feat: add docs skill

Fix MCP operations not tracked for usage metering (#334 )
2026-02-10 12:33:16 +01:00 · 2026-02-10 12:30:04 +01:00 · 2026-02-10 09:38:15 +01:00 · 2026-02-09 21:28:29 +01:00 · 2026-02-09 11:18:30 -07:00 · 2026-02-09 18:03:37 +01:00
415 changed files with 49702 additions and 4808 deletions
@@ -2,7 +2,7 @@
 # Copy this file to .env and fill in your values

 # LLM Configuration (Required)
-# Supported providers: openai, groq, ollama, gemini, anthropic, lmstudio
+# Supported providers: openai, groq, ollama, gemini, anthropic, lmstudio, vertexai
 HINDSIGHT_API_LLM_PROVIDER=openai
 HINDSIGHT_API_LLM_API_KEY=your-api-key-here
 HINDSIGHT_API_LLM_MODEL=o3-mini
@@ -13,6 +13,13 @@ HINDSIGHT_API_LLM_BASE_URL=https://api.openai.com/v1
 # HINDSIGHT_API_LLM_API_KEY=your-anthropic-api-key
 # HINDSIGHT_API_LLM_MODEL=claude-sonnet-4-20250514

+# Example: Google Vertex AI configuration
+# HINDSIGHT_API_LLM_PROVIDER=vertexai
+# HINDSIGHT_API_LLM_MODEL=google/gemini-2.0-flash-001
+# HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID=your-gcp-project-id
+# HINDSIGHT_API_LLM_VERTEXAI_REGION=us-central1
+# HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY=/path/to/service-account-key.json  # Optional, uses ADC if not set
+
 # Example: LM Studio local configuration (Qwen 2.5 32B recommended)
 # HINDSIGHT_API_LLM_PROVIDER=lmstudio
 # HINDSIGHT_API_LLM_API_KEY=lmstudio
@@ -26,6 +33,7 @@ HINDSIGHT_API_LOG_LEVEL=info

 # Database (Optional - uses embedded pg0 by default)
 # HINDSIGHT_API_DATABASE_URL=postgresql://user:pass@host:5432/db
+# HINDSIGHT_API_DATABASE_SCHEMA=public  # PostgreSQL schema name (default: public)

 # Embeddings Configuration (Optional - uses local by default)
 # Provider: "local" (default) or "tei" (HuggingFace Text Embeddings Inference)
@@ -139,6 +139,104 @@ jobs:
        path: hindsight-clients/typescript/*.tgz
        retention-days: 1

+  release-openclaw-integration:
+    runs-on: ubuntu-latest
+    environment: npm
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+        registry-url: 'https://registry.npmjs.org'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm ci
+
+    - name: Build
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm run build
+
+    - name: Publish to npm
+      working-directory: ./hindsight-integrations/openclaw
+      run: |
+        set +e
+        OUTPUT=$(npm publish --access public 2>&1)
+        EXIT_CODE=$?
+        echo "$OUTPUT"
+        if [ $EXIT_CODE -ne 0 ]; then
+          if echo "$OUTPUT" | grep -q "cannot publish over"; then
+            echo "Package version already published, skipping..."
+            exit 0
+          fi
+          exit $EXIT_CODE
+        fi
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+    - name: Pack for GitHub release
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm pack
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: openclaw-integration
+        path: hindsight-integrations/openclaw/*.tgz
+        retention-days: 1
+
+  release-ai-sdk-integration:
+    runs-on: ubuntu-latest
+    environment: npm
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+        registry-url: 'https://registry.npmjs.org'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm ci
+
+    - name: Build
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm run build
+
+    - name: Publish to npm
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: |
+        set +e
+        OUTPUT=$(npm publish --access public 2>&1)
+        EXIT_CODE=$?
+        echo "$OUTPUT"
+        if [ $EXIT_CODE -ne 0 ]; then
+          if echo "$OUTPUT" | grep -q "cannot publish over"; then
+            echo "Package version already published, skipping..."
+            exit 0
+          fi
+          exit $EXIT_CODE
+        fi
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+    - name: Pack for GitHub release
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm pack
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: ai-sdk-integration
+        path: hindsight-integrations/ai-sdk/*.tgz
+        retention-days: 1
+
  release-control-plane:
    runs-on: ubuntu-latest
    environment: npm
@@ -242,6 +340,7 @@ jobs:
        retention-days: 1

  release-docker-images:
+    name: Release Docker (${{ matrix.image_name }}${{ matrix.tag_suffix }})
    runs-on: ubuntu-latest
    permissions:
      contents: read
@@ -251,10 +350,28 @@ jobs:
        include:
          - target: api-only
            image_name: hindsight-api
+            tag_suffix: ""
+            build_args: ""
+          - target: api-only
+            image_name: hindsight-api
+            tag_suffix: "-slim"
+            build_args: |
+              INCLUDE_LOCAL_MODELS=false
+              PRELOAD_ML_MODELS=false
          - target: cp-only
            image_name: hindsight-control-plane
+            tag_suffix: ""
+            build_args: ""
          - target: standalone
            image_name: hindsight
+            tag_suffix: ""
+            build_args: ""
+          - target: standalone
+            image_name: hindsight
+            tag_suffix: "-slim"
+            build_args: |
+              INCLUDE_LOCAL_MODELS=false
+              PRELOAD_ML_MODELS=false

    steps:
    - uses: actions/checkout@v4
@@ -292,6 +409,9 @@ jobs:
      uses: docker/metadata-action@v5
      with:
        images: ghcr.io/${{ github.repository_owner }}/${{ matrix.image_name }}
+        flavor: |
+          latest=auto
+          suffix=${{ matrix.tag_suffix }}
        tags: |
          type=semver,pattern={{version}},value=${{ steps.get_version.outputs.VERSION }}
          type=semver,pattern={{major}}.{{minor}},value=${{ steps.get_version.outputs.VERSION }}
@@ -317,7 +437,7 @@ jobs:
    # - name: Smoke test - verify container starts
    #   env:
    #     GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
-    #   run: ./scripts/docker-smoke-test.sh "${{ matrix.image_name }}:test" "${{ matrix.target }}"
+    #   run: ./docker/test-image.sh "${{ matrix.image_name }}:test" "${{ matrix.target }}"

    # Build multi-platform and push to release tags
    - name: Build and push release images
@@ -326,6 +446,7 @@ jobs:
        context: .
        file: docker/standalone/Dockerfile
        target: ${{ matrix.target }}
+        build-args: ${{ matrix.build_args }}
        push: true
        platforms: linux/amd64,linux/arm64
        tags: ${{ steps.meta.outputs.tags }}
@@ -366,7 +487,7 @@ jobs:

  create-github-release:
    runs-on: ubuntu-latest
-    needs: [release-python-packages, release-typescript-client, release-control-plane, release-rust-cli, release-docker-images, release-helm-chart]
+    needs: [release-python-packages, release-typescript-client, release-openclaw-integration, release-ai-sdk-integration, release-control-plane, release-rust-cli, release-docker-images, release-helm-chart]
    permissions:
      contents: write

@@ -389,6 +510,18 @@ jobs:
        name: typescript-client
        path: ./artifacts/typescript-client

+    - name: Download OpenClaw Integration
+      uses: actions/download-artifact@v4
+      with:
+        name: openclaw-integration
+        path: ./artifacts/openclaw-integration
+
+    - name: Download AI SDK Integration
+      uses: actions/download-artifact@v4
+      with:
+        name: ai-sdk-integration
+        path: ./artifacts/ai-sdk-integration
+
    - name: Download Control Plane
      uses: actions/download-artifact@v4
      with:
@@ -430,6 +563,10 @@ jobs:
        cp artifacts/python-packages/hindsight-embed/dist/* release-assets/ || true
        # TypeScript client
        cp artifacts/typescript-client/*.tgz release-assets/ || true
+        # OpenClaw Integration
+        cp artifacts/openclaw-integration/*.tgz release-assets/ || true
+        # AI SDK Integration
+        cp artifacts/ai-sdk-integration/*.tgz release-assets/ || true
        # Control Plane
        cp artifacts/control-plane/*.tgz release-assets/ || true
        # Rust CLI binaries
@@ -9,42 +9,11 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  build-python-packages:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - name: hindsight-all
-            path: hindsight
-          - name: hindsight-api
-            path: hindsight-api
-          - name: hindsight-client
-            path: hindsight-clients/python
-          - name: hindsight-embed
-            path: hindsight-embed
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version-file: ".python-version"
-
-    - name: Build ${{ matrix.name }}
-      working-directory: ./${{ matrix.path }}
-      run: uv build
-
  build-api-python-versions:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        python-version: ['3.11', '3.12', '3.13']
+        python-version: ['3.11', '3.12', '3.13', '3.14']

    steps:
    - uses: actions/checkout@v4
@@ -82,6 +51,52 @@ jobs:
    - name: Build TypeScript client
      run: npm run build --workspace=hindsight-clients/typescript

+  build-openclaw-integration:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm ci
+
+    - name: Run tests
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm test
+
+    - name: Build
+      working-directory: ./hindsight-integrations/openclaw
+      run: npm run build
+
+  build-ai-sdk-integration:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm ci
+
+    - name: Run tests
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm test
+
+    - name: Build
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm run build
+
  build-control-plane:
    runs-on: ubuntu-latest

@@ -262,16 +277,35 @@ jobs:
      run: helm lint helm/hindsight

  build-docker-images:
+    name: Build Docker (${{ matrix.name }})
    runs-on: ubuntu-latest
    strategy:
      matrix:
        include:
          - target: api-only
            name: api
+            variant: full
+            build_args: ""
+          - target: api-only
+            name: api-slim
+            variant: slim
+            build_args: |
+              INCLUDE_LOCAL_MODELS=false
+              PRELOAD_ML_MODELS=false
          - target: cp-only
            name: control-plane
+            variant: full
+            build_args: ""
          - target: standalone
            name: standalone
+            variant: full
+            build_args: ""
+          - target: standalone
+            name: standalone-slim
+            variant: slim
+            build_args: |
+              INCLUDE_LOCAL_MODELS=false
+              PRELOAD_ML_MODELS=false

    steps:
    - uses: actions/checkout@v4
@@ -290,20 +324,31 @@ jobs:
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3

-    - name: Build ${{ matrix.name }} image
+    - name: Build ${{ matrix.name }} image (${{ matrix.variant }})
      uses: docker/build-push-action@v6
      with:
        context: .
        file: docker/standalone/Dockerfile
        target: ${{ matrix.target }}
+        build-args: ${{ matrix.build_args }}
        push: false
-        load: false
+        load: ${{ matrix.variant == 'slim' }}
+        tags: hindsight-${{ matrix.name }}:test
+        # Removed GitHub Actions cache (type=gha) - it frequently returns 502 errors
+        # causing buildx to fail with "failed to parse error response 502"
+        # Build will be slower but more reliable

-    # TODO: Re-enable smoke test when disk space issue is resolved
-    # - name: Smoke test - verify container starts
-    #   env:
-    #     GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
-    #   run: ./scripts/docker-smoke-test.sh "hindsight-${{ matrix.name }}:test" "${{ matrix.target }}"
+    # Only test slim variants to save disk space (they're much smaller)
+    # Slim variants require external embedding providers
+    - name: Smoke test - verify container starts
+      if: matrix.variant == 'slim'
+      env:
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        HINDSIGHT_API_EMBEDDINGS_PROVIDER: openai
+        HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        HINDSIGHT_API_RERANKER_PROVIDER: cohere
+        HINDSIGHT_API_COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+      run: ./docker/test-image.sh "hindsight-${{ matrix.name }}:test" "${{ matrix.target }}"

  test-api:
    runs-on: ubuntu-latest
@@ -726,9 +771,9 @@ jobs:
  test-embed:
    runs-on: ubuntu-latest
    env:
-      HINDSIGHT_EMBED_LLM_PROVIDER: groq
-      HINDSIGHT_EMBED_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
-      HINDSIGHT_EMBED_LLM_MODEL: openai/gpt-oss-20b
+      HINDSIGHT_API_LLM_PROVIDER: groq
+      HINDSIGHT_API_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
+      HINDSIGHT_API_LLM_MODEL: openai/gpt-oss-20b
      # Prefer CPU-only PyTorch in CI
      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu

@@ -759,10 +804,62 @@ jobs:
          ${{ runner.os }}-huggingface-embed-
          ${{ runner.os }}-huggingface-

+    - name: Run unit and integration tests
+      working-directory: ./hindsight-embed
+      run: uv run pytest tests/ -v
+
    - name: Run smoke test
      working-directory: ./hindsight-embed
      run: ./test.sh

+  test-hindsight-all:
+    runs-on: ubuntu-latest
+    env:
+      HINDSIGHT_API_LLM_PROVIDER: groq
+      HINDSIGHT_API_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
+      HINDSIGHT_API_LLM_MODEL: openai/gpt-oss-20b
+      # For test_server_integration.py compatibility
+      HINDSIGHT_LLM_PROVIDER: groq
+      HINDSIGHT_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
+      HINDSIGHT_LLM_MODEL: openai/gpt-oss-20b
+      # Prefer CPU-only PyTorch in CI
+      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+        prune-cache: false
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version-file: ".python-version"
+
+    - name: Build hindsight-all
+      working-directory: ./hindsight
+      run: uv build
+
+    - name: Install dependencies
+      working-directory: ./hindsight
+      run: uv sync --frozen --extra test --index-strategy unsafe-best-match
+
+    - name: Cache HuggingFace models
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/huggingface
+        key: ${{ runner.os }}-huggingface-all-${{ hashFiles('hindsight/pyproject.toml') }}
+        restore-keys: |
+          ${{ runner.os }}-huggingface-all-
+          ${{ runner.os }}-huggingface-
+
+    - name: Run unit tests
+      working-directory: ./hindsight
+      run: uv run pytest tests/ -v
+
  test-doc-examples:
    runs-on: ubuntu-latest
    needs: test-rust-cli
@@ -935,6 +1032,18 @@ jobs:
      working-directory: ./hindsight-dev
      run: uv run pytest upgrade_tests/ -v --tb=short

+    - name: Show upgrade test logs
+      if: always()
+      run: |
+        echo "=== Upgrade Test Server Logs ==="
+        for log in /tmp/upgrade-test-*.log; do
+          if [ -f "$log" ]; then
+            echo ""
+            echo "--- $log ---"
+            tail -500 "$log"
+          fi
+        done
+
  verify-generated-files:
    runs-on: ubuntu-latest
    env:
@@ -1005,4 +1114,52 @@ jobs:
          git diff --stat
          exit 1
        fi
-        echo "✓ All generated files are up to date"
+        echo "✓ All generated files are up to date"
+
+  check-openapi-compatibility:
+    runs-on: ubuntu-latest
+    env:
+      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch full git history to access base branch
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version-file: ".python-version"
+
+    - name: Install hindsight-dev dependencies
+      run: |
+        cd hindsight-dev && uv sync --frozen --index-strategy unsafe-best-match
+
+    - name: Check OpenAPI compatibility with base branch
+      run: |
+        # Get the base branch (usually main)
+        BASE_BRANCH="${{ github.base_ref }}"
+
+        if [ -z "$BASE_BRANCH" ]; then
+          echo "⚠️  Warning: No base branch found (not a PR?). Skipping compatibility check."
+          exit 0
+        fi
+
+        echo "Checking OpenAPI compatibility against base branch: $BASE_BRANCH"
+
+        # Extract the old OpenAPI spec from base branch
+        git show "origin/$BASE_BRANCH:hindsight-docs/static/openapi.json" > /tmp/old-openapi.json
+
+        if [ ! -s /tmp/old-openapi.json ]; then
+          echo "⚠️  Warning: Could not find OpenAPI spec in base branch. Skipping compatibility check."
+          exit 0
+        fi
+
+        # Check compatibility using our tool
+        cd hindsight-dev
+        uv run check-openapi-compatibility /tmp/old-openapi.json ../hindsight-docs/static/openapi.json
@@ -45,10 +45,14 @@ hindsight-docs/static/llms-full.txt

 hindsight-dev/benchmarks/locomo/results/
 hindsight-dev/benchmarks/longmemeval/results/
+hindsight-dev/benchmarks/consolidation/results/
+benchmarks/results/
 hindsight-cli/target
 hindsight-clients/rust/target
 .claude
 whats-next.md
 TASK.md
 # Changelog is now tracked in hindsight-docs/src/pages/changelog.md
-# CHANGELOG.md
+# CHANGELOG.md
+
+blog-post*
@@ -93,6 +93,34 @@ uv run ty check hindsight_api  # Type check
 3. Run tests to ensure nothing breaks
 4. Submit a PR with a clear description of changes

+## Release Process
+
+The project uses `scripts/release.sh` for creating releases. This script automates the entire release workflow:
+
+1. Bumps version in all components (API, clients, CLI, control plane, Helm)
+2. **Regenerates OpenAPI spec and client SDKs** (Python, TypeScript, Rust)
+3. Updates documentation versioning
+4. Creates a commit and git tag
+5. Pushes to GitHub (triggers CI/CD to publish packages)
+
+### Usage
+
+```bash
+./scripts/release.sh <version>
+```
+
+**Example:**
+```bash
+./scripts/release.sh 0.5.0
+```
+
+### Important for Developers
+
+- During development, version bumps in `__init__.py` do NOT require client regeneration
+- Clients are only regenerated during releases
+- Do not manually run `./scripts/generate-clients.sh` unless testing generation changes
+- Client version comments will reflect the API version from the latest release
+
 ## Reporting Issues

 Open an issue on GitHub with:
@@ -1,6 +1,6 @@
 <div align="center">

-![Hindsight Banner](./hindsight-docs/static/img/banner.svg)
+![Hindsight Banner](./hindsight-docs/static/img/hindsight-github-banner.png)

 [Documentation](https://hindsight.vectorize.io) • [Paper](https://arxiv.org/abs/2512.12818) • [Cookbook](https://hindsight.vectorize.io/cookbook) • [Hindsight Cloud](https://vectorize.io/hindsight/cloud)

@@ -17,76 +17,76 @@

 ## What is Hindsight?

-Hindsight™ is an agent memory system built to create smarter agents that learn over time. It eliminates the shortcomings of alternative techniques such as RAG and knowledge graph and delivers state-of-the-art performance on long term memory tasks.
+Hindsight™ is an agent memory system built to create smarter agents that learn over time. Most agent memory systems focus on recalling conversation history. Hindsight is focused on making agents that learn, not just remember.

-Hindsight addresses common challenges that have frustrated AI engineers building agents to automate tasks and assist users with conversational interfaces. Many of these challenges stem directly from a lack of memory.

- **Inconsistency:** Agents complete tasks successfully one time, then fail when asked to complete the same task again. Memory gives the agent a mechanism to remember what worked and what didn't and to use that information to reduce errors and improve consistency.
- **Hallucinations:** Long term memory can be seeded with external knowledge to ground agent behavior in reliable sources to augment training data.
- **Cognitive Overload:** As workflows get complex, retrievals, tool calls, user messages and agent responses can grow to fill the context window leading to context rot. Short term memory optimization allows agents to reduce tokens and focus context by removing irrelevant details.
+<video src="https://github.com/user-attachments/assets/923b798d-3581-4897-bb62-9cfa5a931682" controls></video>

-## How is Hindsight Different From Other Memory Systems?
-
-![Overview](./hindsight-docs/static/img/hindsight-overview.webp)
-
-Most agent memory implementation rely on basic vector search or sometimes use a knowledge graph. Hindsight uses biomimetic data structures to organize agent memories in a way that is more like how human memory works:
-
- **World:** Facts about the world ("The stove gets hot")
- **Experiences:** Agent's own experiences ("I touched the stove and it really hurt")
- **Opinion:** Beliefs with confidence scores ("I shouldn't touch the stove again" - .99 confidence)
- **Observation:** Complex mental models derived by reflecting on facts and experiences ("Curling irons, ovens, and fire are also hot. I shouldn't touch those either.")
-
-Memories in Hindsight are stored in banks (i.e. memory banks). When memories are added to Hindsight, they are pushed into either the world facts or experiences memory pathway. They are then represented as a combination of entities, relationships, and time series with sparse/dense vector representations to aid in later recall.
-
-Hindsight provides three simple methods to interact with the system:
-
- **Retain:** Provide information to Hindsight that you want it to remember
- **Recall:** Retrieve memories from Hindsight
- **Reflect:** Reflect on memories and experiences to generate new observations and insights from existing memories.
-
-### Agent Memory That Learns
-
-A key goal of Hindsight is to build agent memory that enables agents to learn and improve over time. This is the role of the `reflect` operation which provides the agent to form broader opinions and observations over time.
-
-For example, imagine a product support agent that is helping a user troubleshoot a problem. It uses a `search-documentation` tool it found on an MCP server. Later in the conversation, the agent discovers that the documentation returned from the tool wasn't for the product the user was asking about. The agent now has an experience in its memory bank. And just like humans, we want that agent to learn from its experience.
-
-As the agent gains more experiences, `reflect` allows the agent to form observations about what worked, what didn't, and what to do differently the next time it encounters a similar task.
-
---
+It eliminates the shortcomings of alternative techniques such as RAG and knowledge graph and delivers state-of-the-art performance on long term memory tasks.

 ## Memory Performance & Accuracy

-Hindsight has achieved state-of-the-art performance on the LongMemEval benchmark, widely used to assess memory system performance across a variety of conversational
-AI scenarios. The current reported performance of Hindsight and other agent memory solutions as of December 2025 is shown here:
+Hindsight is the most accurate agent memory system ever tested according to benchmark performance. It has achieved state-of-the-art performance on the LongMemEval benchmark, widely used to assess memory system performance across a variety of conversational AI scenarios. The current reported performance of Hindsight and other agent memory solutions as of January 2026 is shown here:

 ![Overview](./hindsight-docs/static/img/hindsight-bench.jpg)

-The benchmark performance data for Hindsight and GPT-4o (full context) have been reproduced by research collaborators at the Virginia Tech [Sanghani Center for Artificial Intelligence and Data Analytics](https://sanghani.cs.vt.edu/) and The Washington Post. Other scores are self-reported by software vendors.
+The benchmark performance data for Hindsight has been independently reproduced by research collaborators at the Virginia Tech [Sanghani Center for Artificial Intelligence and Data Analytics](https://sanghani.cs.vt.edu/) and The Washington Post. Other scores are self-reported by software vendors.

-A thorough examination of the techniques implemented in Hindsight and detailed breakdowns of benchmark performance are [available on arXiv](https://arxiv.org/abs/2512.12818). This research is currently being prepared for conference submission and the wider peer review process.
+Hindsight is being used in production at Fortune 500 enterprises and by a growing number of AI startups. 
+
+## Adding Hindsight to Your AI Agents
+
+The easiest way use Hindsight with an existing agent is with the LLM Wrapper. You can add memory to your agent with 2 lines of code. That will swap your current LLM client out with the Hindsight wrapper. After that, memories will be stored and retrieved automatically as you make LLM calls.
+
+If you need more control over how and when your agent stores and recalls memories, there's also a simple API you can integrate with using the SDKs or directly via HTTP.
+
+![Hindsight Banner](./hindsight-docs/static/img/migration-code.png)
+
+---
+
+> 🤖 **Using a coding agent?** Install the Hindsight documentation skill for instant access to docs while you code:
+> ```bash
+> npx skills add https://github.com/vectorize-io/hindsight --skill hindsight-docs
+> ```
+> Works with Claude Code, Cursor, and other AI coding assistants.
+
+---

-The benchmark results from this research can be inspected in our [visual benchmark explorer](https://hindsight-benchmarks.vercel.app). As additional improvements are made to Hindsight, new benchmark data will be available for review using this same tool.

 ## Quick Start

 ### Docker (recommended)

 ```bash
-export OPENAI_API_KEY=your-key
+export OPENAI_API_KEY=sk-xxx

 docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \
  -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \
-  -e HINDSIGHT_API_LLM_MODEL=o3-mini \
  -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \
  ghcr.io/vectorize-io/hindsight:latest
 ```

+>API: http://localhost:8888
+>UI: http://localhost:9999
+
 You can modify the LLM provider by setting `HINDSIGHT_API_LLM_PROVIDER`. Valid options are `openai`, `anthropic`, `gemini`, `groq`, `ollama`, and `lmstudio`. The documentation provides more details on [supported models](https://hindsight.vectorize.io/developer/models).

-API: http://localhost:8888  
-UI: http://localhost:9999

-Install client:
+
+### Docker (external PostgreSQL)
+
+```bash
+export OPENAI_API_KEY=sk-xxx
+export HINDSIGHT_DB_PASSWORD=choose-a-password
+cd docker/docker-compose
+docker compose up 
+```
+
+
+>API: http://localhost:8888
+>UI: http://localhost:9999
+
+### Client

 ```bash
 pip install hindsight-client -U
@@ -94,7 +94,7 @@ pip install hindsight-client -U
 npm install @vectorize-io/hindsight-client
 ```

-Python example:
+#### Python

 ```python
 from hindsight_client import Hindsight
@@ -111,7 +111,29 @@ client.recall(bank_id="my-bank", query="What does Alice do?")
 client.reflect(bank_id="my-bank", query="Tell me about Alice")
 ```

-### Python (embedded, no Docker)
+#### Node.js / TypeScript
+
+```bash
+npm install @vectorize-io/hindsight-client
+```
+
+```javascript
+const { HindsightClient } = require('@vectorize-io/hindsight-client');
+
+const main = async () => {
+  const client = new HindsightClient({ baseUrl: 'http://localhost:8888' });
+
+  await client.retain('my-bank', 'Alice loves hiking in Yosemite');
+
+  const results = await client.recall('my-bank', 'What does Alice like?');
+  console.log(results);
+}
+
+main();
+```
+
+
+### Python Embedded (no server required)

 ```bash
 pip install hindsight-all -U
@@ -131,25 +153,48 @@ with HindsightServer(
    results = client.recall(bank_id="my-bank", query="Where does Alice work?")
 ```

-### Node.js / TypeScript

-```bash
-npm install @vectorize-io/hindsight-client
-```
+---

-```javascript
-const { HindsightClient } = require('@vectorize-io/hindsight-client');
+## Use Cases

-const client = new HindsightClient({ baseUrl: 'http://localhost:8888' });

-await client.retain('my-bank', 'Alice loves hiking in Yosemite');
-await client.recall('my-bank', 'What does Alice like?');
-```
+Hindsight is built to support conversational AI agents as well as agents that are intended to perform tasks autonomously. The ideal use case for Hindsight are agents that require a blend of these features such as AI employees that need to handle open-ended tasks, change behavior based on user feedback, and learn to perform complex tasks to automate work at a level that approximates a human work. Hindsight can be used with simple AI workflows like those built with n8n and other similar tools, but may be overkill for such applications.
+
+### Per-User Memories and Chat History
+
+One of the simpler use cases you can use Hindsight for is to personalize AI chatbots and other conversational agents by storing and recalling memories associated with individual users.
+
+The requirements for this use case usually look something like this:
+
+![Per-User Memories](./hindsight-docs/static/img/per-user-memory-requirements.png)
+
+<video src="https://github.com/user-attachments/assets/4805e8e1-e7d1-47c6-a4f8-2344a5ec8906" controls></video>
+
+Satisfying these requirements in Hindsight is straightforward. When new user inputs and tool calls are ingested into Hindsight using the retain operation, custom metadata can be used to enrich the new memories. Metadata provides a convenient way to isolate memories that need to be restricted to a given user. Once these are fed into the retain operation, any raw memories and mental models that get created can be filtered when retrieving relevant memories. 
+
+![Per-User Memories](./hindsight-docs/static/img/per-user-memory-howto.png)

 ---

 ## Architecture & Operations

+![Overview](./hindsight-docs/static/img/hindsight-overview.webp)
+
+Most agent memory implementation rely on basic vector search or sometimes use a knowledge graph. Hindsight uses biomimetic data structures to organize agent memories in a way that is more like how human memory works:
+
+- **World:** Facts about the world ("The stove gets hot")
+- **Experiences:** Agent's own experiences ("I touched the stove and it really hurt")
+- **Mental Models:** Learned understanding of the agent's world formed by reflecting on raw memories and experiences.
+
+Memories in Hindsight are stored in banks (i.e. memory banks). When memories are added to Hindsight, they are pushed into either the world facts or experiences memory pathway. They are then represented as a combination of entities, relationships, and time series with sparse/dense vector representations to aid in later recall.
+
+Hindsight provides three simple methods to interact with the system:
+
+- **Retain:** Provide information to Hindsight that you want it to remember
+- **Recall:** Retrieve memories from Hindsight
+- **Reflect:** Reflect on memories and experiences to generate new observations and insights from existing memories.
+
 ### Retain

 The `retain` operation is used to push new memories into Hindsight. It tells Hindsight to _retain_ the information you pass in as an input.
@@ -208,7 +253,7 @@ The final output is trimmed as needed to fit within the token limit.

 ### Reflect

-The reflect operation is used to perform a more thorough analysis of existing memories. This allows the agent to form new connections between memories which are then persisted as opinions and/or observations. When building agents, the reflect operation is a key capability to enable the agent to learn from its experiences. 
+The reflect operation is used to perform a more thorough analysis of existing memories. This allows the agent to form new connections between memories and build a more thorough understanding of its world.

 For example, the `reflect` operation can be used to support use cases such as:

@@ -0,0 +1,54 @@
+# Docker Compose file for Hindsight with PostgreSQL and pgvector
+#
+# Make sure to set the required environment variables before running:
+# - HINDSIGHT_DB_PASSWORD: Password for the PostgreSQL user
+# - Configure LLM provider variables as needed (see below in the hindsight service)
+#
+# Usage:
+# docker compose up -d
+#
+# Optional environment variables with defaults:
+# - HINDSIGHT_VERSION: Hindsight application version (default: latest)
+# - HINDSIGHT_DB_USER: PostgreSQL user (default: hindsight_user)
+# - HINDSIGHT_DB_NAME: PostgreSQL database name (default: hindsight_db)
+# - HINDSIGHT_DB_VERSION: PostgreSQL version (default: 18)
+
+services:
+  db:
+    # Use a PostgreSQL-Image with pgvector extension pre-installed
+    # see https://hub.docker.com/r/pgvector/pgvector 
+    image: pgvector/pgvector:pg${HINDSIGHT_DB_VERSION:-18}
+    container_name: hindsight-db
+    restart: always
+    # Expose PostgreSQL port
+    # ports:
+      # - "5432:5432"
+    environment:
+      POSTGRES_USER: ${HINDSIGHT_DB_USER:-hindsight_user}
+      POSTGRES_PASSWORD: ${HINDSIGHT_DB_PASSWORD:?Please set the HINDSIGHT_DB_PASSWORD env variable}
+      POSTGRES_DB: ${HINDSIGHT_DB_NAME:-hindsight_db}
+    volumes:
+      - pg_data:/var/lib/postgresql/${HINDSIGHT_DB_VERSION:-18}/docker
+    networks:
+      - hindsight-net
+
+  hindsight:
+    image: ghcr.io/vectorize-io/hindsight:${HINDSIGHT_VERSION:-latest}
+    container_name: hindsight-app
+    ports:
+      - "8888:8888"
+      - "9999:9999"
+    environment:
+      - HINDSIGHT_API_LLM_API_KEY=${OPENAI_API_KEY?Please set the OPENAI_API_KEY env variable}
+      - HINDSIGHT_API_DATABASE_URL=postgresql://${HINDSIGHT_DB_USER:-hindsight_user}:${HINDSIGHT_DB_PASSWORD:?Please set the HINDSIGHT_DB_PASSWORD env variable}@db:5432/${HINDSIGHT_DB_NAME:-hindsight_db}
+    depends_on:
+      - db
+    networks:
+      - hindsight-net
+
+networks:
+  hindsight-net:
+    driver: bridge
+
+volumes:
+  pg_data:
@@ -169,16 +169,34 @@ ENV PATH="/app/api/.venv/bin:${PATH}"

 # Pre-download ML models to avoid runtime download (conditional)
 # Only runs if both PRELOAD_ML_MODELS=true AND INCLUDE_LOCAL_MODELS=true
+# Includes retry logic with exponential backoff for transient network failures
 ARG PRELOAD_ML_MODELS
 ARG INCLUDE_LOCAL_MODELS
+ENV HF_HUB_DOWNLOAD_TIMEOUT=600
 RUN if [ "$PRELOAD_ML_MODELS" = "true" ] && [ "$INCLUDE_LOCAL_MODELS" = "true" ]; then \
-    /app/api/.venv/bin/python -c "\
+    MAX_RETRIES=3; \
+    RETRY_DELAY=10; \
+    for i in $(seq 1 $MAX_RETRIES); do \
+      echo "Attempt $i/$MAX_RETRIES: Downloading ML models..."; \
+      /app/api/.venv/bin/python -c "\
+import os; os.environ['HF_HUB_DOWNLOAD_TIMEOUT'] = '600'; \
 from sentence_transformers import SentenceTransformer, CrossEncoder; \
 print('Downloading embedding model...'); \
 SentenceTransformer('BAAI/bge-small-en-v1.5'); \
 print('Downloading cross-encoder model...'); \
 CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2'); \
-print('Models cached successfully')"; \
+print('Downloading tiktoken encoding...'); import tiktoken; tiktoken.get_encoding('cl100k_base'); \
+print('Models cached successfully')" && break; \
+      if [ $i -lt $MAX_RETRIES ]; then \
+        echo "Attempt $i failed, retrying in ${RETRY_DELAY}s..."; \
+        sleep $RETRY_DELAY; \
+        RETRY_DELAY=$((RETRY_DELAY * 2)); \
+      fi; \
+    done; \
+    if [ $i -eq $MAX_RETRIES ] && ! /app/api/.venv/bin/python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('BAAI/bge-small-en-v1.5')" 2>/dev/null; then \
+      echo "ERROR: Failed to download models after $MAX_RETRIES attempts"; \
+      exit 1; \
+    fi; \
    elif [ "$INCLUDE_LOCAL_MODELS" != "true" ]; then echo "Skipping ML model preload (local-models not included)"; \
    else echo "Skipping ML model preload"; fi

@@ -190,6 +208,10 @@ ENV HINDSIGHT_API_LOG_LEVEL=info
 ENV HINDSIGHT_ENABLE_API=true
 ENV HINDSIGHT_ENABLE_CP=false
 ENV PYTHONUNBUFFERED=1
+# Suppress verbose transformers/HuggingFace model loading warnings
+ENV TRANSFORMERS_VERBOSITY=error
+ENV HF_HUB_VERBOSITY=error
+ENV TOKENIZERS_PARALLELISM=false

 CMD ["/app/start-all.sh"]

@@ -277,16 +299,34 @@ ENV PATH="/app/api/.venv/bin:${PATH}"

 # Pre-download ML models to avoid runtime download (conditional)
 # Only runs if both PRELOAD_ML_MODELS=true AND INCLUDE_LOCAL_MODELS=true
+# Includes retry logic with exponential backoff for transient network failures
 ARG PRELOAD_ML_MODELS
 ARG INCLUDE_LOCAL_MODELS
+ENV HF_HUB_DOWNLOAD_TIMEOUT=600
 RUN if [ "$PRELOAD_ML_MODELS" = "true" ] && [ "$INCLUDE_LOCAL_MODELS" = "true" ]; then \
-    /app/api/.venv/bin/python -c "\
+    MAX_RETRIES=3; \
+    RETRY_DELAY=10; \
+    for i in $(seq 1 $MAX_RETRIES); do \
+      echo "Attempt $i/$MAX_RETRIES: Downloading ML models..."; \
+      /app/api/.venv/bin/python -c "\
+import os; os.environ['HF_HUB_DOWNLOAD_TIMEOUT'] = '600'; \
 from sentence_transformers import SentenceTransformer, CrossEncoder; \
 print('Downloading embedding model...'); \
 SentenceTransformer('BAAI/bge-small-en-v1.5'); \
 print('Downloading cross-encoder model...'); \
 CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2'); \
-print('Models cached successfully')"; \
+print('Downloading tiktoken encoding...'); import tiktoken; tiktoken.get_encoding('cl100k_base'); \
+print('Models cached successfully')" && break; \
+      if [ $i -lt $MAX_RETRIES ]; then \
+        echo "Attempt $i failed, retrying in ${RETRY_DELAY}s..."; \
+        sleep $RETRY_DELAY; \
+        RETRY_DELAY=$((RETRY_DELAY * 2)); \
+      fi; \
+    done; \
+    if [ $i -eq $MAX_RETRIES ] && ! /app/api/.venv/bin/python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('BAAI/bge-small-en-v1.5')" 2>/dev/null; then \
+      echo "ERROR: Failed to download models after $MAX_RETRIES attempts"; \
+      exit 1; \
+    fi; \
    elif [ "$INCLUDE_LOCAL_MODELS" != "true" ]; then echo "Skipping ML model preload (local-models not included)"; \
    else echo "Skipping ML model preload"; fi

@@ -300,6 +340,10 @@ ENV HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:8888
 ENV HINDSIGHT_ENABLE_API=true
 ENV HINDSIGHT_ENABLE_CP=true
 ENV PYTHONUNBUFFERED=1
+# Suppress verbose transformers/HuggingFace model loading warnings
+ENV TRANSFORMERS_VERBOSITY=error
+ENV HF_HUB_VERBOSITY=error
+ENV TOKENIZERS_PARALLELISM=false

 CMD ["/app/start-all.sh"]

@@ -6,28 +6,40 @@
 # Can be run locally or in CI pipelines.
 #
 # Usage:
-#   ./scripts/docker-smoke-test.sh <image> [target]
+#   ./docker/test-image.sh <image> [target]
 #
 # Arguments:
 #   image   - Docker image to test (e.g., hindsight-api:test, ghcr.io/vectorize-io/hindsight:latest)
 #   target  - Optional: 'cp-only' for control plane, otherwise assumes API image (default: api)
 #
 # Environment variables:
-#   GROQ_API_KEY              - Required for API/standalone images (LLM verification)
-#   HINDSIGHT_API_LLM_PROVIDER - LLM provider (default: groq)
-#   HINDSIGHT_API_LLM_MODEL    - LLM model (default: llama-3.3-70b-versatile)
-#   SMOKE_TEST_TIMEOUT        - Timeout in seconds (default: 120)
-#   SMOKE_TEST_CONTAINER_NAME - Container name (default: hindsight-smoke-test)
+#   GROQ_API_KEY                                - Required for API/standalone images (LLM verification)
+#   HINDSIGHT_API_LLM_PROVIDER                  - LLM provider (default: groq)
+#   HINDSIGHT_API_LLM_MODEL                     - LLM model (default: llama-3.3-70b-versatile)
+#   HINDSIGHT_API_EMBEDDINGS_PROVIDER           - Embeddings provider (optional, for slim images: openai, cohere, tei)
+#   HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY     - OpenAI API key for embeddings (optional)
+#   HINDSIGHT_API_RERANKER_PROVIDER             - Reranker provider (optional, for slim images: cohere, tei)
+#   HINDSIGHT_API_COHERE_API_KEY                - Cohere API key for reranking (optional)
+#   SMOKE_TEST_TIMEOUT                          - Timeout in seconds (default: 120)
+#   SMOKE_TEST_CONTAINER_NAME                   - Container name (default: hindsight-smoke-test)
 #
 # Examples:
-#   # Test a locally built image
-#   ./scripts/docker-smoke-test.sh hindsight-api:test
+#   # Test a locally built full image
+#   ./docker/test-image.sh hindsight-api:test
 #
 #   # Test a released image
-#   ./scripts/docker-smoke-test.sh ghcr.io/vectorize-io/hindsight:latest
+#   ./docker/test-image.sh ghcr.io/vectorize-io/hindsight:latest
 #
 #   # Test control plane image
-#   ./scripts/docker-smoke-test.sh hindsight-control-plane:test cp-only
+#   ./docker/test-image.sh hindsight-control-plane:test cp-only
+#
+#   # Test slim image with external providers
+#   export GROQ_API_KEY=gsk_xxx
+#   export HINDSIGHT_API_EMBEDDINGS_PROVIDER=openai
+#   export HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=sk-xxx
+#   export HINDSIGHT_API_RERANKER_PROVIDER=cohere
+#   export HINDSIGHT_API_COHERE_API_KEY=xxx
+#   ./docker/test-image.sh hindsight-slim:test
 #
 # Exit codes:
 #   0 - Success (container healthy)
@@ -108,12 +120,32 @@ if [ "$TARGET" = "cp-only" ]; then
        -p "${HEALTH_PORT}:${HEALTH_PORT}" \
        "$IMAGE"
 else
-    docker run -d --name "$CONTAINER_NAME" \
-        -e HINDSIGHT_API_LLM_PROVIDER="$LLM_PROVIDER" \
-        -e HINDSIGHT_API_LLM_API_KEY="${GROQ_API_KEY}" \
-        -e HINDSIGHT_API_LLM_MODEL="$LLM_MODEL" \
-        -p "${HEALTH_PORT}:${HEALTH_PORT}" \
-        "$IMAGE"
+    # Build docker run command with required and optional env vars
+    DOCKER_CMD="docker run -d --name $CONTAINER_NAME"
+    DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_LLM_PROVIDER=$LLM_PROVIDER"
+    DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_LLM_API_KEY=${GROQ_API_KEY}"
+    DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_LLM_MODEL=$LLM_MODEL"
+
+    # Add optional embeddings provider config
+    if [ -n "${HINDSIGHT_API_EMBEDDINGS_PROVIDER:-}" ]; then
+        DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_EMBEDDINGS_PROVIDER=${HINDSIGHT_API_EMBEDDINGS_PROVIDER}"
+    fi
+    if [ -n "${HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY:-}" ]; then
+        DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=${HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY}"
+    fi
+
+    # Add optional reranker provider config
+    if [ -n "${HINDSIGHT_API_RERANKER_PROVIDER:-}" ]; then
+        DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_RERANKER_PROVIDER=${HINDSIGHT_API_RERANKER_PROVIDER}"
+    fi
+    if [ -n "${HINDSIGHT_API_COHERE_API_KEY:-}" ]; then
+        DOCKER_CMD="$DOCKER_CMD -e HINDSIGHT_API_COHERE_API_KEY=${HINDSIGHT_API_COHERE_API_KEY}"
+    fi
+
+    DOCKER_CMD="$DOCKER_CMD -p ${HEALTH_PORT}:${HEALTH_PORT}"
+    DOCKER_CMD="$DOCKER_CMD $IMAGE"
+
+    eval $DOCKER_CMD
 fi

 # Wait for health endpoint
@@ -0,0 +1,51 @@
+#!/bin/bash
+#
+# Local Test Script for Slim Docker Images
+#
+# This script makes it easy to test slim images locally with external providers.
+# It expects API keys to be set in environment variables.
+#
+# Usage:
+#   export GROQ_API_KEY=gsk_xxx
+#   export OPENAI_API_KEY=sk-xxx
+#   export COHERE_API_KEY=xxx
+#   ./docker/test-slim-local.sh
+#
+# Or inline:
+#   GROQ_API_KEY=gsk_xxx OPENAI_API_KEY=sk_xxx COHERE_API_KEY=xxx ./docker/test-slim-local.sh
+#
+
+set -euo pipefail
+
+# Check for required API keys
+if [ -z "${GROQ_API_KEY:-}" ]; then
+    echo "❌ Error: GROQ_API_KEY environment variable is required"
+    echo "Set it with: export GROQ_API_KEY=gsk_xxx"
+    exit 1
+fi
+
+if [ -z "${OPENAI_API_KEY:-}" ]; then
+    echo "❌ Error: OPENAI_API_KEY environment variable is required"
+    echo "Set it with: export OPENAI_API_KEY=sk-xxx"
+    exit 1
+fi
+
+if [ -z "${COHERE_API_KEY:-}" ]; then
+    echo "❌ Error: COHERE_API_KEY environment variable is required"
+    echo "Set it with: export COHERE_API_KEY=xxx"
+    exit 1
+fi
+
+# Configuration
+IMAGE="${1:-hindsight-slim:test}"
+echo "Testing image: $IMAGE"
+echo ""
+
+# Set up external providers
+export HINDSIGHT_API_EMBEDDINGS_PROVIDER=openai
+export HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=$OPENAI_API_KEY
+export HINDSIGHT_API_RERANKER_PROVIDER=cohere
+export HINDSIGHT_API_COHERE_API_KEY=$COHERE_API_KEY
+
+# Run the test
+exec "$(dirname "$0")/test-image.sh" "$IMAGE" standalone
@@ -2,8 +2,8 @@ apiVersion: v2
 name: hindsight
 description: Hindsight helm chart
 type: application
-version: 0.4.0
-appVersion: "0.4.0"
+version: 0.4.10
+appVersion: "0.4.10"
 keywords:
  - ai
  - memory
@@ -33,7 +33,7 @@ spec:
      - name: api
        securityContext:
          {{- toYaml .Values.securityContext | nindent 10 }}
-        image: "{{ .Values.api.image.repository }}:{{ .Values.api.image.tag | default .Values.version }}"
+        image: "{{ .Values.api.image.repository }}:{{ .Values.api.image.tag | default .Values.version | default .Chart.AppVersion }}"
        imagePullPolicy: {{ .Values.api.image.pullPolicy }}
        ports:
        - name: http
@@ -60,6 +60,9 @@ spec:
        - name: HINDSIGHT_API_WORKER_ENABLED
          value: "false"
        {{- end }}
+        {{- /* Explicitly set port to override K8s service discovery env var (HINDSIGHT_API_PORT) */}}
+        - name: HINDSIGHT_API_PORT
+          value: {{ .Values.api.service.targetPort | quote }}
        {{- range $key, $value := .Values.api.env }}
        - name: {{ $key }}
          value: {{ $value | quote }}
@@ -84,7 +87,7 @@ spec:
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
-      {{- with .Values.affinity }}
+      {{- with (.Values.api.affinity | default .Values.affinity) }}
      affinity:
        {{- toYaml . | nindent 8 }}
      {{- end }}
@@ -33,7 +33,7 @@ spec:
      - name: control-plane
        securityContext:
          {{- toYaml .Values.securityContext | nindent 10 }}
-        image: "{{ .Values.controlPlane.image.repository }}:{{ .Values.controlPlane.image.tag | default .Values.version }}"
+        image: "{{ .Values.controlPlane.image.repository }}:{{ .Values.controlPlane.image.tag | default .Values.version | default .Chart.AppVersion }}"
        imagePullPolicy: {{ .Values.controlPlane.image.pullPolicy }}
        ports:
        - name: http
@@ -71,7 +71,7 @@ spec:
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
-      {{- with .Values.affinity }}
+      {{- with (.Values.controlPlane.affinity | default .Values.affinity) }}
      affinity:
        {{- toYaml . | nindent 8 }}
      {{- end }}
@@ -0,0 +1,56 @@
+{{- if and .Values.api.enabled .Values.api.podDisruptionBudget.enabled }}
+apiVersion: policy/v1
+kind: PodDisruptionBudget
+metadata:
+  name: {{ include "hindsight.fullname" . }}-api
+  labels:
+    {{- include "hindsight.api.labels" . | nindent 4 }}
+spec:
+  {{- if .Values.api.podDisruptionBudget.minAvailable }}
+  minAvailable: {{ .Values.api.podDisruptionBudget.minAvailable }}
+  {{- end }}
+  {{- if .Values.api.podDisruptionBudget.maxUnavailable }}
+  maxUnavailable: {{ .Values.api.podDisruptionBudget.maxUnavailable }}
+  {{- end }}
+  selector:
+    matchLabels:
+      {{- include "hindsight.api.selectorLabels" . | nindent 6 }}
+{{- end }}
+---
+{{- if and .Values.controlPlane.enabled .Values.controlPlane.podDisruptionBudget.enabled }}
+apiVersion: policy/v1
+kind: PodDisruptionBudget
+metadata:
+  name: {{ include "hindsight.fullname" . }}-control-plane
+  labels:
+    {{- include "hindsight.controlPlane.labels" . | nindent 4 }}
+spec:
+  {{- if .Values.controlPlane.podDisruptionBudget.minAvailable }}
+  minAvailable: {{ .Values.controlPlane.podDisruptionBudget.minAvailable }}
+  {{- end }}
+  {{- if .Values.controlPlane.podDisruptionBudget.maxUnavailable }}
+  maxUnavailable: {{ .Values.controlPlane.podDisruptionBudget.maxUnavailable }}
+  {{- end }}
+  selector:
+    matchLabels:
+      {{- include "hindsight.controlPlane.selectorLabels" . | nindent 6 }}
+{{- end }}
+---
+{{- if and .Values.worker.enabled .Values.worker.podDisruptionBudget.enabled }}
+apiVersion: policy/v1
+kind: PodDisruptionBudget
+metadata:
+  name: {{ include "hindsight.fullname" . }}-worker
+  labels:
+    {{- include "hindsight.worker.labels" . | nindent 4 }}
+spec:
+  {{- if .Values.worker.podDisruptionBudget.minAvailable }}
+  minAvailable: {{ .Values.worker.podDisruptionBudget.minAvailable }}
+  {{- end }}
+  {{- if .Values.worker.podDisruptionBudget.maxUnavailable }}
+  maxUnavailable: {{ .Values.worker.podDisruptionBudget.maxUnavailable }}
+  {{- end }}
+  selector:
+    matchLabels:
+      {{- include "hindsight.worker.selectorLabels" . | nindent 6 }}
+{{- end }}
@@ -32,7 +32,7 @@ spec:
      - name: worker
        securityContext:
          {{- toYaml .Values.securityContext | nindent 10 }}
-        image: "{{ .Values.worker.image.repository }}:{{ .Values.worker.image.tag | default .Values.version }}"
+        image: "{{ .Values.worker.image.repository }}:{{ .Values.worker.image.tag | default .Values.version | default .Chart.AppVersion }}"
        imagePullPolicy: {{ .Values.worker.image.pullPolicy }}
        command: ["hindsight-worker"]
        ports:
@@ -99,7 +99,7 @@ spec:
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
-      {{- with .Values.affinity }}
+      {{- with (.Values.worker.affinity | default .Values.affinity) }}
      affinity:
        {{- toYaml . | nindent 8 }}
      {{- end }}
@@ -1,7 +1,8 @@
 # Default values for hindsight

-# Chart version - use this to set a consistent image tag across all components
-version: "0.1.1"
+# Global version override - use this to set a consistent image tag across all components
+# If not set, defaults to Chart.appVersion from Chart.yaml
+# version: ""

 # Use an existing secret instead of creating one from values
 # When set, all keys from this secret are injected as environment variables via envFrom
@@ -57,6 +58,15 @@ api:
    timeoutSeconds: 3
    failureThreshold: 3

+  # Pod disruption budget
+  podDisruptionBudget:
+    enabled: false
+    minAvailable: 1
+    # maxUnavailable: 1
+
+  # Pod affinity/anti-affinity (overrides global affinity for this component)
+  # affinity: {}
+
  # Environment variables
  env:
    #HINDSIGHT_API_LLM_PROVIDER: "groq"
@@ -75,7 +85,7 @@ worker:
  image:
    repository: ghcr.io/vectorize-io/hindsight-api
    pullPolicy: IfNotPresent
-    # tag defaults to .Values.version if not specified
+    # tag: ""  # defaults to .Values.version, then Chart.appVersion if not specified

  service:
    # Service for metrics scraping (headless for StatefulSet)
@@ -121,6 +131,15 @@ worker:
    # HTTP port for metrics/health (matches service.targetPort)
    HINDSIGHT_API_WORKER_HTTP_PORT: "8889"

+  # Pod disruption budget
+  podDisruptionBudget:
+    enabled: false
+    minAvailable: 1
+    # maxUnavailable: 1
+
+  # Pod affinity/anti-affinity (overrides global affinity for this component)
+  # affinity: {}
+
  # Secret environment variables (inherited from api.secrets if not specified)
  secrets: {}

@@ -164,6 +183,15 @@ controlPlane:
    timeoutSeconds: 3
    failureThreshold: 3

+  # Pod disruption budget
+  podDisruptionBudget:
+    enabled: false
+    minAvailable: 1
+    # maxUnavailable: 1
+
+  # Pod affinity/anti-affinity (overrides global affinity for this component)
+  # affinity: {}
+
  # Environment variables
  env:
    NODE_ENV: "production"
@@ -262,7 +290,7 @@ nodeSelector: {}
 # Tolerations
 tolerations: []

-# Affinity
+# Affinity (applied to all components unless overridden per-component)
 affinity: {}

 # Autoscaling
@@ -46,4 +46,4 @@ __all__ = [
    "RemoteTEICrossEncoder",
    "LLMConfig",
 ]
-__version__ = "0.4.0"
+__version__ = "0.4.10"
@@ -11,6 +11,7 @@ from collections.abc import Sequence
 import sqlalchemy as sa
 from alembic import op
 from pgvector.sqlalchemy import Vector
+from sqlalchemy import text
 from sqlalchemy.dialects import postgresql

 # revision identifiers, used by Alembic.
@@ -23,8 +24,21 @@ depends_on: str | Sequence[str] | None = None
 def upgrade() -> None:
    """Upgrade schema - create all tables from scratch."""

-    # Enable required extensions
-    op.execute("CREATE EXTENSION IF NOT EXISTS vector")
+    # Note: pgvector extension is installed globally BEFORE migrations run
+    # See migrations.py:run_migrations() - this ensures the extension is available
+    # to all schemas, not just the one being migrated
+
+    # We keep this here as a fallback for backwards compatibility
+    # This may fail if user lacks permissions, which is fine if extension already exists
+    try:
+        op.execute("CREATE EXTENSION IF NOT EXISTS vector")
+    except Exception:
+        # Extension might already exist or user lacks permissions - verify it exists
+        conn = op.get_bind()
+        result = conn.execute(text("SELECT 1 FROM pg_extension WHERE extname = 'vector'")).fetchone()
+        if not result:
+            # Extension truly doesn't exist - re-raise the error
+            raise

    # Create banks table
    op.create_table(
@@ -0,0 +1,60 @@
+"""Fix mental_models primary key to be scoped per bank
+
+Revision ID: w8r9s0t1u2v3
+Revises: v7q8r9s0t1u2
+Create Date: 2026-02-05
+
+This migration fixes a critical bank isolation bug where mental_models.id was
+globally unique across all banks instead of being scoped per bank. This caused
+conflicts when different banks tried to use the same custom ID.
+
+CRITICAL FIX: Changes primary key from (id) to (bank_id, id) to ensure proper isolation.
+"""
+
+from collections.abc import Sequence
+
+from alembic import context, op
+
+revision: str = "w8r9s0t1u2v3"
+down_revision: str | Sequence[str] | None = "v7q8r9s0t1u2"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def _get_schema_prefix() -> str:
+    """Get schema prefix for table names (required for multi-tenant support)."""
+    schema = context.config.get_main_option("target_schema")
+    return f'"{schema}".' if schema else ""
+
+
+def upgrade() -> None:
+    """Change mental_models primary key from (id) to (bank_id, id) for proper bank isolation."""
+    schema = _get_schema_prefix()
+
+    # Drop the old primary key constraint (just id)
+    # Note: The constraint might be named differently on different DBs
+    # Try both old names (pinned_reflections_pkey from original, mental_models_pkey from rename)
+    op.execute(f"ALTER TABLE {schema}mental_models DROP CONSTRAINT IF EXISTS pinned_reflections_pkey")
+    op.execute(f"ALTER TABLE {schema}mental_models DROP CONSTRAINT IF EXISTS mental_models_pkey")
+
+    # Create the new composite primary key (bank_id, id)
+    # This ensures IDs are scoped per bank, not globally
+    op.execute(f"""
+        ALTER TABLE {schema}mental_models
+        ADD CONSTRAINT mental_models_pkey PRIMARY KEY (bank_id, id)
+    """)
+
+
+def downgrade() -> None:
+    """Revert mental_models primary key from (bank_id, id) to (id)."""
+    schema = _get_schema_prefix()
+
+    # Drop the composite primary key
+    op.execute(f"ALTER TABLE {schema}mental_models DROP CONSTRAINT IF EXISTS mental_models_pkey")
+
+    # Restore the old primary key (just id)
+    # WARNING: This downgrade will fail if there are duplicate IDs across banks
+    op.execute(f"""
+        ALTER TABLE {schema}mental_models
+        ADD CONSTRAINT mental_models_pkey PRIMARY KEY (id)
+    """)
@@ -72,22 +72,24 @@ def create_app(

    # Mount MCP server and chain its lifespan if enabled
    if mcp_app is not None:
-        # Get the MCP app's underlying Starlette app for lifespan access
-        mcp_starlette_app = mcp_app.mcp_app
+        # Get both MCP apps' underlying Starlette apps for lifespan access
+        multi_bank_starlette_app = mcp_app.multi_bank_app
+        single_bank_starlette_app = mcp_app.single_bank_app

        # Store the original lifespan
        original_lifespan = app.router.lifespan_context

        @asynccontextmanager
        async def chained_lifespan(app_instance: FastAPI):
-            """Chain the MCP lifespan with the main app lifespan."""
-            # Start MCP lifespan first
-            async with mcp_starlette_app.router.lifespan_context(mcp_starlette_app):
-                logger.info("MCP lifespan started")
-                # Then start the original app lifespan
-                async with original_lifespan(app_instance):
-                    yield
-            logger.info("MCP lifespan stopped")
+            """Chain both MCP lifespans with the main app lifespan."""
+            # Start both MCP lifespans (multi-bank and single-bank)
+            async with multi_bank_starlette_app.router.lifespan_context(multi_bank_starlette_app):
+                async with single_bank_starlette_app.router.lifespan_context(single_bank_starlette_app):
+                    logger.info("MCP lifespans started (multi-bank and single-bank)")
+                    # Then start the original app lifespan
+                    async with original_lifespan(app_instance):
+                        yield
+                logger.info("MCP lifespans stopped")

        # Replace the app's lifespan with the chained version
        app.router.lifespan_context = chained_lifespan
@@ -5,6 +5,7 @@ This module provides the create_app function to create and configure
 the FastAPI application with all API endpoints.
 """

+import asyncio
 import json
 import logging
 import uuid
@@ -35,7 +36,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator

 from hindsight_api import MemoryEngine
 from hindsight_api.engine.db_utils import acquire_with_retry
-from hindsight_api.engine.memory_engine import Budget, fq_table
+from hindsight_api.engine.memory_engine import Budget, _get_tiktoken_encoding, fq_table
 from hindsight_api.engine.reflect.observations import Observation
 from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES, TokenUsage
 from hindsight_api.engine.search.tags import TagsMatch
@@ -45,6 +46,8 @@ from hindsight_api.models import RequestContext

 logger = logging.getLogger(__name__)

+MAX_QUERY_TOKENS = 500  # Maximum tokens allowed in recall query
+

 class EntityIncludeOptions(BaseModel):
    """Options for including entity observations in recall results."""
@@ -92,8 +95,7 @@ class RecallRequest(BaseModel):
    query: str
    types: list[str] | None = Field(
        default=None,
-        description="List of fact types to recall: 'world', 'experience', 'observation'. Defaults to world and experience if not specified. "
-        "Note: 'opinion' is accepted but ignored (opinions are excluded from recall).",
+        description="List of fact types to recall: 'world', 'experience', 'observation'. Defaults to world and experience if not specified.",
    )
    budget: Budget = Budget.MID
    max_tokens: int = 4096
@@ -504,13 +506,6 @@ class ReflectRequest(BaseModel):
    )


-class OpinionItem(BaseModel):
-    """Model for an opinion with confidence score."""
-
-    text: str
-    confidence: float
-
-
 class ReflectFact(BaseModel):
    """A fact used in think response."""

@@ -528,8 +523,10 @@ class ReflectFact(BaseModel):
    )

    id: str | None = None
-    text: str
-    type: str | None = None  # fact type: world, experience, opinion
+    text: str = Field(
+        description="Fact text. When type='observation', this contains markdown-formatted consolidated knowledge"
+    )
+    type: str | None = None  # fact type: world, experience, observation
    context: str | None = None
    occurred_start: str | None = None
    occurred_end: str | None = None
@@ -593,7 +590,7 @@ class ReflectResponse(BaseModel):
    model_config = ConfigDict(
        json_schema_extra={
            "example": {
-                "text": "Based on my understanding, AI is a transformative technology...",
+                "text": "## AI Overview\n\nBased on my understanding, AI is a **transformative technology**:\n\n- Used extensively in healthcare\n- Discussed in recent conversations\n- Continues to evolve rapidly",
                "based_on": {
                    "memories": [
                        {"id": "123", "text": "AI is used in healthcare", "type": "world"},
@@ -621,7 +618,9 @@ class ReflectResponse(BaseModel):
        }
    )

-    text: str
+    text: str = Field(
+        description="The reflect response as well-formatted markdown (headers, lists, bold/italic, code blocks, etc.)"
+    )
    based_on: ReflectBasedOn | None = Field(
        default=None,
        description="Evidence used to generate the response. Only present when include.facts is set.",
@@ -871,6 +870,7 @@ class ListDocumentsResponse(BaseModel):
                        "updated_at": "2024-01-15T10:30:00Z",
                        "text_length": 5420,
                        "memory_unit_count": 15,
+                        "tags": ["user_a", "session_123"],
                    }
                ],
                "total": 50,
@@ -1118,7 +1118,9 @@ class MentalModelResponse(BaseModel):
    bank_id: str
    name: str
    source_query: str
-    content: str
+    content: str = Field(
+        description="The mental model content as well-formatted markdown (auto-generated from reflect endpoint)"
+    )
    tags: list[str] = Field(default_factory=list)
    max_tokens: int = Field(default=2048)
    trigger: MentalModelTrigger = Field(default_factory=MentalModelTrigger)
@@ -1142,6 +1144,7 @@ class CreateMentalModelRequest(BaseModel):
    model_config = ConfigDict(
        json_schema_extra={
            "example": {
+                "id": "team-communication",
                "name": "Team Communication Preferences",
                "source_query": "How does the team prefer to communicate?",
                "tags": ["team"],
@@ -1151,6 +1154,9 @@ class CreateMentalModelRequest(BaseModel):
        }
    )

+    id: str | None = Field(
+        None, description="Optional custom ID for the mental model (alphanumeric lowercase with hyphens)"
+    )
    name: str = Field(description="Human-readable name for the mental model")
    source_query: str = Field(description="The query to run to generate content")
    tags: list[str] = Field(default_factory=list, description="Tags for scoped visibility")
@@ -1161,7 +1167,8 @@ class CreateMentalModelRequest(BaseModel):
 class CreateMentalModelResponse(BaseModel):
    """Response model for mental model creation."""

-    operation_id: str = Field(description="Operation ID to track progress")
+    mental_model_id: str | None = Field(None, description="ID of the created mental model")
+    operation_id: str = Field(description="Operation ID to track refresh progress")


 class UpdateMentalModelRequest(BaseModel):
@@ -1323,7 +1330,7 @@ class VersionResponse(BaseModel):
    model_config = ConfigDict(
        json_schema_extra={
            "example": {
-                "api_version": "1.0.0",
+                "api_version": "0.4.0",
                "features": {
                    "observations": False,
                    "mcp": True,
@@ -1406,19 +1413,31 @@ def create_app(

        # Start worker poller if enabled (standalone mode)
        if config.worker_enabled and memory._pool is not None:
+            from ..config import DEFAULT_DATABASE_SCHEMA
+
            worker_id = config.worker_id or socket.gethostname()
+            # Convert default schema to None for SQL compatibility (no schema prefix)
+            schema = None if config.database_schema == DEFAULT_DATABASE_SCHEMA else config.database_schema
            poller = WorkerPoller(
                pool=memory._pool,
                worker_id=worker_id,
                executor=memory.execute_task,
                poll_interval_ms=config.worker_poll_interval_ms,
-                batch_size=config.worker_batch_size,
                max_retries=config.worker_max_retries,
-                tenant_extension=getattr(memory, "_tenant_extension", None),
+                schema=schema,
+                tenant_extension=memory._tenant_extension,
+                max_slots=config.worker_max_slots,
+                consolidation_max_slots=config.worker_consolidation_max_slots,
            )
            poller_task = asyncio.create_task(poller.run())
            logging.info(f"Worker poller started (worker_id={worker_id})")

+        # Call tenant extension startup hook (e.g. JWKS fetch for Supabase)
+        tenant_extension = memory.tenant_extension
+        if tenant_extension:
+            await tenant_extension.on_startup()
+            logging.info("Tenant extension started")
+
        # Call HTTP extension startup hook
        if http_extension:
            await http_extension.on_startup()
@@ -1437,6 +1456,11 @@ def create_app(
                    pass
            logging.info("Worker poller stopped")

+        # Call tenant extension shutdown hook
+        if tenant_extension:
+            await tenant_extension.on_shutdown()
+            logging.info("Tenant extension stopped")
+
        # Call HTTP extension shutdown hook
        if http_extension:
            await http_extension.on_shutdown()
@@ -1567,11 +1591,12 @@ def _register_routes(app: FastAPI):
        Returns version info and feature flags that can be used by clients
        to determine which capabilities are available.
        """
+        from hindsight_api import __version__
        from hindsight_api.config import get_config

        config = get_config()
        return VersionResponse(
-            api_version="1.0.0",
+            api_version=__version__,
            features=FeaturesInfo(
                observations=config.enable_observations,
                mcp=config.mcp_enabled,
@@ -1706,9 +1731,7 @@ def _register_routes(app: FastAPI):
        description="Recall memory using semantic similarity and spreading activation.\n\n"
        "The type parameter is optional and must be one of:\n"
        "- `world`: General knowledge about people, places, events, and things that happen\n"
-        "- `experience`: Memories about experience, conversations, actions taken, and tasks performed\n"
-        "- `opinion`: The bank's formed beliefs, perspectives, and viewpoints\n\n"
-        "Set `include_entities=true` to get entity observations alongside recall results.",
+        "- `experience`: Memories about experience, conversations, actions taken, and tasks performed",
        operation_id="recall_memories",
        tags=["Memory"],
    )
@@ -1721,11 +1744,18 @@ def _register_routes(app: FastAPI):
        handler_start = time.time()
        metrics = get_metrics_collector()

+        # Validate query length to prevent expensive operations on oversized queries
+        encoding = _get_tiktoken_encoding()
+        query_tokens = len(encoding.encode(request.query))
+        if query_tokens > MAX_QUERY_TOKENS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Query too long: {query_tokens} tokens exceeds maximum of {MAX_QUERY_TOKENS}. Please shorten your query.",
+            )
+
        try:
-            # Default to world and experience if not specified (exclude observation and opinion)
-            # Filter out 'opinion' even if requested - opinions are excluded from recall
+            # Default to world and experience if not specified (exclude observation)
            fact_types = request.types if request.types else list(VALID_RECALL_FACT_TYPES)
-            fact_types = [ft for ft in fact_types if ft != "opinion"]

            # Parse query_timestamp if provided
            question_date = None
@@ -1837,6 +1867,15 @@ def _register_routes(app: FastAPI):
            raise HTTPException(status_code=e.status_code, detail=e.reason)
        except (AuthenticationError, HTTPException):
            raise
+        except (asyncio.TimeoutError, TimeoutError):
+            handler_duration = time.time() - handler_start
+            logger.error(
+                f"[RECALL TIMEOUT] bank={bank_id} handler_duration={handler_duration:.3f}s - database query timed out"
+            )
+            raise HTTPException(
+                status_code=504,
+                detail="Request timed out while searching memories. Try a shorter or more specific query.",
+            )
        except Exception as e:
            import traceback

@@ -1857,8 +1896,7 @@ def _register_routes(app: FastAPI):
        "2. Retrieves world facts relevant to the query\n"
        "3. Retrieves existing opinions (bank's perspectives)\n"
        "4. Uses LLM to formulate a contextual answer\n"
-        "5. Extracts and stores any new opinions formed\n"
-        "6. Returns plain text answer, the facts used, and new opinions",
+        "5. Returns plain text answer and the facts used",
        operation_id="reflect",
        tags=["Memory"],
    )
@@ -1895,17 +1933,17 @@ def _register_routes(app: FastAPI):
                directives = []
                for fact_type, facts in core_result.based_on.items():
                    if fact_type == "directives":
-                        # Directives have different structure (id, name, content)
+                        # Directives are dicts with id, name, content (not MemoryFact objects)
                        for directive in facts:
                            directives.append(
                                ReflectDirective(
-                                    id=directive.id,
-                                    name=directive.name,
-                                    content=directive.content,
+                                    id=directive["id"],
+                                    name=directive["name"],
+                                    content=directive["content"],
                                )
                            )
-                    elif fact_type == "mental_models":
-                        # Mental models are MemoryFact with type "mental_models"
+                    elif fact_type == "mental-models":
+                        # Mental models are MemoryFact with type "mental-models" (note: hyphen, not underscore)
                        for fact in facts:
                            mental_models.append(
                                ReflectMentalModel(
@@ -2296,6 +2334,23 @@ def _register_routes(app: FastAPI):
    ):
        """Get a mental model by ID."""
        try:
+            # Pre-operation validation hook
+            validator = app.state.memory._operation_validator
+            if validator:
+                from hindsight_api.extensions.operation_validator import MentalModelGetContext
+
+                ctx = MentalModelGetContext(
+                    bank_id=bank_id,
+                    mental_model_id=mental_model_id,
+                    request_context=request_context,
+                )
+                validation = await validator.validate_mental_model_get(ctx)
+                if not validation.allowed:
+                    raise OperationValidationError(
+                        validation.reason or "Operation not allowed",
+                        status_code=validation.status_code,
+                    )
+
            mental_model = await app.state.memory.get_mental_model(
                bank_id=bank_id,
                mental_model_id=mental_model_id,
@@ -2303,9 +2358,31 @@ def _register_routes(app: FastAPI):
            )
            if mental_model is None:
                raise HTTPException(status_code=404, detail=f"Mental model '{mental_model_id}' not found")
+
+            # Post-operation hook
+            if validator:
+                from hindsight_api.extensions.operation_validator import MentalModelGetResult
+
+                content = mental_model.get("content", "")
+                output_tokens = len(content) // 4 if content else 0
+
+                result_ctx = MentalModelGetResult(
+                    bank_id=bank_id,
+                    mental_model_id=mental_model_id,
+                    request_context=request_context,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+                try:
+                    await validator.on_mental_model_get_complete(result_ctx)
+                except Exception as hook_err:
+                    logger.warning(f"Post-mental-model-get hook error (non-fatal): {hook_err}")
+
            return MentalModelResponse(**mental_model)
        except (AuthenticationError, HTTPException):
            raise
+        except OperationValidationError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.reason)
        except Exception as e:
            import traceback

@@ -2330,12 +2407,30 @@ def _register_routes(app: FastAPI):
    ):
        """Create a mental model (async - returns operation_id)."""
        try:
+            # Pre-operation validation hook
+            validator = app.state.memory._operation_validator
+            if validator:
+                from hindsight_api.extensions.operation_validator import MentalModelRefreshContext
+
+                ctx = MentalModelRefreshContext(
+                    bank_id=bank_id,
+                    mental_model_id=None,  # Not yet created
+                    request_context=request_context,
+                )
+                validation = await validator.validate_mental_model_refresh(ctx)
+                if not validation.allowed:
+                    raise OperationValidationError(
+                        validation.reason or "Operation not allowed",
+                        status_code=validation.status_code,
+                    )
+
            # 1. Create the mental model with placeholder content
            mental_model = await app.state.memory.create_mental_model(
                bank_id=bank_id,
                name=body.name,
                source_query=body.source_query,
                content="Generating content...",
+                mental_model_id=body.id if body.id else None,
                tags=body.tags if body.tags else None,
                max_tokens=body.max_tokens,
                trigger=body.trigger.model_dump() if body.trigger else None,
@@ -2347,11 +2442,13 @@ def _register_routes(app: FastAPI):
                mental_model_id=mental_model["id"],
                request_context=request_context,
            )
-            return CreateMentalModelResponse(operation_id=result["operation_id"])
+            return CreateMentalModelResponse(mental_model_id=mental_model["id"], operation_id=result["operation_id"])
        except ValueError as e:
            raise HTTPException(status_code=400, detail=str(e))
        except (AuthenticationError, HTTPException):
            raise
+        except OperationValidationError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.reason)
        except Exception as e:
            import traceback

@@ -2374,6 +2471,23 @@ def _register_routes(app: FastAPI):
    ):
        """Refresh a mental model by re-running its source query (async)."""
        try:
+            # Pre-operation validation hook
+            validator = app.state.memory._operation_validator
+            if validator:
+                from hindsight_api.extensions.operation_validator import MentalModelRefreshContext
+
+                ctx = MentalModelRefreshContext(
+                    bank_id=bank_id,
+                    mental_model_id=mental_model_id,
+                    request_context=request_context,
+                )
+                validation = await validator.validate_mental_model_refresh(ctx)
+                if not validation.allowed:
+                    raise OperationValidationError(
+                        validation.reason or "Operation not allowed",
+                        status_code=validation.status_code,
+                    )
+
            result = await app.state.memory.submit_async_refresh_mental_model(
                bank_id=bank_id,
                mental_model_id=mental_model_id,
@@ -2384,6 +2498,8 @@ def _register_routes(app: FastAPI):
            raise HTTPException(status_code=404, detail=str(e))
        except (AuthenticationError, HTTPException):
            raise
+        except OperationValidationError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.reason)
        except Exception as e:
            import traceback

@@ -8,7 +8,11 @@ from contextvars import ContextVar
 from fastmcp import FastMCP

 from hindsight_api import MemoryEngine
+from hindsight_api.engine.memory_engine import _current_schema
+from hindsight_api.extensions import MCPExtension, load_extension
+from hindsight_api.extensions.tenant import AuthenticationError
 from hindsight_api.mcp_tools import MCPToolsConfig, register_mcp_tools
+from hindsight_api.models import RequestContext

 # Configure logging from HINDSIGHT_API_LOG_LEVEL environment variable
 _log_level_str = os.environ.get("HINDSIGHT_API_LOG_LEVEL", "info").lower()
@@ -29,21 +33,49 @@ logger = logging.getLogger(__name__)
 # Default bank_id from environment variable
 DEFAULT_BANK_ID = os.environ.get("HINDSIGHT_MCP_BANK_ID", "default")

+# Legacy MCP authentication token (for backwards compatibility)
+# If set, this token is checked first before TenantExtension auth
+MCP_AUTH_TOKEN = os.environ.get("HINDSIGHT_API_MCP_AUTH_TOKEN")
+
 # Context variable to hold the current bank_id
 _current_bank_id: ContextVar[str | None] = ContextVar("current_bank_id", default=None)

+# Context variable to hold the current API key (for tenant auth propagation)
+_current_api_key: ContextVar[str | None] = ContextVar("current_api_key", default=None)
+
+# Context variables for tenant_id and api_key_id (set by authenticate, used by usage metering)
+_current_tenant_id: ContextVar[str | None] = ContextVar("current_tenant_id", default=None)
+_current_api_key_id: ContextVar[str | None] = ContextVar("current_api_key_id", default=None)
+

 def get_current_bank_id() -> str | None:
    """Get the current bank_id from context."""
    return _current_bank_id.get()


-def create_mcp_server(memory: MemoryEngine) -> FastMCP:
+def get_current_api_key() -> str | None:
+    """Get the current API key from context."""
+    return _current_api_key.get()
+
+
+def get_current_tenant_id() -> str | None:
+    """Get the current tenant_id from context."""
+    return _current_tenant_id.get()
+
+
+def get_current_api_key_id() -> str | None:
+    """Get the current api_key_id from context."""
+    return _current_api_key_id.get()
+
+
+def create_mcp_server(memory: MemoryEngine, multi_bank: bool = True) -> FastMCP:
    """
    Create and configure the Hindsight MCP server.

    Args:
        memory: MemoryEngine instance (required)
+        multi_bank: If True, expose all tools with bank_id parameters (default).
+                   If False, only expose bank-scoped tools without bank_id parameters.

    Returns:
        Configured FastMCP server instance with stateless_http enabled
@@ -54,36 +86,78 @@ def create_mcp_server(memory: MemoryEngine) -> FastMCP:
    # Configure and register tools using shared module
    config = MCPToolsConfig(
        bank_id_resolver=get_current_bank_id,
-        include_bank_id_param=True,  # HTTP MCP supports multi-bank via parameter
-        tools=None,  # All tools
+        api_key_resolver=get_current_api_key,  # Propagate API key for tenant auth
+        tenant_id_resolver=get_current_tenant_id,  # Propagate tenant_id for usage metering
+        api_key_id_resolver=get_current_api_key_id,  # Propagate api_key_id for usage metering
+        include_bank_id_param=multi_bank,
+        tools=None if multi_bank else {"retain", "recall", "reflect"},  # Scoped tools for single-bank mode
        retain_fire_and_forget=False,  # HTTP MCP supports sync/async modes
    )

    register_mcp_tools(mcp, memory, config)

+    # Load and register additional tools from MCP extension if configured
+    mcp_extension = load_extension("MCP", MCPExtension)
+    if mcp_extension:
+        logger.info(f"Loading MCP extension: {mcp_extension.__class__.__name__}")
+        mcp_extension.register_tools(mcp, memory)
+
    return mcp


 class MCPMiddleware:
-    """ASGI middleware that extracts bank_id from header or path and sets context.
+    """ASGI middleware that handles authentication and routes to appropriate MCP server.

-    Bank ID can be provided via:
-    1. X-Bank-Id header (recommended for Claude Code)
-    2. URL path: /mcp/{bank_id}/
-    3. Environment variable HINDSIGHT_MCP_BANK_ID (fallback default)
+    Authentication:
+        1. If HINDSIGHT_API_MCP_AUTH_TOKEN is set (legacy), validates against that token
+        2. Otherwise, uses TenantExtension.authenticate_mcp() from the MemoryEngine
+           - DefaultTenantExtension: no auth required (local dev)
+           - ApiKeyTenantExtension: validates against env var

-    For Claude Code, configure with:
+    Two modes based on URL structure:
+
+    1. Multi-bank mode (for /mcp/ root endpoint):
+       - Exposes all tools: retain, recall, reflect, list_banks, create_bank
+       - All tools include optional bank_id parameter for cross-bank operations
+       - Bank ID from: X-Bank-Id header or HINDSIGHT_MCP_BANK_ID env var
+
+    2. Single-bank mode (for /mcp/{bank_id}/ endpoints):
+       - Exposes bank-scoped tools only: retain, recall, reflect
+       - No bank_id parameter (comes from URL)
+       - No bank management tools (list_banks, create_bank)
+       - Recommended for agent isolation
+
+    Examples:
+        # Single-bank mode (recommended for agent isolation)
+        claude mcp add --transport http my-agent http://localhost:8888/mcp/my-agent-bank/ \\
+            --header "Authorization: Bearer <token>"
+
+        # Multi-bank mode (for cross-bank operations)
        claude mcp add --transport http hindsight http://localhost:8888/mcp \\
-            --header "X-Bank-Id: my-bank"
+            --header "X-Bank-Id: my-bank" --header "Authorization: Bearer <token>"
    """

    def __init__(self, app, memory: MemoryEngine):
        self.app = app
        self.memory = memory
-        self.mcp_server = create_mcp_server(memory)
-        self.mcp_app = self.mcp_server.http_app(path="/")
-        # Expose the lifespan for the parent app to chain
-        self.lifespan = self.mcp_app.lifespan_handler if hasattr(self.mcp_app, "lifespan_handler") else None
+        self.tenant_extension = memory._tenant_extension
+
+        # Create two server instances:
+        # 1. Multi-bank server (for /mcp/ root endpoint)
+        self.multi_bank_server = create_mcp_server(memory, multi_bank=True)
+        self.multi_bank_app = self.multi_bank_server.http_app(path="/")
+
+        # 2. Single-bank server (for /mcp/{bank_id}/ endpoints)
+        self.single_bank_server = create_mcp_server(memory, multi_bank=False)
+        self.single_bank_app = self.single_bank_server.http_app(path="/")
+
+        # Backward compatibility: expose multi_bank_app as mcp_app
+        self.mcp_app = self.multi_bank_app
+
+        # Expose the lifespan for the parent app to chain (use multi-bank as default)
+        self.lifespan = (
+            self.multi_bank_app.lifespan_handler if hasattr(self.multi_bank_app, "lifespan_handler") else None
+        )

    def _get_header(self, scope: dict, name: str) -> str | None:
        """Extract a header value from ASGI scope."""
@@ -95,9 +169,47 @@ class MCPMiddleware:

    async def __call__(self, scope, receive, send):
        if scope["type"] != "http":
-            await self.mcp_app(scope, receive, send)
+            await self.multi_bank_app(scope, receive, send)
            return

+        # Extract auth token from header (for tenant auth propagation)
+        auth_header = self._get_header(scope, "Authorization")
+        auth_token: str | None = None
+        if auth_header:
+            # Support both "Bearer <token>" and direct token
+            auth_token = auth_header[7:].strip() if auth_header.startswith("Bearer ") else auth_header.strip()
+
+        # Authenticate: check legacy MCP_AUTH_TOKEN first, then TenantExtension
+        tenant_context = None
+        auth_tenant_id: str | None = None
+        auth_api_key_id: str | None = None
+        if MCP_AUTH_TOKEN:
+            # Legacy authentication mode - validate against static token
+            if not auth_token:
+                await self._send_error(send, 401, "Authorization header required")
+                return
+            if auth_token != MCP_AUTH_TOKEN:
+                await self._send_error(send, 401, "Invalid authentication token")
+                return
+            # Legacy mode doesn't use tenant schemas
+            tenant_context = None
+        else:
+            # Use TenantExtension.authenticate_mcp() for auth
+            try:
+                auth_context = RequestContext(api_key=auth_token)
+                tenant_context = await self.tenant_extension.authenticate_mcp(auth_context)
+                # Capture tenant_id and api_key_id set by authenticate() for usage metering
+                auth_tenant_id = auth_context.tenant_id
+                auth_api_key_id = auth_context.api_key_id
+            except AuthenticationError as e:
+                await self._send_error(send, 401, str(e))
+                return
+
+        # Set schema from tenant context so downstream DB queries use the correct schema
+        schema_token = (
+            _current_schema.set(tenant_context.schema_name) if tenant_context and tenant_context.schema_name else None
+        )
+
        path = scope.get("path", "")

        # Strip any mount prefix (e.g., /mcp) that FastAPI might not have stripped
@@ -111,8 +223,13 @@ class MCPMiddleware:
        elif path == "/mcp":
            path = "/"

+        # Ensure path has leading slash (needed after stripping mount path)
+        if path and not path.startswith("/"):
+            path = "/" + path
+
        # Try to get bank_id from header first (for Claude Code compatibility)
        bank_id = self._get_header(scope, "X-Bank-Id")
+        bank_id_from_path = False

        # MCP endpoint paths that should not be treated as bank_ids
        MCP_ENDPOINTS = {"sse", "messages"}
@@ -125,6 +242,7 @@ class MCPMiddleware:
            if parts[0] and parts[0] not in MCP_ENDPOINTS:
                # First segment looks like a bank_id
                bank_id = parts[0]
+                bank_id_from_path = True
                new_path = "/" + parts[1] if len(parts) > 1 else "/"

        # Fall back to default bank_id
@@ -132,8 +250,18 @@ class MCPMiddleware:
            bank_id = DEFAULT_BANK_ID
            logger.debug(f"Using default bank_id: {bank_id}")

-        # Set bank_id context
-        token = _current_bank_id.set(bank_id)
+        # Select the appropriate MCP app based on how bank_id was provided:
+        # - Path-based bank_id → single-bank app (no bank_id param, scoped tools)
+        # - Header/env bank_id → multi-bank app (bank_id param, all tools)
+        target_app = self.single_bank_app if bank_id_from_path else self.multi_bank_app
+
+        # Set bank_id, api_key, tenant_id, and api_key_id context
+        bank_id_token = _current_bank_id.set(bank_id)
+        # Store the auth token for tenant extension to validate
+        api_key_token = _current_api_key.set(auth_token) if auth_token else None
+        # Store tenant_id and api_key_id from authentication for usage metering
+        tenant_id_token = _current_tenant_id.set(auth_tenant_id) if auth_tenant_id else None
+        api_key_id_token = _current_api_key_id.set(auth_api_key_id) if auth_api_key_id else None
        try:
            new_scope = scope.copy()
            new_scope["path"] = new_path
@@ -142,7 +270,7 @@ class MCPMiddleware:

            # Wrap send to rewrite the SSE endpoint URL to include bank_id if using path-based routing
            async def send_wrapper(message):
-                if message["type"] == "http.response.body":
+                if message["type"] == "http.response.body" and bank_id_from_path:
                    body = message.get("body", b"")
                    if body and b"/messages" in body:
                        # Rewrite /messages to /{bank_id}/messages in SSE endpoint event
@@ -150,9 +278,17 @@ class MCPMiddleware:
                        message = {**message, "body": body}
                await send(message)

-            await self.mcp_app(new_scope, receive, send_wrapper)
+            await target_app(new_scope, receive, send_wrapper)
        finally:
-            _current_bank_id.reset(token)
+            _current_bank_id.reset(bank_id_token)
+            if api_key_token is not None:
+                _current_api_key.reset(api_key_token)
+            if tenant_id_token is not None:
+                _current_tenant_id.reset(tenant_id_token)
+            if api_key_id_token is not None:
+                _current_api_key_id.reset(api_key_id_token)
+            if schema_token is not None:
+                _current_schema.reset(schema_token)

    async def _send_error(self, send, status: int, message: str):
        """Send an error response."""
@@ -174,12 +310,23 @@ class MCPMiddleware:

 def create_mcp_app(memory: MemoryEngine):
    """
-    Create an ASGI app that handles MCP requests.
+    Create an ASGI app that handles MCP requests with dynamic tool exposure.

-    Bank ID can be provided via:
-    1. X-Bank-Id header: claude mcp add --transport http hindsight http://localhost:8888/mcp --header "X-Bank-Id: my-bank"
-    2. URL path: /mcp/{bank_id}/
-    3. Environment variable HINDSIGHT_MCP_BANK_ID (fallback, default: "default")
+    Authentication:
+        Uses the TenantExtension from the MemoryEngine (same auth as REST API).
+
+    Two modes based on URL structure:
+
+    1. Single-bank mode (recommended for agent isolation):
+       - URL: /mcp/{bank_id}/
+       - Tools: retain, recall, reflect (no bank_id parameter)
+       - Example: claude mcp add --transport http my-agent http://localhost:8888/mcp/my-agent-bank/
+
+    2. Multi-bank mode (for cross-bank operations):
+       - URL: /mcp/
+       - Tools: retain, recall, reflect, list_banks, create_bank (all with bank_id parameter)
+       - Bank ID from: X-Bank-Id header or HINDSIGHT_MCP_BANK_ID env var (default: "default")
+       - Example: claude mcp add --transport http hindsight http://localhost:8888/mcp --header "X-Bank-Id: my-bank"

    Args:
        memory: MemoryEngine instance
@@ -4,6 +4,8 @@ Banner display for Hindsight API startup.
 Shows the logo and tagline with gradient colors.
 """

+from .utils import mask_network_location
+
 # Gradient colors: #0074d9 -> #009296
 GRADIENT_START = (0, 116, 217)  # #0074d9
 GRADIENT_END = (0, 146, 150)  # #009296
@@ -83,11 +85,14 @@ def print_startup_info(
    embeddings_provider: str,
    reranker_provider: str,
    mcp_enabled: bool = False,
+    version: str | None = None,
 ):
    """Print styled startup information."""
    print(color_start("Starting Hindsight API..."))
+    if version:
+        print(f"  {dim('Version:')} {color(f'v{version}', 0.1)}")
    print(f"  {dim('URL:')} {color(f'http://{host}:{port}', 0.2)}")
-    print(f"  {dim('Database:')} {color(database_url, 0.4)}")
+    print(f"  {dim('Database:')} {color(mask_network_location(database_url), 0.4)}")
    print(f"  {dim('LLM:')} {color(f'{llm_provider} / {llm_model}', 0.6)}")
    print(f"  {dim('Embeddings:')} {color(embeddings_provider, 0.8)}")
    print(f"  {dim('Reranker:')} {color(reranker_provider, 1.0)}")
@@ -20,11 +20,15 @@ logger = logging.getLogger(__name__)

 # Environment variable names
 ENV_DATABASE_URL = "HINDSIGHT_API_DATABASE_URL"
+ENV_DATABASE_SCHEMA = "HINDSIGHT_API_DATABASE_SCHEMA"
 ENV_LLM_PROVIDER = "HINDSIGHT_API_LLM_PROVIDER"
 ENV_LLM_API_KEY = "HINDSIGHT_API_LLM_API_KEY"
 ENV_LLM_MODEL = "HINDSIGHT_API_LLM_MODEL"
 ENV_LLM_BASE_URL = "HINDSIGHT_API_LLM_BASE_URL"
 ENV_LLM_MAX_CONCURRENT = "HINDSIGHT_API_LLM_MAX_CONCURRENT"
+ENV_LLM_MAX_RETRIES = "HINDSIGHT_API_LLM_MAX_RETRIES"
+ENV_LLM_INITIAL_BACKOFF = "HINDSIGHT_API_LLM_INITIAL_BACKOFF"
+ENV_LLM_MAX_BACKOFF = "HINDSIGHT_API_LLM_MAX_BACKOFF"
 ENV_LLM_TIMEOUT = "HINDSIGHT_API_LLM_TIMEOUT"
 ENV_LLM_GROQ_SERVICE_TIER = "HINDSIGHT_API_LLM_GROQ_SERVICE_TIER"

@@ -33,19 +37,35 @@ ENV_RETAIN_LLM_PROVIDER = "HINDSIGHT_API_RETAIN_LLM_PROVIDER"
 ENV_RETAIN_LLM_API_KEY = "HINDSIGHT_API_RETAIN_LLM_API_KEY"
 ENV_RETAIN_LLM_MODEL = "HINDSIGHT_API_RETAIN_LLM_MODEL"
 ENV_RETAIN_LLM_BASE_URL = "HINDSIGHT_API_RETAIN_LLM_BASE_URL"
+ENV_RETAIN_LLM_MAX_CONCURRENT = "HINDSIGHT_API_RETAIN_LLM_MAX_CONCURRENT"
+ENV_RETAIN_LLM_MAX_RETRIES = "HINDSIGHT_API_RETAIN_LLM_MAX_RETRIES"
+ENV_RETAIN_LLM_INITIAL_BACKOFF = "HINDSIGHT_API_RETAIN_LLM_INITIAL_BACKOFF"
+ENV_RETAIN_LLM_MAX_BACKOFF = "HINDSIGHT_API_RETAIN_LLM_MAX_BACKOFF"
+ENV_RETAIN_LLM_TIMEOUT = "HINDSIGHT_API_RETAIN_LLM_TIMEOUT"

 ENV_REFLECT_LLM_PROVIDER = "HINDSIGHT_API_REFLECT_LLM_PROVIDER"
 ENV_REFLECT_LLM_API_KEY = "HINDSIGHT_API_REFLECT_LLM_API_KEY"
 ENV_REFLECT_LLM_MODEL = "HINDSIGHT_API_REFLECT_LLM_MODEL"
 ENV_REFLECT_LLM_BASE_URL = "HINDSIGHT_API_REFLECT_LLM_BASE_URL"
+ENV_REFLECT_LLM_MAX_CONCURRENT = "HINDSIGHT_API_REFLECT_LLM_MAX_CONCURRENT"
+ENV_REFLECT_LLM_MAX_RETRIES = "HINDSIGHT_API_REFLECT_LLM_MAX_RETRIES"
+ENV_REFLECT_LLM_INITIAL_BACKOFF = "HINDSIGHT_API_REFLECT_LLM_INITIAL_BACKOFF"
+ENV_REFLECT_LLM_MAX_BACKOFF = "HINDSIGHT_API_REFLECT_LLM_MAX_BACKOFF"
+ENV_REFLECT_LLM_TIMEOUT = "HINDSIGHT_API_REFLECT_LLM_TIMEOUT"

 ENV_CONSOLIDATION_LLM_PROVIDER = "HINDSIGHT_API_CONSOLIDATION_LLM_PROVIDER"
 ENV_CONSOLIDATION_LLM_API_KEY = "HINDSIGHT_API_CONSOLIDATION_LLM_API_KEY"
 ENV_CONSOLIDATION_LLM_MODEL = "HINDSIGHT_API_CONSOLIDATION_LLM_MODEL"
 ENV_CONSOLIDATION_LLM_BASE_URL = "HINDSIGHT_API_CONSOLIDATION_LLM_BASE_URL"
+ENV_CONSOLIDATION_LLM_MAX_CONCURRENT = "HINDSIGHT_API_CONSOLIDATION_LLM_MAX_CONCURRENT"
+ENV_CONSOLIDATION_LLM_MAX_RETRIES = "HINDSIGHT_API_CONSOLIDATION_LLM_MAX_RETRIES"
+ENV_CONSOLIDATION_LLM_INITIAL_BACKOFF = "HINDSIGHT_API_CONSOLIDATION_LLM_INITIAL_BACKOFF"
+ENV_CONSOLIDATION_LLM_MAX_BACKOFF = "HINDSIGHT_API_CONSOLIDATION_LLM_MAX_BACKOFF"
+ENV_CONSOLIDATION_LLM_TIMEOUT = "HINDSIGHT_API_CONSOLIDATION_LLM_TIMEOUT"

 ENV_EMBEDDINGS_PROVIDER = "HINDSIGHT_API_EMBEDDINGS_PROVIDER"
 ENV_EMBEDDINGS_LOCAL_MODEL = "HINDSIGHT_API_EMBEDDINGS_LOCAL_MODEL"
+ENV_EMBEDDINGS_LOCAL_FORCE_CPU = "HINDSIGHT_API_EMBEDDINGS_LOCAL_FORCE_CPU"
 ENV_EMBEDDINGS_TEI_URL = "HINDSIGHT_API_EMBEDDINGS_TEI_URL"
 ENV_EMBEDDINGS_OPENAI_API_KEY = "HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY"
 ENV_EMBEDDINGS_OPENAI_MODEL = "HINDSIGHT_API_EMBEDDINGS_OPENAI_MODEL"
@@ -65,6 +85,7 @@ ENV_RERANKER_LITELLM_MODEL = "HINDSIGHT_API_RERANKER_LITELLM_MODEL"

 ENV_RERANKER_PROVIDER = "HINDSIGHT_API_RERANKER_PROVIDER"
 ENV_RERANKER_LOCAL_MODEL = "HINDSIGHT_API_RERANKER_LOCAL_MODEL"
+ENV_RERANKER_LOCAL_FORCE_CPU = "HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU"
 ENV_RERANKER_LOCAL_MAX_CONCURRENT = "HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT"
 ENV_RERANKER_TEI_URL = "HINDSIGHT_API_RERANKER_TEI_URL"
 ENV_RERANKER_TEI_BATCH_SIZE = "HINDSIGHT_API_RERANKER_TEI_BATCH_SIZE"
@@ -87,17 +108,22 @@ ENV_MCP_LOCAL_BANK_ID = "HINDSIGHT_API_MCP_LOCAL_BANK_ID"
 ENV_MCP_INSTRUCTIONS = "HINDSIGHT_API_MCP_INSTRUCTIONS"
 ENV_MENTAL_MODEL_REFRESH_CONCURRENCY = "HINDSIGHT_API_MENTAL_MODEL_REFRESH_CONCURRENCY"

+# Vertex AI configuration
+ENV_LLM_VERTEXAI_PROJECT_ID = "HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID"
+ENV_LLM_VERTEXAI_REGION = "HINDSIGHT_API_LLM_VERTEXAI_REGION"
+ENV_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY = "HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY"
+
 # Retain settings
 ENV_RETAIN_MAX_COMPLETION_TOKENS = "HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS"
 ENV_RETAIN_CHUNK_SIZE = "HINDSIGHT_API_RETAIN_CHUNK_SIZE"
 ENV_RETAIN_EXTRACT_CAUSAL_LINKS = "HINDSIGHT_API_RETAIN_EXTRACT_CAUSAL_LINKS"
 ENV_RETAIN_EXTRACTION_MODE = "HINDSIGHT_API_RETAIN_EXTRACTION_MODE"
 ENV_RETAIN_CUSTOM_INSTRUCTIONS = "HINDSIGHT_API_RETAIN_CUSTOM_INSTRUCTIONS"
-ENV_RETAIN_OBSERVATIONS_ASYNC = "HINDSIGHT_API_RETAIN_OBSERVATIONS_ASYNC"

 # Observations settings (consolidated knowledge from facts)
 ENV_ENABLE_OBSERVATIONS = "HINDSIGHT_API_ENABLE_OBSERVATIONS"
 ENV_CONSOLIDATION_BATCH_SIZE = "HINDSIGHT_API_CONSOLIDATION_BATCH_SIZE"
+ENV_CONSOLIDATION_MAX_TOKENS = "HINDSIGHT_API_CONSOLIDATION_MAX_TOKENS"

 # Optimization flags
 ENV_SKIP_LLM_VERIFICATION = "HINDSIGHT_API_SKIP_LLM_VERIFICATION"
@@ -117,26 +143,52 @@ ENV_WORKER_ENABLED = "HINDSIGHT_API_WORKER_ENABLED"
 ENV_WORKER_ID = "HINDSIGHT_API_WORKER_ID"
 ENV_WORKER_POLL_INTERVAL_MS = "HINDSIGHT_API_WORKER_POLL_INTERVAL_MS"
 ENV_WORKER_MAX_RETRIES = "HINDSIGHT_API_WORKER_MAX_RETRIES"
-ENV_WORKER_BATCH_SIZE = "HINDSIGHT_API_WORKER_BATCH_SIZE"
 ENV_WORKER_HTTP_PORT = "HINDSIGHT_API_WORKER_HTTP_PORT"
+ENV_WORKER_MAX_SLOTS = "HINDSIGHT_API_WORKER_MAX_SLOTS"
+ENV_WORKER_CONSOLIDATION_MAX_SLOTS = "HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS"

 # Reflect agent settings
 ENV_REFLECT_MAX_ITERATIONS = "HINDSIGHT_API_REFLECT_MAX_ITERATIONS"

 # Default values
 DEFAULT_DATABASE_URL = "pg0"
+DEFAULT_DATABASE_SCHEMA = "public"
 DEFAULT_LLM_PROVIDER = "openai"
-DEFAULT_LLM_MODEL = "gpt-5-mini"
+
+# Provider-specific default models
+PROVIDER_DEFAULT_MODELS = {
+    "openai": "o3-mini",
+    "anthropic": "claude-haiku-4-5-20251001",
+    "gemini": "gemini-2.5-flash",
+    "groq": "openai/gpt-oss-120b",
+    "ollama": "gemma3:12b",
+    "lmstudio": "local-model",
+    "vertexai": "gemini-2.0-flash-001",
+    "openai-codex": "gpt-5.2-codex",
+    "claude-code": "claude-sonnet-4-5-20250929",
+    "mock": "mock-model",
+}
+DEFAULT_LLM_MODEL = "o3-mini"  # Fallback if provider not in table
 DEFAULT_LLM_MAX_CONCURRENT = 32
+DEFAULT_LLM_MAX_RETRIES = 10  # Max retry attempts for LLM API calls
+DEFAULT_LLM_INITIAL_BACKOFF = 1.0  # Initial backoff in seconds for retry exponential backoff
+DEFAULT_LLM_MAX_BACKOFF = 60.0  # Max backoff cap in seconds for retry exponential backoff
 DEFAULT_LLM_TIMEOUT = 120.0  # seconds

+# Vertex AI defaults
+DEFAULT_LLM_VERTEXAI_PROJECT_ID = None  # Required for Vertex AI
+DEFAULT_LLM_VERTEXAI_REGION = "us-central1"
+DEFAULT_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY = None  # Optional, uses ADC if not set
+
 DEFAULT_EMBEDDINGS_PROVIDER = "local"
 DEFAULT_EMBEDDINGS_LOCAL_MODEL = "BAAI/bge-small-en-v1.5"
+DEFAULT_EMBEDDINGS_LOCAL_FORCE_CPU = False  # Force CPU mode for local embeddings (avoids MPS/XPC issues on macOS)
 DEFAULT_EMBEDDINGS_OPENAI_MODEL = "text-embedding-3-small"
 DEFAULT_EMBEDDING_DIMENSION = 384

 DEFAULT_RERANKER_PROVIDER = "local"
 DEFAULT_RERANKER_LOCAL_MODEL = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+DEFAULT_RERANKER_LOCAL_FORCE_CPU = False  # Force CPU mode for local reranker (avoids MPS/XPC issues on macOS)
 DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4  # Limit concurrent CPU-bound reranking to prevent thrashing
 DEFAULT_RERANKER_TEI_BATCH_SIZE = 128
 DEFAULT_RERANKER_TEI_MAX_CONCURRENT = 8
@@ -172,11 +224,11 @@ DEFAULT_RETAIN_EXTRACT_CAUSAL_LINKS = True  # Extract causal links between facts
 DEFAULT_RETAIN_EXTRACTION_MODE = "concise"  # Extraction mode: "concise", "verbose", or "custom"
 RETAIN_EXTRACTION_MODES = ("concise", "verbose", "custom")  # Allowed extraction modes
 DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS = None  # Custom extraction guidelines (only used when mode="custom")
-DEFAULT_RETAIN_OBSERVATIONS_ASYNC = False  # Run observation generation async (after retain completes)

 # Observations defaults (consolidated knowledge from facts)
 DEFAULT_ENABLE_OBSERVATIONS = True  # Observations enabled by default
 DEFAULT_CONSOLIDATION_BATCH_SIZE = 50  # Memories to load per batch (internal memory optimization)
+DEFAULT_CONSOLIDATION_MAX_TOKENS = 1024  # Max tokens for recall when finding related observations

 # Database migrations
 DEFAULT_RUN_MIGRATIONS_ON_STARTUP = True
@@ -192,8 +244,9 @@ DEFAULT_WORKER_ENABLED = True  # API runs worker by default (standalone mode)
 DEFAULT_WORKER_ID = None  # Will use hostname if not specified
 DEFAULT_WORKER_POLL_INTERVAL_MS = 500  # Poll database every 500ms
 DEFAULT_WORKER_MAX_RETRIES = 3  # Max retries before marking task failed
-DEFAULT_WORKER_BATCH_SIZE = 10  # Tasks to claim per poll cycle
 DEFAULT_WORKER_HTTP_PORT = 8889  # HTTP port for worker metrics/health
+DEFAULT_WORKER_MAX_SLOTS = 10  # Total concurrent tasks per worker
+DEFAULT_WORKER_CONSOLIDATION_MAX_SLOTS = 2  # Max concurrent consolidation tasks per worker

 # Reflect agent settings
 DEFAULT_REFLECT_MAX_ITERATIONS = 10  # Max tool call iterations before forcing response
@@ -264,12 +317,18 @@ def _validate_extraction_mode(mode: str) -> str:
    return mode_lower


+def _get_default_model_for_provider(provider: str) -> str:
+    """Get the default model for a given provider."""
+    return PROVIDER_DEFAULT_MODELS.get(provider.lower(), DEFAULT_LLM_MODEL)
+
+
@dataclass
 class HindsightConfig:
    """Configuration container for Hindsight API."""

    # Database
    database_url: str
+    database_schema: str

    # LLM (default, used as fallback for per-operation config)
    llm_provider: str
@@ -277,27 +336,51 @@ class HindsightConfig:
    llm_model: str
    llm_base_url: str | None
    llm_max_concurrent: int
+    llm_max_retries: int
+    llm_initial_backoff: float
+    llm_max_backoff: float
    llm_timeout: float

+    # Vertex AI configuration
+    llm_vertexai_project_id: str | None
+    llm_vertexai_region: str
+    llm_vertexai_service_account_key: str | None
+
    # Per-operation LLM configuration (None = use default LLM config)
    retain_llm_provider: str | None
    retain_llm_api_key: str | None
    retain_llm_model: str | None
    retain_llm_base_url: str | None
+    retain_llm_max_concurrent: int | None
+    retain_llm_max_retries: int | None
+    retain_llm_initial_backoff: float | None
+    retain_llm_max_backoff: float | None
+    retain_llm_timeout: float | None

    reflect_llm_provider: str | None
    reflect_llm_api_key: str | None
    reflect_llm_model: str | None
    reflect_llm_base_url: str | None
+    reflect_llm_max_concurrent: int | None
+    reflect_llm_max_retries: int | None
+    reflect_llm_initial_backoff: float | None
+    reflect_llm_max_backoff: float | None
+    reflect_llm_timeout: float | None

    consolidation_llm_provider: str | None
    consolidation_llm_api_key: str | None
    consolidation_llm_model: str | None
    consolidation_llm_base_url: str | None
+    consolidation_llm_max_concurrent: int | None
+    consolidation_llm_max_retries: int | None
+    consolidation_llm_initial_backoff: float | None
+    consolidation_llm_max_backoff: float | None
+    consolidation_llm_timeout: float | None

    # Embeddings
    embeddings_provider: str
    embeddings_local_model: str
+    embeddings_local_force_cpu: bool
    embeddings_tei_url: str | None
    embeddings_openai_base_url: str | None
    embeddings_cohere_base_url: str | None
@@ -305,6 +388,8 @@ class HindsightConfig:
    # Reranker
    reranker_provider: str
    reranker_local_model: str
+    reranker_local_force_cpu: bool
+    reranker_local_max_concurrent: int
    reranker_tei_url: str | None
    reranker_tei_batch_size: int
    reranker_tei_max_concurrent: int
@@ -331,11 +416,11 @@ class HindsightConfig:
    retain_extract_causal_links: bool
    retain_extraction_mode: str
    retain_custom_instructions: str | None
-    retain_observations_async: bool

    # Observations settings (consolidated knowledge from facts)
    enable_observations: bool
    consolidation_batch_size: int
+    consolidation_max_tokens: int

    # Optimization flags
    skip_llm_verification: bool
@@ -355,47 +440,146 @@ class HindsightConfig:
    worker_id: str | None
    worker_poll_interval_ms: int
    worker_max_retries: int
-    worker_batch_size: int
    worker_http_port: int
+    worker_max_slots: int
+    worker_consolidation_max_slots: int

    # Reflect agent settings
    reflect_max_iterations: int

+    def validate(self) -> None:
+        """Validate configuration values and raise errors for invalid combinations."""
+        # RETAIN_MAX_COMPLETION_TOKENS must be greater than RETAIN_CHUNK_SIZE
+        # to ensure the LLM has enough output capacity to extract facts from chunks
+        if self.retain_max_completion_tokens <= self.retain_chunk_size:
+            raise ValueError(
+                f"Invalid configuration: HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS "
+                f"({self.retain_max_completion_tokens}) must be greater than "
+                f"HINDSIGHT_API_RETAIN_CHUNK_SIZE ({self.retain_chunk_size}). "
+                f"\n\nYou have two options to fix this:"
+                f"\n  1. Increase HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS to a value > {self.retain_chunk_size}"
+                f"\n  2. Use a model that supports at least {self.retain_max_completion_tokens} output tokens"
+                f"\n     (current model: {self.retain_llm_model or self.llm_model}, "
+                f"provider: {self.retain_llm_provider or self.llm_provider})"
+            )
+
    @classmethod
    def from_env(cls) -> "HindsightConfig":
        """Create configuration from environment variables."""
-        return cls(
+        # Get provider first to determine default model
+        llm_provider = os.getenv(ENV_LLM_PROVIDER, DEFAULT_LLM_PROVIDER)
+        llm_model = os.getenv(ENV_LLM_MODEL) or _get_default_model_for_provider(llm_provider)
+
+        config = cls(
            # Database
            database_url=os.getenv(ENV_DATABASE_URL, DEFAULT_DATABASE_URL),
+            database_schema=os.getenv(ENV_DATABASE_SCHEMA, DEFAULT_DATABASE_SCHEMA),
            # LLM
-            llm_provider=os.getenv(ENV_LLM_PROVIDER, DEFAULT_LLM_PROVIDER),
+            llm_provider=llm_provider,
            llm_api_key=os.getenv(ENV_LLM_API_KEY),
-            llm_model=os.getenv(ENV_LLM_MODEL, DEFAULT_LLM_MODEL),
+            llm_model=llm_model,
            llm_base_url=os.getenv(ENV_LLM_BASE_URL) or None,
            llm_max_concurrent=int(os.getenv(ENV_LLM_MAX_CONCURRENT, str(DEFAULT_LLM_MAX_CONCURRENT))),
+            llm_max_retries=int(os.getenv(ENV_LLM_MAX_RETRIES, str(DEFAULT_LLM_MAX_RETRIES))),
+            llm_initial_backoff=float(os.getenv(ENV_LLM_INITIAL_BACKOFF, str(DEFAULT_LLM_INITIAL_BACKOFF))),
+            llm_max_backoff=float(os.getenv(ENV_LLM_MAX_BACKOFF, str(DEFAULT_LLM_MAX_BACKOFF))),
            llm_timeout=float(os.getenv(ENV_LLM_TIMEOUT, str(DEFAULT_LLM_TIMEOUT))),
+            # Vertex AI
+            llm_vertexai_project_id=os.getenv(ENV_LLM_VERTEXAI_PROJECT_ID) or DEFAULT_LLM_VERTEXAI_PROJECT_ID,
+            llm_vertexai_region=os.getenv(ENV_LLM_VERTEXAI_REGION, DEFAULT_LLM_VERTEXAI_REGION),
+            llm_vertexai_service_account_key=os.getenv(ENV_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY)
+            or DEFAULT_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY,
            # Per-operation LLM config (None = use default)
            retain_llm_provider=os.getenv(ENV_RETAIN_LLM_PROVIDER) or None,
            retain_llm_api_key=os.getenv(ENV_RETAIN_LLM_API_KEY) or None,
-            retain_llm_model=os.getenv(ENV_RETAIN_LLM_MODEL) or None,
+            retain_llm_model=os.getenv(ENV_RETAIN_LLM_MODEL)
+            or (
+                _get_default_model_for_provider(os.getenv(ENV_RETAIN_LLM_PROVIDER))
+                if os.getenv(ENV_RETAIN_LLM_PROVIDER)
+                else None
+            ),
            retain_llm_base_url=os.getenv(ENV_RETAIN_LLM_BASE_URL) or None,
+            retain_llm_max_concurrent=int(os.getenv(ENV_RETAIN_LLM_MAX_CONCURRENT))
+            if os.getenv(ENV_RETAIN_LLM_MAX_CONCURRENT)
+            else None,
+            retain_llm_max_retries=int(os.getenv(ENV_RETAIN_LLM_MAX_RETRIES))
+            if os.getenv(ENV_RETAIN_LLM_MAX_RETRIES)
+            else None,
+            retain_llm_initial_backoff=float(os.getenv(ENV_RETAIN_LLM_INITIAL_BACKOFF))
+            if os.getenv(ENV_RETAIN_LLM_INITIAL_BACKOFF)
+            else None,
+            retain_llm_max_backoff=float(os.getenv(ENV_RETAIN_LLM_MAX_BACKOFF))
+            if os.getenv(ENV_RETAIN_LLM_MAX_BACKOFF)
+            else None,
+            retain_llm_timeout=float(os.getenv(ENV_RETAIN_LLM_TIMEOUT)) if os.getenv(ENV_RETAIN_LLM_TIMEOUT) else None,
            reflect_llm_provider=os.getenv(ENV_REFLECT_LLM_PROVIDER) or None,
            reflect_llm_api_key=os.getenv(ENV_REFLECT_LLM_API_KEY) or None,
-            reflect_llm_model=os.getenv(ENV_REFLECT_LLM_MODEL) or None,
+            reflect_llm_model=os.getenv(ENV_REFLECT_LLM_MODEL)
+            or (
+                _get_default_model_for_provider(os.getenv(ENV_REFLECT_LLM_PROVIDER))
+                if os.getenv(ENV_REFLECT_LLM_PROVIDER)
+                else None
+            ),
            reflect_llm_base_url=os.getenv(ENV_REFLECT_LLM_BASE_URL) or None,
+            reflect_llm_max_concurrent=int(os.getenv(ENV_REFLECT_LLM_MAX_CONCURRENT))
+            if os.getenv(ENV_REFLECT_LLM_MAX_CONCURRENT)
+            else None,
+            reflect_llm_max_retries=int(os.getenv(ENV_REFLECT_LLM_MAX_RETRIES))
+            if os.getenv(ENV_REFLECT_LLM_MAX_RETRIES)
+            else None,
+            reflect_llm_initial_backoff=float(os.getenv(ENV_REFLECT_LLM_INITIAL_BACKOFF))
+            if os.getenv(ENV_REFLECT_LLM_INITIAL_BACKOFF)
+            else None,
+            reflect_llm_max_backoff=float(os.getenv(ENV_REFLECT_LLM_MAX_BACKOFF))
+            if os.getenv(ENV_REFLECT_LLM_MAX_BACKOFF)
+            else None,
+            reflect_llm_timeout=float(os.getenv(ENV_REFLECT_LLM_TIMEOUT))
+            if os.getenv(ENV_REFLECT_LLM_TIMEOUT)
+            else None,
            consolidation_llm_provider=os.getenv(ENV_CONSOLIDATION_LLM_PROVIDER) or None,
            consolidation_llm_api_key=os.getenv(ENV_CONSOLIDATION_LLM_API_KEY) or None,
-            consolidation_llm_model=os.getenv(ENV_CONSOLIDATION_LLM_MODEL) or None,
+            consolidation_llm_model=os.getenv(ENV_CONSOLIDATION_LLM_MODEL)
+            or (
+                _get_default_model_for_provider(os.getenv(ENV_CONSOLIDATION_LLM_PROVIDER))
+                if os.getenv(ENV_CONSOLIDATION_LLM_PROVIDER)
+                else None
+            ),
            consolidation_llm_base_url=os.getenv(ENV_CONSOLIDATION_LLM_BASE_URL) or None,
+            consolidation_llm_max_concurrent=int(os.getenv(ENV_CONSOLIDATION_LLM_MAX_CONCURRENT))
+            if os.getenv(ENV_CONSOLIDATION_LLM_MAX_CONCURRENT)
+            else None,
+            consolidation_llm_max_retries=int(os.getenv(ENV_CONSOLIDATION_LLM_MAX_RETRIES))
+            if os.getenv(ENV_CONSOLIDATION_LLM_MAX_RETRIES)
+            else None,
+            consolidation_llm_initial_backoff=float(os.getenv(ENV_CONSOLIDATION_LLM_INITIAL_BACKOFF))
+            if os.getenv(ENV_CONSOLIDATION_LLM_INITIAL_BACKOFF)
+            else None,
+            consolidation_llm_max_backoff=float(os.getenv(ENV_CONSOLIDATION_LLM_MAX_BACKOFF))
+            if os.getenv(ENV_CONSOLIDATION_LLM_MAX_BACKOFF)
+            else None,
+            consolidation_llm_timeout=float(os.getenv(ENV_CONSOLIDATION_LLM_TIMEOUT))
+            if os.getenv(ENV_CONSOLIDATION_LLM_TIMEOUT)
+            else None,
            # Embeddings
            embeddings_provider=os.getenv(ENV_EMBEDDINGS_PROVIDER, DEFAULT_EMBEDDINGS_PROVIDER),
            embeddings_local_model=os.getenv(ENV_EMBEDDINGS_LOCAL_MODEL, DEFAULT_EMBEDDINGS_LOCAL_MODEL),
+            embeddings_local_force_cpu=os.getenv(
+                ENV_EMBEDDINGS_LOCAL_FORCE_CPU, str(DEFAULT_EMBEDDINGS_LOCAL_FORCE_CPU)
+            ).lower()
+            in ("true", "1"),
            embeddings_tei_url=os.getenv(ENV_EMBEDDINGS_TEI_URL),
            embeddings_openai_base_url=os.getenv(ENV_EMBEDDINGS_OPENAI_BASE_URL) or None,
            embeddings_cohere_base_url=os.getenv(ENV_EMBEDDINGS_COHERE_BASE_URL) or None,
            # Reranker
            reranker_provider=os.getenv(ENV_RERANKER_PROVIDER, DEFAULT_RERANKER_PROVIDER),
            reranker_local_model=os.getenv(ENV_RERANKER_LOCAL_MODEL, DEFAULT_RERANKER_LOCAL_MODEL),
+            reranker_local_force_cpu=os.getenv(
+                ENV_RERANKER_LOCAL_FORCE_CPU, str(DEFAULT_RERANKER_LOCAL_FORCE_CPU)
+            ).lower()
+            in ("true", "1"),
+            reranker_local_max_concurrent=int(
+                os.getenv(ENV_RERANKER_LOCAL_MAX_CONCURRENT, str(DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT))
+            ),
            reranker_tei_url=os.getenv(ENV_RERANKER_TEI_URL),
            reranker_tei_batch_size=int(os.getenv(ENV_RERANKER_TEI_BATCH_SIZE, str(DEFAULT_RERANKER_TEI_BATCH_SIZE))),
            reranker_tei_max_concurrent=int(
@@ -435,15 +619,14 @@ class HindsightConfig:
                os.getenv(ENV_RETAIN_EXTRACTION_MODE, DEFAULT_RETAIN_EXTRACTION_MODE)
            ),
            retain_custom_instructions=os.getenv(ENV_RETAIN_CUSTOM_INSTRUCTIONS) or DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS,
-            retain_observations_async=os.getenv(
-                ENV_RETAIN_OBSERVATIONS_ASYNC, str(DEFAULT_RETAIN_OBSERVATIONS_ASYNC)
-            ).lower()
-            == "true",
            # Observations settings (consolidated knowledge from facts)
            enable_observations=os.getenv(ENV_ENABLE_OBSERVATIONS, str(DEFAULT_ENABLE_OBSERVATIONS)).lower() == "true",
            consolidation_batch_size=int(
                os.getenv(ENV_CONSOLIDATION_BATCH_SIZE, str(DEFAULT_CONSOLIDATION_BATCH_SIZE))
            ),
+            consolidation_max_tokens=int(
+                os.getenv(ENV_CONSOLIDATION_MAX_TOKENS, str(DEFAULT_CONSOLIDATION_MAX_TOKENS))
+            ),
            # Database migrations
            run_migrations_on_startup=os.getenv(ENV_RUN_MIGRATIONS_ON_STARTUP, "true").lower() == "true",
            # Database connection pool
@@ -456,11 +639,16 @@ class HindsightConfig:
            worker_id=os.getenv(ENV_WORKER_ID) or DEFAULT_WORKER_ID,
            worker_poll_interval_ms=int(os.getenv(ENV_WORKER_POLL_INTERVAL_MS, str(DEFAULT_WORKER_POLL_INTERVAL_MS))),
            worker_max_retries=int(os.getenv(ENV_WORKER_MAX_RETRIES, str(DEFAULT_WORKER_MAX_RETRIES))),
-            worker_batch_size=int(os.getenv(ENV_WORKER_BATCH_SIZE, str(DEFAULT_WORKER_BATCH_SIZE))),
            worker_http_port=int(os.getenv(ENV_WORKER_HTTP_PORT, str(DEFAULT_WORKER_HTTP_PORT))),
+            worker_max_slots=int(os.getenv(ENV_WORKER_MAX_SLOTS, str(DEFAULT_WORKER_MAX_SLOTS))),
+            worker_consolidation_max_slots=int(
+                os.getenv(ENV_WORKER_CONSOLIDATION_MAX_SLOTS, str(DEFAULT_WORKER_CONSOLIDATION_MAX_SLOTS))
+            ),
            # Reflect agent settings
            reflect_max_iterations=int(os.getenv(ENV_REFLECT_MAX_ITERATIONS, str(DEFAULT_REFLECT_MAX_ITERATIONS))),
        )
+        config.validate()
+        return config

    def get_llm_base_url(self) -> str:
        """Get the LLM base URL, with provider-specific defaults."""
@@ -515,7 +703,7 @@ class HindsightConfig:

    def log_config(self) -> None:
        """Log the current configuration (without sensitive values)."""
-        logger.info(f"Database: {self.database_url}")
+        logger.info(f"Database: {self.database_url} (schema: {self.database_schema})")
        logger.info(f"LLM: provider={self.llm_provider}, model={self.llm_model}")
        if self.retain_llm_provider or self.retain_llm_model:
            retain_provider = self.retain_llm_provider or self.llm_provider
@@ -1,11 +1,10 @@
 """
 Daemon mode support for Hindsight API.

-Provides idle timeout and lockfile management for running as a background daemon.
+Provides idle timeout for running as a background daemon.
 """

 import asyncio
-import fcntl
 import logging
 import os
 import sys
@@ -15,10 +14,11 @@ from pathlib import Path
 logger = logging.getLogger(__name__)

 # Default daemon configuration
-DEFAULT_DAEMON_PORT = 8889
+DEFAULT_DAEMON_PORT = 8888
 DEFAULT_IDLE_TIMEOUT = 0  # 0 = no auto-exit (hindsight-embed passes its own timeout)
-LOCKFILE_PATH = Path.home() / ".hindsight" / "daemon.lock"
-DAEMON_LOG_PATH = Path.home() / ".hindsight" / "daemon.log"
+
+# Allow override via environment variable for profile-specific logs
+DAEMON_LOG_PATH = Path(os.getenv("HINDSIGHT_API_DAEMON_LOG", str(Path.home() / ".hindsight" / "daemon.log")))


 class IdleTimeoutMiddleware:
@@ -52,82 +52,10 @@ class IdleTimeoutMiddleware:
                logger.info(f"Idle timeout reached ({self.idle_timeout}s), shutting down daemon")
                # Give a moment for any in-flight requests
                await asyncio.sleep(1)
-                os._exit(0)
+                # Send SIGTERM to ourselves to trigger graceful shutdown
+                import signal

-
-class DaemonLock:
-    """
-    File-based lock to prevent multiple daemon instances.
-
-    Uses fcntl.flock for atomic locking on Unix systems.
-    """
-
-    def __init__(self, lockfile: Path = LOCKFILE_PATH):
-        self.lockfile = lockfile
-        self._fd = None
-
-    def acquire(self) -> bool:
-        """
-        Try to acquire the daemon lock.
-
-        Returns True if lock acquired, False if another daemon is running.
-        """
-        self.lockfile.parent.mkdir(parents=True, exist_ok=True)
-
-        try:
-            self._fd = open(self.lockfile, "w")
-            fcntl.flock(self._fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-            # Write PID for debugging
-            self._fd.write(str(os.getpid()))
-            self._fd.flush()
-            return True
-        except (IOError, OSError):
-            # Lock is held by another process
-            if self._fd:
-                self._fd.close()
-                self._fd = None
-            return False
-
-    def release(self):
-        """Release the daemon lock."""
-        if self._fd:
-            try:
-                fcntl.flock(self._fd.fileno(), fcntl.LOCK_UN)
-                self._fd.close()
-            except Exception:
-                pass
-            finally:
-                self._fd = None
-                # Remove lockfile
-                try:
-                    self.lockfile.unlink()
-                except Exception:
-                    pass
-
-    def is_locked(self) -> bool:
-        """Check if the lock is held by another process."""
-        if not self.lockfile.exists():
-            return False
-
-        try:
-            fd = open(self.lockfile, "r")
-            fcntl.flock(fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-            # We got the lock, so no one else has it
-            fcntl.flock(fd.fileno(), fcntl.LOCK_UN)
-            fd.close()
-            return False
-        except (IOError, OSError):
-            return True
-
-    def get_pid(self) -> int | None:
-        """Get the PID of the daemon holding the lock."""
-        if not self.lockfile.exists():
-            return None
-        try:
-            with open(self.lockfile, "r") as f:
-                return int(f.read().strip())
-        except (ValueError, IOError):
-            return None
+                os.kill(os.getpid(), signal.SIGTERM)


 def daemonize():
@@ -136,16 +64,21 @@ def daemonize():

    Uses double-fork technique to properly detach from terminal.
    """
-    # First fork
-    pid = os.fork()
-    if pid > 0:
-        # Parent exits
-        sys.exit(0)
+    # First fork - detach from parent
+    try:
+        pid = os.fork()
+        if pid > 0:
+            sys.exit(0)
+    except OSError as e:
+        sys.stderr.write(f"fork #1 failed: {e}\n")
+        sys.exit(1)

-    # Create new session
+    # Decouple from parent environment
+    os.chdir("/")
    os.setsid()
+    os.umask(0)

-    # Second fork to prevent zombie processes
+    # Second fork - prevent zombie
    pid = os.fork()
    if pid > 0:
        sys.exit(0)
@@ -178,27 +111,3 @@ def check_daemon_running(port: int = DEFAULT_DAEMON_PORT) -> bool:
        return result == 0
    except Exception:
        return False
-
-
-def stop_daemon(port: int = DEFAULT_DAEMON_PORT) -> bool:
-    """Stop a running daemon by sending SIGTERM to the process."""
-    lock = DaemonLock()
-    pid = lock.get_pid()
-
-    if pid is None:
-        return False
-
-    try:
-        import signal
-
-        os.kill(pid, signal.SIGTERM)
-        # Wait for process to exit
-        for _ in range(50):  # Wait up to 5 seconds
-            time.sleep(0.1)
-            try:
-                os.kill(pid, 0)  # Check if process exists
-            except OSError:
-                return True  # Process exited
-        return False
-    except OSError:
-        return False
@@ -143,11 +143,18 @@ async def run_consolidation_job(
        "skipped": 0,
    }

+    # Track all unique tags from consolidated memories for mental model refresh filtering
+    consolidated_tags: set[str] = set()
+
    batch_num = 0
+    last_progress_timings = {}  # Track timings at last progress log
    while True:
        batch_num += 1
        batch_start = time.time()

+        # Snapshot timings at batch start for per-batch calculation
+        batch_start_timings = perf.timings.copy()
+
        # Fetch next batch of unconsolidated memories
        async with pool.acquire() as conn:
            t0 = time.time()
@@ -172,6 +179,11 @@ async def run_consolidation_job(
        for memory in memories:
            mem_start = time.time()

+            # Track tags from this memory for mental model refresh filtering
+            memory_tags = memory.get("tags") or []
+            if memory_tags:
+                consolidated_tags.update(memory_tags)
+
            # Process the memory (uses its own connection internally)
            async with pool.acquire() as conn:
                result = await _process_memory(
@@ -217,19 +229,44 @@ async def run_consolidation_job(
            elif action == "skipped":
                stats["skipped"] += 1

-            # Log progress periodically
+            # Log progress periodically with timing breakdown
            if stats["memories_processed"] % 10 == 0:
+                # Calculate timing deltas since last progress log
+                timing_parts = []
+                for key in ["recall", "llm", "embedding", "db_write"]:
+                    if key in perf.timings:
+                        delta = perf.timings[key] - last_progress_timings.get(key, 0)
+                        timing_parts.append(f"{key}={delta:.2f}s")
+
+                timing_str = f" | {', '.join(timing_parts)}" if timing_parts else ""
                logger.info(
                    f"[CONSOLIDATION] bank={bank_id} progress: "
-                    f"{stats['memories_processed']}/{total_count} memories processed"
+                    f"{stats['memories_processed']}/{total_count} memories processed{timing_str}"
                )

+                # Update last progress snapshot
+                last_progress_timings = perf.timings.copy()
+
        batch_time = time.time() - batch_start
        perf.log(
            f"[2] Batch {batch_num}: {len(memories)} memories in {batch_time:.3f}s "
            f"(avg {batch_time / len(memories):.3f}s/memory)"
        )

+        # Log timing breakdown after each batch (delta from batch start)
+        timing_parts = []
+        for key in ["recall", "llm", "embedding", "db_write"]:
+            if key in perf.timings:
+                delta = perf.timings[key] - batch_start_timings.get(key, 0)
+                timing_parts.append(f"{key}={delta:.3f}s")
+
+        if timing_parts:
+            avg_per_memory = batch_time / len(memories) if memories else 0
+            logger.info(
+                f"[CONSOLIDATION] bank={bank_id} batch {batch_num}/{len(memories)} memories: "
+                f"{', '.join(timing_parts)} | avg={avg_per_memory:.3f}s/memory"
+            )
+
    # Build summary
    perf.log(
        f"[3] Results: {stats['memories_processed']} memories -> "
@@ -255,10 +292,12 @@ async def run_consolidation_job(
        perf.log(f"[4] Timing breakdown: {', '.join(timing_parts)}")

    # Trigger mental model refreshes for models with refresh_after_consolidation=true
+    # SECURITY: Only refresh mental models with matching tags (or all if no tags were consolidated)
    mental_models_refreshed = await _trigger_mental_model_refreshes(
        memory_engine=memory_engine,
        bank_id=bank_id,
        request_context=request_context,
+        consolidated_tags=list(consolidated_tags) if consolidated_tags else None,
        perf=perf,
    )
    stats["mental_models_refreshed"] = mental_models_refreshed
@@ -272,15 +311,20 @@ async def _trigger_mental_model_refreshes(
    memory_engine: "MemoryEngine",
    bank_id: str,
    request_context: "RequestContext",
+    consolidated_tags: list[str] | None = None,
    perf: ConsolidationPerfLog | None = None,
 ) -> int:
    """
    Trigger refreshes for mental models with refresh_after_consolidation=true.

+    SECURITY: Only triggers refresh for mental models whose tags overlap with the
+    consolidated memory tags, preventing unnecessary refreshes across security boundaries.
+
    Args:
        memory_engine: MemoryEngine instance
        bank_id: Bank identifier
        request_context: Request context for authentication
+        consolidated_tags: Tags from memories that were consolidated (None = refresh all)
        perf: Performance logging

    Returns:
@@ -289,22 +333,52 @@ async def _trigger_mental_model_refreshes(
    pool = memory_engine._pool

    # Find mental models with refresh_after_consolidation=true
+    # SECURITY: Control which mental models get refreshed based on tags
    async with pool.acquire() as conn:
-        rows = await conn.fetch(
-            f"""
-            SELECT id, name
-            FROM {fq_table("mental_models")}
-            WHERE bank_id = $1
-              AND (trigger->>'refresh_after_consolidation')::boolean = true
-            """,
-            bank_id,
-        )
+        if consolidated_tags:
+            # Tagged memories were consolidated - refresh:
+            # 1. Mental models with overlapping tags (security boundary)
+            # 2. Untagged mental models (they're "global" and available to all contexts)
+            # DO NOT refresh mental models with different tags
+            rows = await conn.fetch(
+                f"""
+                SELECT id, name, tags
+                FROM {fq_table("mental_models")}
+                WHERE bank_id = $1
+                  AND (trigger->>'refresh_after_consolidation')::boolean = true
+                  AND (
+                    (tags IS NOT NULL AND tags != '{{}}' AND tags && $2::varchar[])
+                    OR (tags IS NULL OR tags = '{{}}')
+                  )
+                """,
+                bank_id,
+                consolidated_tags,
+            )
+        else:
+            # Untagged memories were consolidated - only refresh untagged mental models
+            # SECURITY: Tagged mental models are NOT refreshed when untagged memories are consolidated
+            rows = await conn.fetch(
+                f"""
+                SELECT id, name, tags
+                FROM {fq_table("mental_models")}
+                WHERE bank_id = $1
+                  AND (trigger->>'refresh_after_consolidation')::boolean = true
+                  AND (tags IS NULL OR tags = '{{}}')
+                """,
+                bank_id,
+            )

    if not rows:
        return 0

    if perf:
-        perf.log(f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true")
+        if consolidated_tags:
+            perf.log(
+                f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true "
+                f"(filtered by tags: {consolidated_tags})"
+            )
+        else:
+            perf.log(f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true")

    # Submit refresh tasks for each mental model
    refreshed_count = 0
@@ -356,7 +430,8 @@ async def _process_memory(
    memory_id = memory["id"]
    fact_tags = memory.get("tags") or []

-    # Find related observations using the full recall system (NO tag filtering)
+    # Find related observations using the full recall system
+    # SECURITY: Pass tags to ensure observations don't leak across security boundaries
    t0 = time.time()
    related_observations = await _find_related_observations(
        conn=conn,
@@ -364,6 +439,7 @@ async def _process_memory(
        bank_id=bank_id,
        query=fact_text,
        request_context=request_context,
+        tags=fact_tags,  # Pass source memory's tags for security
    )
    if perf:
        perf.record_timing("recall", time.time() - t0)
@@ -637,74 +713,120 @@ async def _find_related_observations(
    bank_id: str,
    query: str,
    request_context: "RequestContext",
+    tags: list[str] | None = None,
 ) -> list[dict[str, Any]]:
    """
-    Find observations related to the given query using the full recall system.
+    Find observations related to the given query using optimized recall.

-    IMPORTANT: We do NOT filter by tags here. Consolidation needs to see ALL
-    potentially related observations regardless of scope, so the LLM can
-    decide on tag routing (same scope update vs cross-scope create).
+    SECURITY: Filters by tags using all_strict matching to prevent cross-tenant/cross-user
+    information leakage. Observations are only consolidated within the same tag scope.

-    This leverages:
-    - Semantic search (embedding similarity)
-    - BM25 text search (keyword matching)
-    - Entity-based retrieval (shared entities)
-    - Graph traversal (connected via entity links)
+    Uses max_tokens to naturally limit observations (no artificial count limit).
+    Includes source memories with dates for LLM context.
+
+    Args:
+        tags: Optional tags to filter observations (uses all_strict matching for security)

    Returns:
-        List of related observations with their tags for LLM tag routing
+        List of related observations with their tags, source memories, and dates
    """
-    # Use recall to find related observations
-    # NO tags parameter - we want ALL observations regardless of scope
-    # Use low max_tokens since we only need observations, not memories
+    # Use recall to find related observations with token budget
+    # max_tokens naturally limits how many observations are returned
+    from ...config import get_config
+
+    config = get_config()
+
+    # SECURITY: Use all_strict matching if tags provided to prevent cross-scope consolidation
+    tags_match = "all_strict" if tags else "any"
+
    recall_result = await memory_engine.recall_async(
        bank_id=bank_id,
        query=query,
-        max_tokens=5000,  # Token budget for observations
+        max_tokens=config.consolidation_max_tokens,  # Token budget for observations (configurable)
        fact_type=["observation"],  # Only retrieve observations
        request_context=request_context,
+        tags=tags,  # Filter by source memory's tags
+        tags_match=tags_match,  # Use strict matching for security
        _quiet=True,  # Suppress logging
-        # NO tags parameter - intentionally get ALL observations
    )

    # If no observations returned, return empty list
-    # When fact_type=["observation"], results come back in `results` field
    if not recall_result.results:
        return []

-    # Trust recall's relevance filtering - fetch full data for each observation
+    # Batch fetch all observations in a single query (no artificial limit)
+    observation_ids = [uuid.UUID(obs.id) for obs in recall_result.results]
+
+    rows = await conn.fetch(
+        f"""
+        SELECT id, text, proof_count, history, tags, source_memory_ids, created_at, updated_at,
+               occurred_start, occurred_end, mentioned_at
+        FROM {fq_table("memory_units")}
+        WHERE id = ANY($1) AND bank_id = $2 AND fact_type = 'observation'
+        """,
+        observation_ids,
+        bank_id,
+    )
+
+    # Build results list preserving recall order
+    id_to_row = {row["id"]: row for row in rows}
    results = []
+
    for obs in recall_result.results:
-        # Fetch full observation data from DB to get history, source_memory_ids, tags
-        row = await conn.fetchrow(
-            f"""
-            SELECT id, text, proof_count, history, tags, source_memory_ids, created_at, updated_at
-            FROM {fq_table("memory_units")}
-            WHERE id = $1 AND bank_id = $2 AND fact_type = 'observation'
-            """,
-            uuid.UUID(obs.id),
-            bank_id,
-        )
+        obs_id = uuid.UUID(obs.id)
+        if obs_id not in id_to_row:
+            continue

-        if row:
-            history = row["history"]
-            if isinstance(history, str):
-                history = json.loads(history)
-            elif history is None:
-                history = []
+        row = id_to_row[obs_id]
+        history = row["history"]
+        if isinstance(history, str):
+            history = json.loads(history)
+        elif history is None:
+            history = []

-            results.append(
-                {
-                    "id": row["id"],
-                    "text": row["text"],
-                    "proof_count": row["proof_count"] or 1,
-                    "history": history,
-                    "tags": row["tags"] or [],  # Include tags for LLM tag routing
-                    "source_memory_ids": row["source_memory_ids"] or [],
-                    "similarity": 1.0,  # Retrieved via recall so assumed relevant
-                }
+        # Fetch source memories to include their text and dates
+        source_memory_ids = row["source_memory_ids"] or []
+        source_memories = []
+
+        if source_memory_ids:
+            source_rows = await conn.fetch(
+                f"""
+                SELECT text, occurred_start, occurred_end, mentioned_at, event_date
+                FROM {fq_table("memory_units")}
+                WHERE id = ANY($1) AND bank_id = $2
+                ORDER BY created_at ASC
+                LIMIT 5
+                """,
+                source_memory_ids[:5],  # Limit to first 5 source memories for token efficiency
+                bank_id,
            )

+            for src_row in source_rows:
+                source_memories.append(
+                    {
+                        "text": src_row["text"],
+                        "occurred_start": src_row["occurred_start"],
+                        "occurred_end": src_row["occurred_end"],
+                        "mentioned_at": src_row["mentioned_at"],
+                        "event_date": src_row["event_date"],
+                    }
+                )
+
+        results.append(
+            {
+                "id": row["id"],
+                "text": row["text"],
+                "proof_count": row["proof_count"] or 1,
+                "tags": row["tags"] or [],
+                "source_memories": source_memories,
+                "occurred_start": row["occurred_start"],
+                "occurred_end": row["occurred_end"],
+                "mentioned_at": row["mentioned_at"],
+                "created_at": row["created_at"],
+                "updated_at": row["updated_at"],
+            }
+        )
+
    return results


@@ -732,14 +854,43 @@ async def _consolidate_with_llm(
        - {"action": "create", "text": "...", "reason": "..."}
        - [] if fact is purely ephemeral (no durable knowledge)
    """
-    # Format observations WITH their tags (or "None" if empty)
+    # Format observations as JSON with source memories and dates
    if observations:
-        observations_text = "\n".join(
-            f'- ID: {obs["id"]}, Tags: {json.dumps(obs["tags"])}, Text: "{obs["text"]}" (proof_count: {obs["proof_count"]})'
-            for obs in observations
-        )
+        obs_list = []
+        for obs in observations:
+            obs_data = {
+                "id": str(obs["id"]),
+                "text": obs["text"],
+                "proof_count": obs["proof_count"],
+                "tags": obs["tags"],
+                "created_at": obs["created_at"].isoformat() if obs.get("created_at") else None,
+                "updated_at": obs["updated_at"].isoformat() if obs.get("updated_at") else None,
+            }
+
+            # Include temporal info if available
+            if obs.get("occurred_start"):
+                obs_data["occurred_start"] = obs["occurred_start"].isoformat()
+            if obs.get("occurred_end"):
+                obs_data["occurred_end"] = obs["occurred_end"].isoformat()
+            if obs.get("mentioned_at"):
+                obs_data["mentioned_at"] = obs["mentioned_at"].isoformat()
+
+            # Include source memories (up to 3 for brevity)
+            if obs.get("source_memories"):
+                obs_data["source_memories"] = [
+                    {
+                        "text": sm["text"],
+                        "event_date": sm["event_date"].isoformat() if sm.get("event_date") else None,
+                        "occurred_start": sm["occurred_start"].isoformat() if sm.get("occurred_start") else None,
+                    }
+                    for sm in obs["source_memories"][:3]  # Limit to 3 for token efficiency
+                ]
+
+            obs_list.append(obs_data)
+
+        observations_text = json.dumps(obs_list, indent=2)
    else:
-        observations_text = "None (this is a new topic - create if fact contains durable knowledge)"
+        observations_text = "[]"

    # Only include mission section if mission is set and not the default
    mission_section = ""
@@ -769,7 +920,14 @@ Focus on DURABLE knowledge that serves this mission, not ephemeral state.
        )
        # Parse JSON response - should be an array
        if isinstance(result, str):
-            result = json.loads(result)
+            # Strip markdown code fences (some models wrap JSON in ```json ... ```)
+            clean = result.strip()
+            if clean.startswith("```"):
+                clean = clean.split("\n", 1)[1] if "\n" in clean else clean[3:]
+                if clean.endswith("```"):
+                    clean = clean[:-3]
+                clean = clean.strip()
+            result = json.loads(clean)
        # Ensure result is a list
        if isinstance(result, list):
            return result
@@ -2,7 +2,7 @@

 CONSOLIDATION_SYSTEM_PROMPT = """You are a memory consolidation system. Your job is to convert facts into durable knowledge (observations) and merge with existing knowledge when appropriate.

-You must output ONLY valid JSON with no markdown formatting, no code blocks, and no additional text.
+You must output ONLY valid JSON with no markdown code blocks or additional text. However, the "text" field within each observation should use markdown formatting (headers, lists, bold, etc.) for clarity and readability.

 ## EXTRACT DURABLE KNOWLEDGE, NOT EPHEMERAL STATE
 Facts often describe events or actions. Extract the DURABLE KNOWLEDGE implied by the fact, not the transient state.
@@ -32,13 +32,16 @@ BAD examples:

 ## MERGE RULES (when comparing to existing observations):
 1. REDUNDANT: Same information worded differently → update existing
-2. CONTRADICTION: Opposite information about same topic → update with history (e.g., "used to X, now Y")
-3. UPDATE: New state replacing old state → update with history
+2. CONTRADICTION: Opposite information about same topic → update with temporal markers showing change
+   Example: "Alex used to love pizza but now hates it" OR "Alex's pizza preference changed from love to hate"
+3. UPDATE: New state replacing old state → update showing the transition with "used to", "now", "changed from X to Y"

 ## CRITICAL RULES:
 - NEVER merge facts about DIFFERENT people
 - NEVER merge unrelated topics (food preferences vs work vs hobbies)
- When merging contradictions, capture the CHANGE (before → after)
+- When merging contradictions, the "text" field MUST capture BOTH states with temporal markers:
+  * Use "used to X, now Y" OR "changed from X to Y" OR "X but now Y"
+  * DO NOT just state the new fact - you MUST show the change
 - Keep observations focused on ONE specific topic per person
 - The "text" field MUST contain durable knowledge, not ephemeral state
 - Do NOT include "tags" in output - tags are handled automatically"""
@@ -47,23 +50,36 @@ CONSOLIDATION_USER_PROMPT = """Analyze this new fact and consolidate into knowle
 {mission_section}
 NEW FACT: {fact_text}

-EXISTING OBSERVATIONS:
+EXISTING OBSERVATIONS (JSON array with source memories and dates):
 {observations_text}

-Instructions:
-1. First, extract the DURABLE KNOWLEDGE from the fact (not ephemeral state like "user is at X")
-2. Then compare with existing observations:
-   - If an observation covers the same topic: UPDATE it with the new knowledge
-   - If no observation covers the topic: CREATE a new one
+Each observation includes:
+- id: unique identifier for updating
+- text: the observation content
+- proof_count: number of supporting memories
+- tags: visibility scope (handled automatically)
+- created_at/updated_at: when observation was created/modified
+- occurred_start/occurred_end: temporal range of source facts
+- source_memories: array of supporting facts with their text and dates

-Output JSON array of actions (ALWAYS an array, even for single action):
+Instructions:
+1. Extract DURABLE KNOWLEDGE from the new fact (not ephemeral state)
+2. Review source_memories in existing observations to understand evidence
+3. Check dates to detect contradictions or updates
+4. Compare with observations:
+   - Same topic → UPDATE with learning_id
+   - New topic → CREATE new observation
+   - Purely ephemeral → return []
+
+Output JSON array of actions (the "text" field should use markdown formatting for structure):
 [
-  {{"action": "update", "learning_id": "uuid", "text": "updated durable knowledge", "reason": "..."}},
-  {{"action": "create", "text": "new durable knowledge", "reason": "..."}}
+  {{"action": "update", "learning_id": "uuid-from-observations", "text": "## Updated Knowledge\n\n**Key point**: details here\n\n- Supporting detail 1\n- Supporting detail 2", "reason": "..."}},
+  {{"action": "create", "text": "## New Durable Knowledge\n\nDescription with **emphasis** and proper structure", "reason": "..."}}
 ]

-If NO consolidation is needed (fact is purely ephemeral with no durable knowledge):
-[]
+Return [] if fact contains no durable knowledge.

-If no observations exist and fact contains durable knowledge:
-[{{"action": "create", "text": "durable knowledge text", "reason": "new topic"}}]"""
+IMPORTANT: Format the "text" field with markdown for better readability:
+- Use headers, lists, bold/italic, tables where appropriate
+- CRITICAL: Add blank lines before and after block elements (tables, code blocks, lists)
+- Ensure proper spacing for markdown to render correctly"""
@@ -9,6 +9,7 @@ Configuration via environment variables - see hindsight_api.config for all env v
 import asyncio
 import logging
 import os
+import warnings
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor

@@ -20,6 +21,7 @@ from ..config import (
    DEFAULT_RERANKER_FLASHRANK_CACHE_DIR,
    DEFAULT_RERANKER_FLASHRANK_MODEL,
    DEFAULT_RERANKER_LITELLM_MODEL,
+    DEFAULT_RERANKER_LOCAL_FORCE_CPU,
    DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT,
    DEFAULT_RERANKER_LOCAL_MODEL,
    DEFAULT_RERANKER_PROVIDER,
@@ -33,6 +35,7 @@ from ..config import (
    ENV_RERANKER_FLASHRANK_CACHE_DIR,
    ENV_RERANKER_FLASHRANK_MODEL,
    ENV_RERANKER_LITELLM_MODEL,
+    ENV_RERANKER_LOCAL_FORCE_CPU,
    ENV_RERANKER_LOCAL_MAX_CONCURRENT,
    ENV_RERANKER_LOCAL_MODEL,
    ENV_RERANKER_PROVIDER,
@@ -99,7 +102,7 @@ class LocalSTCrossEncoder(CrossEncoderModel):
    _executor: ThreadPoolExecutor | None = None
    _max_concurrent: int = 4  # Limit concurrent CPU-bound reranking calls

-    def __init__(self, model_name: str | None = None, max_concurrent: int = 4):
+    def __init__(self, model_name: str | None = None, max_concurrent: int = 4, force_cpu: bool = False):
        """
        Initialize local SentenceTransformers cross-encoder.

@@ -108,8 +111,11 @@ class LocalSTCrossEncoder(CrossEncoderModel):
                       Default: cross-encoder/ms-marco-MiniLM-L-6-v2
            max_concurrent: Maximum concurrent reranking calls (default: 2).
                           Higher values may cause CPU thrashing under load.
+            force_cpu: Force CPU mode (avoids MPS/XPC issues on macOS in daemon mode).
+                      Default: False
        """
        self.model_name = model_name or DEFAULT_RERANKER_LOCAL_MODEL
+        self.force_cpu = force_cpu
        self._model = None
        LocalSTCrossEncoder._max_concurrent = max_concurrent

@@ -139,19 +145,46 @@ class LocalSTCrossEncoder(CrossEncoderModel):
        # after loading, which conflicts with accelerate's device_map handling.
        import torch

-        # Check for GPU (CUDA) or Apple Silicon (MPS)
-        has_gpu = torch.cuda.is_available() or (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
-
-        if has_gpu:
-            device = None  # Let sentence-transformers auto-detect GPU/MPS
-        else:
+        # Force CPU mode if configured (used in daemon mode to avoid MPS/XPC issues on macOS)
+        if self.force_cpu:
            device = "cpu"
+            logger.info("Reranker: forcing CPU mode (HINDSIGHT_API_RERANKER_LOCAL_FORCE_CPU=1)")
+        else:
+            # Check for GPU (CUDA) or Apple Silicon (MPS)
+            # Wrap in try-except to gracefully handle any device detection issues
+            # (e.g., in CI environments or when PyTorch is built without GPU support)
+            device = "cpu"  # Default to CPU
+            try:
+                has_gpu = torch.cuda.is_available() or (
+                    hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+                )
+                if has_gpu:
+                    device = None  # Let sentence-transformers auto-detect GPU/MPS
+            except Exception as e:
+                logger.warning(f"Failed to detect GPU/MPS, falling back to CPU: {e}")

-        self._model = CrossEncoder(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
+        # Suppress verbose transformers warnings during model loading
+        # This suppresses the "UNEXPECTED" warnings from CrossEncoder which are harmless
+        # but look alarming to users (e.g., "embeddings.position_ids | UNEXPECTED")
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*was not found in model state dict.*")
+            warnings.filterwarnings("ignore", message=".*UNEXPECTED.*")
+
+            # Also suppress transformers library logging temporarily
+            transformers_logger = logging.getLogger("transformers")
+            original_level = transformers_logger.level
+            transformers_logger.setLevel(logging.ERROR)
+
+            try:
+                self._model = CrossEncoder(
+                    self.model_name,
+                    device=device,
+                    model_kwargs={"low_cpu_mem_usage": False},
+                )
+            finally:
+                # Restore original logging level
+                transformers_logger.setLevel(original_level)

        # Initialize shared executor (limited workers naturally limits concurrency)
        if LocalSTCrossEncoder._executor is None:
@@ -163,101 +196,16 @@ class LocalSTCrossEncoder(CrossEncoderModel):
        else:
            logger.info("Reranker: local provider initialized (using existing executor)")

-    def _is_xpc_error(self, error: Exception) -> bool:
-        """
-        Check if an error is an XPC connection error (macOS daemon issue).
-
-        On macOS, long-running daemons can lose XPC connections to system services
-        when the process is idle for extended periods.
-        """
-        error_str = str(error).lower()
-        return "xpc_error_connection_invalid" in error_str or "xpc error" in error_str
-
-    def _reinitialize_model_sync(self) -> None:
-        """
-        Clear and reinitialize the cross-encoder model synchronously.
-
-        This is used to recover from XPC errors on macOS where the
-        PyTorch/MPS backend loses its connection to system services.
-        """
-        logger.warning(f"Reinitializing reranker model {self.model_name} due to backend error")
-
-        # Clear existing model
-        self._model = None
-
-        # Force garbage collection to free resources
-        import gc
-
-        import torch
-
-        gc.collect()
-
-        # If using CUDA/MPS, clear the cache
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-            try:
-                torch.mps.empty_cache()
-            except AttributeError:
-                pass  # Method might not exist in all PyTorch versions
-
-        # Reinitialize the model
-        try:
-            from sentence_transformers import CrossEncoder
-        except ImportError:
-            raise ImportError(
-                "sentence-transformers is required for LocalSTCrossEncoder. "
-                "Install it with: pip install sentence-transformers"
-            )
-
-        # Determine device based on hardware availability
-        has_gpu = torch.cuda.is_available() or (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
-
-        if has_gpu:
-            device = None  # Let sentence-transformers auto-detect GPU/MPS
-        else:
-            device = "cpu"
-
-        self._model = CrossEncoder(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
-
-        logger.info("Reranker: local provider reinitialized successfully")
-
-    def _predict_with_recovery(self, pairs: list[tuple[str, str]]) -> list[float]:
-        """
-        Predict with automatic recovery from XPC errors.
-
-        This runs synchronously in the thread pool.
-        """
-        max_retries = 1
-        for attempt in range(max_retries + 1):
-            try:
-                scores = self._model.predict(pairs, show_progress_bar=False)
-                return scores.tolist() if hasattr(scores, "tolist") else list(scores)
-            except Exception as e:
-                # Check if this is an XPC error (macOS daemon issue)
-                if self._is_xpc_error(e) and attempt < max_retries:
-                    logger.warning(f"XPC error detected in reranker (attempt {attempt + 1}): {e}")
-                    try:
-                        self._reinitialize_model_sync()
-                        logger.info("Reranker reinitialized successfully, retrying prediction")
-                        continue
-                    except Exception as reinit_error:
-                        logger.error(f"Failed to reinitialize reranker: {reinit_error}")
-                        raise Exception(f"Failed to recover from XPC error: {str(e)}")
-                else:
-                    # Not an XPC error or out of retries
-                    raise
+    def _predict_sync(self, pairs: list[tuple[str, str]]) -> list[float]:
+        """Synchronous prediction wrapper for thread pool execution."""
+        scores = self._model.predict(pairs, show_progress_bar=False)
+        return scores.tolist() if hasattr(scores, "tolist") else list(scores)

    async def predict(self, pairs: list[tuple[str, str]]) -> list[float]:
        """
        Score query-document pairs for relevance.

        Uses a dedicated thread pool with limited workers to prevent CPU thrashing.
-        Automatically recovers from XPC errors on macOS by reinitializing the model.

        Args:
            pairs: List of (query, document) tuples to score
@@ -272,7 +220,7 @@ class LocalSTCrossEncoder(CrossEncoderModel):
        loop = asyncio.get_event_loop()
        return await loop.run_in_executor(
            LocalSTCrossEncoder._executor,
-            self._predict_with_recovery,
+            self._predict_sync,
            pairs,
        )

@@ -684,7 +632,7 @@ class FlashRankCrossEncoder(CrossEncoderModel):
            return

        try:
-            from flashrank import Ranker  # type: ignore[import-untyped]
+            from flashrank import Ranker
        except ImportError:
            raise ImportError("flashrank is required for FlashRankCrossEncoder. Install it with: pip install flashrank")

@@ -711,7 +659,7 @@ class FlashRankCrossEncoder(CrossEncoderModel):

    def _predict_sync(self, pairs: list[tuple[str, str]]) -> list[float]:
        """Synchronous predict - processes each query group."""
-        from flashrank import RerankRequest  # type: ignore[import-untyped]
+        from flashrank import RerankRequest

        if not pairs:
            return []
@@ -873,29 +821,33 @@ class LiteLLMCrossEncoder(CrossEncoderModel):

 def create_cross_encoder_from_env() -> CrossEncoderModel:
    """
-    Create a CrossEncoderModel instance based on environment variables.
+    Create a CrossEncoderModel instance based on configuration.

-    See hindsight_api.config for environment variable names and defaults.
+    Reads configuration via get_config() to ensure consistency across the codebase.

    Returns:
        Configured CrossEncoderModel instance
    """
-    provider = os.environ.get(ENV_RERANKER_PROVIDER, DEFAULT_RERANKER_PROVIDER).lower()
+    from ..config import get_config
+
+    config = get_config()
+    provider = config.reranker_provider.lower()

    if provider == "tei":
-        url = os.environ.get(ENV_RERANKER_TEI_URL)
+        url = config.reranker_tei_url
        if not url:
            raise ValueError(f"{ENV_RERANKER_TEI_URL} is required when {ENV_RERANKER_PROVIDER} is 'tei'")
-        batch_size = int(os.environ.get(ENV_RERANKER_TEI_BATCH_SIZE, str(DEFAULT_RERANKER_TEI_BATCH_SIZE)))
-        max_concurrent = int(os.environ.get(ENV_RERANKER_TEI_MAX_CONCURRENT, str(DEFAULT_RERANKER_TEI_MAX_CONCURRENT)))
-        return RemoteTEICrossEncoder(base_url=url, batch_size=batch_size, max_concurrent=max_concurrent)
+        return RemoteTEICrossEncoder(
+            base_url=url,
+            batch_size=config.reranker_tei_batch_size,
+            max_concurrent=config.reranker_tei_max_concurrent,
+        )
    elif provider == "local":
-        model = os.environ.get(ENV_RERANKER_LOCAL_MODEL)
-        model_name = model or DEFAULT_RERANKER_LOCAL_MODEL
-        max_concurrent = int(
-            os.environ.get(ENV_RERANKER_LOCAL_MAX_CONCURRENT, str(DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT))
+        return LocalSTCrossEncoder(
+            model_name=config.reranker_local_model,
+            max_concurrent=config.reranker_local_max_concurrent,
+            force_cpu=config.reranker_local_force_cpu,
        )
-        return LocalSTCrossEncoder(model_name=model_name, max_concurrent=max_concurrent)
    elif provider == "cohere":
        api_key = os.environ.get(ENV_COHERE_API_KEY)
        if not api_key:
@@ -11,6 +11,7 @@ Configuration via environment variables - see hindsight_api.config for all env v

 import logging
 import os
+import warnings
 from abc import ABC, abstractmethod

 import httpx
@@ -18,6 +19,7 @@ import httpx
 from ..config import (
    DEFAULT_EMBEDDINGS_COHERE_MODEL,
    DEFAULT_EMBEDDINGS_LITELLM_MODEL,
+    DEFAULT_EMBEDDINGS_LOCAL_FORCE_CPU,
    DEFAULT_EMBEDDINGS_LOCAL_MODEL,
    DEFAULT_EMBEDDINGS_OPENAI_MODEL,
    DEFAULT_EMBEDDINGS_PROVIDER,
@@ -26,6 +28,7 @@ from ..config import (
    ENV_EMBEDDINGS_COHERE_BASE_URL,
    ENV_EMBEDDINGS_COHERE_MODEL,
    ENV_EMBEDDINGS_LITELLM_MODEL,
+    ENV_EMBEDDINGS_LOCAL_FORCE_CPU,
    ENV_EMBEDDINGS_LOCAL_MODEL,
    ENV_EMBEDDINGS_OPENAI_API_KEY,
    ENV_EMBEDDINGS_OPENAI_BASE_URL,
@@ -92,15 +95,18 @@ class LocalSTEmbeddings(Embeddings):
    The embedding dimension is auto-detected from the model.
    """

-    def __init__(self, model_name: str | None = None):
+    def __init__(self, model_name: str | None = None, force_cpu: bool = False):
        """
        Initialize local SentenceTransformers embeddings.

        Args:
            model_name: Name of the SentenceTransformer model to use.
                       Default: BAAI/bge-small-en-v1.5
+            force_cpu: Force CPU mode (avoids MPS/XPC issues on macOS in daemon mode).
+                      Default: False
        """
        self.model_name = model_name or DEFAULT_EMBEDDINGS_LOCAL_MODEL
+        self.force_cpu = force_cpu
        self._model = None
        self._dimension: int | None = None

@@ -134,92 +140,54 @@ class LocalSTEmbeddings(Embeddings):
        # which can cause issues when accelerate is installed but no GPU is available.
        import torch

-        # Check for GPU (CUDA) or Apple Silicon (MPS)
-        has_gpu = torch.cuda.is_available() or (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
-
-        if has_gpu:
-            device = None  # Let sentence-transformers auto-detect GPU/MPS
-        else:
+        # Force CPU mode if configured (used in daemon mode to avoid MPS/XPC issues on macOS)
+        if self.force_cpu:
            device = "cpu"
+            logger.info("Embeddings: forcing CPU mode")
+        else:
+            # Check for GPU (CUDA) or Apple Silicon (MPS)
+            # Wrap in try-except to gracefully handle any device detection issues
+            # (e.g., in CI environments or when PyTorch is built without GPU support)
+            device = "cpu"  # Default to CPU
+            try:
+                has_gpu = torch.cuda.is_available() or (
+                    hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+                )
+                if has_gpu:
+                    device = None  # Let sentence-transformers auto-detect GPU/MPS
+            except Exception as e:
+                logger.warning(f"Failed to detect GPU/MPS, falling back to CPU: {e}")

-        self._model = SentenceTransformer(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
+        # Suppress verbose transformers warnings during model loading
+        # This suppresses the "UNEXPECTED" warnings from BertModel which are harmless
+        # but look alarming to users (e.g., "embeddings.position_ids | UNEXPECTED")
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*was not found in model state dict.*")
+            warnings.filterwarnings("ignore", message=".*UNEXPECTED.*")
+
+            # Also suppress transformers library logging temporarily
+            transformers_logger = logging.getLogger("transformers")
+            original_level = transformers_logger.level
+            transformers_logger.setLevel(logging.ERROR)
+
+            try:
+                self._model = SentenceTransformer(
+                    self.model_name,
+                    device=device,
+                    model_kwargs={"low_cpu_mem_usage": False},
+                )
+            finally:
+                # Restore original logging level
+                transformers_logger.setLevel(original_level)

        self._dimension = self._model.get_sentence_embedding_dimension()
        logger.info(f"Embeddings: local provider initialized (dim: {self._dimension})")

-    def _is_xpc_error(self, error: Exception) -> bool:
-        """
-        Check if an error is an XPC connection error (macOS daemon issue).
-
-        On macOS, long-running daemons can lose XPC connections to system services
-        when the process is idle for extended periods.
-        """
-        error_str = str(error).lower()
-        return "xpc_error_connection_invalid" in error_str or "xpc error" in error_str
-
-    def _reinitialize_model_sync(self) -> None:
-        """
-        Clear and reinitialize the embedding model synchronously.
-
-        This is used to recover from XPC errors on macOS where the
-        PyTorch/MPS backend loses its connection to system services.
-        """
-        logger.warning(f"Reinitializing embedding model {self.model_name} due to backend error")
-
-        # Clear existing model
-        self._model = None
-
-        # Force garbage collection to free resources
-        import gc
-
-        import torch
-
-        gc.collect()
-
-        # If using CUDA/MPS, clear the cache
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-            try:
-                torch.mps.empty_cache()
-            except AttributeError:
-                pass  # Method might not exist in all PyTorch versions
-
-        # Reinitialize the model (inline version of initialize() but synchronous)
-        try:
-            from sentence_transformers import SentenceTransformer
-        except ImportError:
-            raise ImportError(
-                "sentence-transformers is required for LocalSTEmbeddings. "
-                "Install it with: pip install sentence-transformers"
-            )
-
-        # Determine device based on hardware availability
-        has_gpu = torch.cuda.is_available() or (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
-
-        if has_gpu:
-            device = None  # Let sentence-transformers auto-detect GPU/MPS
-        else:
-            device = "cpu"
-
-        self._model = SentenceTransformer(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
-
-        logger.info("Embeddings: local provider reinitialized successfully")
-
    def encode(self, texts: list[str]) -> list[list[float]]:
        """
        Generate embeddings for a list of texts.

-        Automatically recovers from XPC errors on macOS by reinitializing the model.
-
        Args:
            texts: List of text strings to encode

@@ -229,26 +197,8 @@ class LocalSTEmbeddings(Embeddings):
        if self._model is None:
            raise RuntimeError("Embeddings not initialized. Call initialize() first.")

-        # Try encoding with automatic recovery from XPC errors
-        max_retries = 1
-        for attempt in range(max_retries + 1):
-            try:
-                embeddings = self._model.encode(texts, convert_to_numpy=True, show_progress_bar=False)
-                return [emb.tolist() for emb in embeddings]
-            except Exception as e:
-                # Check if this is an XPC error (macOS daemon issue)
-                if self._is_xpc_error(e) and attempt < max_retries:
-                    logger.warning(f"XPC error detected in embedding generation (attempt {attempt + 1}): {e}")
-                    try:
-                        self._reinitialize_model_sync()
-                        logger.info("Model reinitialized successfully, retrying embedding generation")
-                        continue
-                    except Exception as reinit_error:
-                        logger.error(f"Failed to reinitialize model: {reinit_error}")
-                        raise Exception(f"Failed to recover from XPC error: {str(e)}")
-                else:
-                    # Not an XPC error or out of retries
-                    raise
+        embeddings = self._model.encode(texts, convert_to_numpy=True, show_progress_bar=False)
+        return [emb.tolist() for emb in embeddings]


 class RemoteTEIEmbeddings(Embeddings):
@@ -613,7 +563,7 @@ class CohereEmbeddings(Embeddings):
                model=self.model,
                input_type=self.input_type,
            )
-            if response.embeddings:
+            if response.embeddings and isinstance(response.embeddings, list):
                self._dimension = len(response.embeddings[0])

        logger.info(f"Embeddings: Cohere provider initialized (model: {self.model}, dim: {self._dimension})")
@@ -770,24 +720,28 @@ class LiteLLMEmbeddings(Embeddings):

 def create_embeddings_from_env() -> Embeddings:
    """
-    Create an Embeddings instance based on environment variables.
+    Create an Embeddings instance based on configuration.

-    See hindsight_api.config for environment variable names and defaults.
+    Reads configuration via get_config() to ensure consistency across the codebase.

    Returns:
        Configured Embeddings instance
    """
-    provider = os.environ.get(ENV_EMBEDDINGS_PROVIDER, DEFAULT_EMBEDDINGS_PROVIDER).lower()
+    from ..config import get_config
+
+    config = get_config()
+    provider = config.embeddings_provider.lower()

    if provider == "tei":
-        url = os.environ.get(ENV_EMBEDDINGS_TEI_URL)
+        url = config.embeddings_tei_url
        if not url:
            raise ValueError(f"{ENV_EMBEDDINGS_TEI_URL} is required when {ENV_EMBEDDINGS_PROVIDER} is 'tei'")
        return RemoteTEIEmbeddings(base_url=url)
    elif provider == "local":
-        model = os.environ.get(ENV_EMBEDDINGS_LOCAL_MODEL)
-        model_name = model or DEFAULT_EMBEDDINGS_LOCAL_MODEL
-        return LocalSTEmbeddings(model_name=model_name)
+        return LocalSTEmbeddings(
+            model_name=config.embeddings_local_model,
+            force_cpu=config.embeddings_local_force_cpu,
+        )
    elif provider == "openai":
        # Use dedicated embeddings API key, or fall back to LLM API key
        api_key = os.environ.get(ENV_EMBEDDINGS_OPENAI_API_KEY) or os.environ.get(ENV_LLM_API_KEY)
@@ -442,49 +442,6 @@ class MemoryEngineInterface(ABC):
        """
        ...

-    @abstractmethod
-    async def get_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        *,
-        limit: int = 10,
-        request_context: "RequestContext",
-    ) -> list[Any]:
-        """
-        Get observations for an entity.
-
-        Args:
-            bank_id: The memory bank ID.
-            entity_id: The entity ID.
-            limit: Maximum observations.
-            request_context: Request context for authentication.
-
-        Returns:
-            List of EntityObservation objects.
-        """
-        ...
-
-    @abstractmethod
-    async def regenerate_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        entity_name: str,
-        *,
-        request_context: "RequestContext",
-    ) -> None:
-        """
-        Regenerate observations for an entity.
-
-        Args:
-            bank_id: The memory bank ID.
-            entity_id: The entity ID.
-            entity_name: The entity's canonical name.
-            request_context: Request context for authentication.
-        """
-        ...
-
    # =========================================================================
    # Statistics & Operations
    # =========================================================================
@@ -0,0 +1,146 @@
+"""
+Abstract interface for LLM providers.
+
+This module defines the interface that all LLM providers must implement,
+enabling support for multiple LLM backends (OpenAI, Anthropic, Gemini, Codex, etc.)
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from .response_models import LLMToolCallResult, TokenUsage
+
+
+class LLMInterface(ABC):
+    """
+    Abstract interface for LLM providers.
+
+    All LLM provider implementations must inherit from this class and implement
+    the required methods.
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        **kwargs: Any,
+    ):
+        """
+        Initialize LLM provider.
+
+        Args:
+            provider: Provider name (e.g., "openai", "codex", "anthropic", "gemini").
+            api_key: API key or authentication token.
+            base_url: Base URL for the API.
+            model: Model name.
+            reasoning_effort: Reasoning effort level for supported providers.
+            **kwargs: Additional provider-specific parameters.
+        """
+        self.provider = provider.lower()
+        self.api_key = api_key
+        self.base_url = base_url
+        self.model = model
+        self.reasoning_effort = reasoning_effort
+
+    @abstractmethod
+    async def verify_connection(self) -> None:
+        """
+        Verify that the LLM provider is configured correctly by making a simple test call.
+
+        Raises:
+            RuntimeError: If the connection test fails.
+        """
+        pass
+
+    @abstractmethod
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make an LLM API call with retry logic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Use strict JSON schema enforcement (OpenAI only).
+            return_usage: If True, return tuple (result, TokenUsage) instead of just result.
+
+        Returns:
+            If return_usage=False: Parsed response if response_format is provided, otherwise text content.
+            If return_usage=True: Tuple of (result, TokenUsage) with token counts.
+
+        Raises:
+            OutputTooLongError: If output exceeds token limits.
+            Exception: Re-raises API errors after retries exhausted.
+        """
+        pass
+
+    @abstractmethod
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make an LLM API call with tool/function calling support.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        pass
+
+    @abstractmethod
+    async def cleanup(self) -> None:
+        """Clean up resources (close connections, etc.)."""
+        pass
+
+
+class OutputTooLongError(Exception):
+    """
+    Bridge exception raised when LLM output exceeds token limits.
+
+    This wraps provider-specific errors (e.g., OpenAI's LengthFinishReasonError)
+    to allow callers to handle output length issues without depending on
+    provider-specific implementations.
+    """
+
+    pass
@@ -20,15 +20,21 @@ from typing import TYPE_CHECKING, Any

 from ..config import get_config
 from ..metrics import get_metrics_collector
+from ..utils import mask_network_location
 from .db_budget import budgeted_operation

 # Context variable for current schema (async-safe, per-task isolation)
-_current_schema: contextvars.ContextVar[str] = contextvars.ContextVar("current_schema", default="public")
+# Note: default is None, actual default comes from config via get_current_schema()
+_current_schema: contextvars.ContextVar[str | None] = contextvars.ContextVar("current_schema", default=None)


 def get_current_schema() -> str:
-    """Get the current schema from context (default: 'public')."""
-    return _current_schema.get()
+    """Get the current schema from context (falls back to config default)."""
+    schema = _current_schema.get()
+    if schema is None:
+        # Fall back to configured default schema
+        return get_config().database_schema
+    return schema


 def fq_table(table_name: str) -> str:
@@ -298,8 +304,10 @@ class MemoryEngine(MemoryEngineInterface):
        db_url = db_url or config.database_url
        memory_llm_provider = memory_llm_provider or config.llm_provider
        memory_llm_api_key = memory_llm_api_key or config.llm_api_key
-        # Ollama and mock don't require an API key
-        if not memory_llm_api_key and memory_llm_provider not in ("ollama", "mock"):
+        # Ollama, openai-codex, claude-code, and mock don't require an API key
+        # openai-codex uses OAuth tokens from ~/.codex/auth.json
+        # claude-code uses OAuth tokens from macOS Keychain
+        if not memory_llm_api_key and memory_llm_provider not in ("ollama", "openai-codex", "claude-code", "mock"):
            raise ValueError("LLM API key is required. Set HINDSIGHT_API_LLM_API_KEY environment variable.")
        memory_llm_model = memory_llm_model or config.llm_model
        memory_llm_base_url = memory_llm_base_url or config.get_llm_base_url() or None
@@ -452,9 +460,18 @@ class MemoryEngine(MemoryEngineInterface):
        # Store operation validator extension (optional)
        self._operation_validator = operation_validator

-        # Store tenant extension (optional)
+        # Store tenant extension (always set, use default if none provided)
+        if tenant_extension is None:
+            from ..extensions.builtin.tenant import DefaultTenantExtension
+
+            tenant_extension = DefaultTenantExtension(config={})
        self._tenant_extension = tenant_extension

+    @property
+    def tenant_extension(self) -> "TenantExtension | None":
+        """The configured tenant extension, if any."""
+        return self._tenant_extension
+
    async def _validate_operation(self, validation_coro) -> None:
        """
        Run validation if an operation validator is configured.
@@ -490,23 +507,18 @@ class MemoryEngine(MemoryEngineInterface):
        Raises:
            AuthenticationError: If authentication fails or request_context is missing when required.
        """
-        if self._tenant_extension is None:
-            _current_schema.set("public")
-            return "public"
-
        from hindsight_api.extensions import AuthenticationError

        if request_context is None:
-            raise AuthenticationError("RequestContext is required when tenant extension is configured")
+            raise AuthenticationError("RequestContext is required")

-        # For internal/background operations (e.g., worker tasks), skip extension authentication
-        # if the schema has already been set by execute_task via the _schema field.
+        # For internal/background operations (e.g., worker tasks), skip extension authentication.
+        # The task was already authenticated at submission time, and execute_task sets _current_schema
+        # from the task's _schema field.
        if request_context.internal:
-            current = _current_schema.get()
-            if current and current != "public":
-                return current
+            return _current_schema.get()

-        # Let AuthenticationError propagate - HTTP layer will convert to 401
+        # Authenticate through tenant extension (always set, may be default no-auth extension)
        tenant_context = await self._tenant_extension.authenticate(request_context)

        _current_schema.set(tenant_context.schema_name)
@@ -532,10 +544,15 @@ class MemoryEngine(MemoryEngineInterface):
            f"[BATCH_RETAIN_TASK] Starting background batch retain for bank_id={bank_id}, {len(contents)} items"
        )

-        # Use internal request context for background tasks (skips tenant auth when schema is pre-set)
+        # Restore tenant_id/api_key_id from task payload so downstream operations
+        # (e.g., consolidation and mental model refreshes) can attribute usage.
        from hindsight_api.models import RequestContext

-        internal_context = RequestContext(internal=True)
+        internal_context = RequestContext(
+            internal=True,
+            tenant_id=task_dict.get("_tenant_id"),
+            api_key_id=task_dict.get("_api_key_id"),
+        )
        await self.retain_batch_async(bank_id=bank_id, contents=contents, request_context=internal_context)

        logger.info(f"[BATCH_RETAIN_TASK] Completed background batch retain for bank_id={bank_id}")
@@ -561,7 +578,13 @@ class MemoryEngine(MemoryEngineInterface):

        from .consolidation import run_consolidation_job

-        internal_context = RequestContext(internal=True)
+        # Restore tenant_id/api_key_id from task payload so downstream operations
+        # (e.g., mental model refreshes) can attribute usage to the correct org.
+        internal_context = RequestContext(
+            internal=True,
+            tenant_id=task_dict.get("_tenant_id"),
+            api_key_id=task_dict.get("_api_key_id"),
+        )
        result = await run_consolidation_job(
            memory_engine=self,
            bank_id=bank_id,
@@ -593,7 +616,13 @@ class MemoryEngine(MemoryEngineInterface):

        from hindsight_api.models import RequestContext

-        internal_context = RequestContext(internal=True)
+        # Restore tenant_id/api_key_id from task payload so extensions can
+        # attribute the mental_model_refresh operation to the correct org.
+        internal_context = RequestContext(
+            internal=True,
+            tenant_id=task_dict.get("_tenant_id"),
+            api_key_id=task_dict.get("_api_key_id"),
+        )

        # Get the current mental model to get source_query
        mental_model = await self.get_mental_model(bank_id, mental_model_id, request_context=internal_context)
@@ -602,30 +631,53 @@ class MemoryEngine(MemoryEngineInterface):

        source_query = mental_model["source_query"]

+        # SECURITY: If the mental model has tags, pass them to reflect with "all_strict" matching
+        # to ensure it can only access other mental models/memories with the SAME tags.
+        # This prevents cross-tenant/cross-user information leakage by excluding untagged content.
+        tags = mental_model.get("tags")
+        tags_match = "all_strict" if tags else "any"
+
        # Run reflect to generate new content, excluding the mental model being refreshed
        reflect_result = await self.reflect_async(
            bank_id=bank_id,
            query=source_query,
            request_context=internal_context,
+            tags=tags,
+            tags_match=tags_match,
            exclude_mental_model_ids=[mental_model_id],
        )

        generated_content = reflect_result.text or "No content generated"

        # Build reflect_response payload to store
+        # based_on contains MemoryFact objects for most types, but plain dicts for directives
+        based_on_serialized: dict[str, list[dict[str, Any]]] = {}
+        for fact_type, facts in reflect_result.based_on.items():
+            serialized_facts = []
+            for fact in facts:
+                if isinstance(fact, dict):
+                    # Plain dict (e.g., directives with id, name, content)
+                    serialized_facts.append(
+                        {
+                            "id": str(fact["id"]),
+                            "text": fact.get("text", fact.get("content", fact.get("name", ""))),
+                            "type": fact_type,
+                        }
+                    )
+                else:
+                    # MemoryFact object with .id and .text attributes
+                    serialized_facts.append(
+                        {
+                            "id": str(fact.id),
+                            "text": fact.text,
+                            "type": fact_type,
+                        }
+                    )
+            based_on_serialized[fact_type] = serialized_facts
+
        reflect_response = {
            "text": reflect_result.text,
-            "based_on": {
-                fact_type: [
-                    {
-                        "id": str(fact.id),
-                        "text": fact.text,
-                        "type": fact_type,
-                    }
-                    for fact in facts
-                ]
-                for fact_type, facts in reflect_result.based_on.items()
-            },
+            "based_on": based_on_serialized,
        }

        # Update the mental model with the generated content and reflect_response
@@ -637,6 +689,42 @@ class MemoryEngine(MemoryEngineInterface):
            request_context=internal_context,
        )

+        # Call post-operation hook if validator is configured
+        if self._operation_validator:
+            from hindsight_api.extensions.operation_validator import MentalModelRefreshResult
+
+            # Count facts and mental models from based_on
+            facts_used = 0
+            mental_models_used = 0
+            if reflect_result.based_on:
+                for fact_type, facts in reflect_result.based_on.items():
+                    if facts:
+                        if fact_type == "mental_models":
+                            mental_models_used += len(facts)
+                        else:
+                            facts_used += len(facts)
+
+            # Estimate tokens
+            query_tokens = len(source_query) // 4 if source_query else 0
+            output_tokens = len(generated_content) // 4 if generated_content else 0
+            context_tokens = 0  # refresh doesn't use additional context
+
+            result_ctx = MentalModelRefreshResult(
+                bank_id=bank_id,
+                mental_model_id=mental_model_id,
+                request_context=internal_context,
+                query_tokens=query_tokens,
+                output_tokens=output_tokens,
+                context_tokens=context_tokens,
+                facts_used=facts_used,
+                mental_models_used=mental_models_used,
+                success=True,
+            )
+            try:
+                await self._operation_validator.on_mental_model_refresh_complete(result_ctx)
+            except Exception as hook_err:
+                logger.warning(f"Post-mental-model-refresh hook error (non-fatal): {hook_err}")
+
        logger.info(f"[REFRESH_MENTAL_MODEL_TASK] Completed for bank_id={bank_id}, mental_model_id={mental_model_id}")

    async def execute_task(self, task_dict: dict[str, Any]):
@@ -784,7 +872,7 @@ class MemoryEngine(MemoryEngineInterface):
                kwargs = {"name": self._pg0_instance_name}
                if self._pg0_port is not None:
                    kwargs["port"] = self._pg0_port
-                pg0 = EmbeddedPostgres(**kwargs)  # type: ignore[invalid-argument-type] - dict kwargs
+                pg0 = EmbeddedPostgres(**kwargs)
                # Check if pg0 is already running before we start it
                was_already_running = await pg0.is_running()
                self.db_url = await pg0.ensure_running()
@@ -880,14 +968,36 @@ class MemoryEngine(MemoryEngineInterface):

            if not self.db_url:
                raise ValueError("Database URL is required for migrations")
+
+            # Migrate all schemas from the tenant extension
+            # The tenant extension is the single source of truth for which schemas exist
            logger.info("Running database migrations...")
-            run_migrations(self.db_url)
+            try:
+                tenants = await self._tenant_extension.list_tenants()
+                if tenants:
+                    logger.info(f"Running migrations on {len(tenants)} schema(s)...")
+                    for tenant in tenants:
+                        schema = tenant.schema
+                        if schema:
+                            try:
+                                run_migrations(self.db_url, schema=schema)
+                            except Exception as e:
+                                logger.warning(f"Failed to migrate schema {schema}: {e}")
+                    logger.info("Schema migrations completed")

-            # Ensure embedding column dimension matches the model's dimension
-            # This is done after migrations and after embeddings.initialize()
-            ensure_embedding_dimension(self.db_url, self.embeddings.dimension)
+                    # Ensure embedding column dimension matches the model's dimension
+                    # This is done after migrations and after embeddings.initialize()
+                    for tenant in tenants:
+                        schema = tenant.schema
+                        if schema:
+                            try:
+                                ensure_embedding_dimension(self.db_url, self.embeddings.dimension, schema=schema)
+                            except Exception as e:
+                                logger.warning(f"Failed to ensure embedding dimension for schema {schema}: {e}")
+            except Exception as e:
+                logger.warning(f"Failed to run schema migrations: {e}")

-        logger.info(f"Connecting to PostgreSQL at {self.db_url}")
+        logger.info(f"Connecting to PostgreSQL at {mask_network_location(self.db_url)}")

        # Create connection pool
        # For read-heavy workloads with many parallel think/search operations,
@@ -1169,15 +1279,15 @@ class MemoryEngine(MemoryEngineInterface):
            context: Context about when/why this memory was formed
            event_date: When the event occurred (defaults to now)
            document_id: Optional document ID for tracking (always upserts if document already exists)
-            fact_type_override: Override fact type ('world', 'experience', 'opinion')
-            confidence_score: Confidence score for opinions (0.0 to 1.0)
+            fact_type_override: Override fact type ('world', 'experience')
+            confidence_score: Confidence score (0.0 to 1.0)
            request_context: Request context for authentication.

        Returns:
            List of created unit IDs
        """
        # Build content dict
-        content_dict: RetainContentDict = {"content": content, "context": context}  # type: ignore[typeddict-item] - building incrementally
+        content_dict: RetainContentDict = {"content": content, "context": context}
        if event_date:
            content_dict["event_date"] = event_date
        if document_id:
@@ -1225,8 +1335,8 @@ class MemoryEngine(MemoryEngineInterface):
                - "document_id" (optional): Document ID for this specific content item
            document_id: **DEPRECATED** - Use "document_id" key in each content dict instead.
                        Applies the same document_id to ALL content items that don't specify their own.
-            fact_type_override: Override fact type for all facts ('world', 'experience', 'opinion')
-            confidence_score: Confidence score for opinions (0.0 to 1.0)
+            fact_type_override: Override fact type for all facts ('world', 'experience')
+            confidence_score: Confidence score (0.0 to 1.0)
            return_usage: If True, returns tuple of (unit_ids, TokenUsage). Default False for backward compatibility.

        Returns:
@@ -1548,16 +1658,16 @@ class MemoryEngine(MemoryEngineInterface):
        if fact_type is None:
            fact_type = list(VALID_RECALL_FACT_TYPES)

-        # Validate fact types early
+        # Filter out 'opinion' early (deprecated, silently ignore)
+        fact_type = [ft for ft in fact_type if ft != "opinion"]
+
+        # Validate fact types
        invalid_types = set(fact_type) - VALID_RECALL_FACT_TYPES
        if invalid_types:
            raise ValueError(
                f"Invalid fact type(s): {', '.join(sorted(invalid_types))}. "
                f"Must be one of: {', '.join(sorted(VALID_RECALL_FACT_TYPES))}"
            )
-
-        # Filter out 'opinion' - opinions are no longer returned from recall
-        fact_type = [ft for ft in fact_type if ft != "opinion"]
        if not fact_type:
            # All requested types were opinions - return empty result
            return RecallResultModel(results=[], entities={}, chunks={})
@@ -2213,44 +2323,15 @@ class MemoryEngine(MemoryEngineInterface):
                    )
                top_results_dicts.append(result_dict)

-            # Get entities for each fact if include_entities is requested
-            fact_entity_map = {}  # unit_id -> list of (entity_id, entity_name)
-            if include_entities and top_scored:
-                unit_ids = [uuid.UUID(sr.id) for sr in top_scored]
-                if unit_ids:
-                    async with acquire_with_retry(pool) as entity_conn:
-                        entity_rows = await entity_conn.fetch(
-                            f"""
-                            SELECT ue.unit_id, e.id as entity_id, e.canonical_name
-                            FROM {fq_table("unit_entities")} ue
-                            JOIN {fq_table("entities")} e ON ue.entity_id = e.id
-                            WHERE ue.unit_id = ANY($1::uuid[])
-                            """,
-                            unit_ids,
-                        )
-                        for row in entity_rows:
-                            unit_id = str(row["unit_id"])
-                            if unit_id not in fact_entity_map:
-                                fact_entity_map[unit_id] = []
-                            fact_entity_map[unit_id].append(
-                                {"entity_id": str(row["entity_id"]), "canonical_name": row["canonical_name"]}
-                            )
-
            # Convert results to MemoryFact objects
            memory_facts = []
            for result_dict in top_results_dicts:
-                result_id = str(result_dict.get("id"))
-                # Get entity names for this fact
-                entity_names = None
-                if include_entities and result_id in fact_entity_map:
-                    entity_names = [e["canonical_name"] for e in fact_entity_map[result_id]]
-
                memory_facts.append(
                    MemoryFact(
-                        id=result_id,
+                        id=str(result_dict.get("id")),
                        text=result_dict.get("text"),
                        fact_type=result_dict.get("fact_type", "world"),
-                        entities=entity_names,
+                        entities=None,  # Entity observations removed
                        context=result_dict.get("context"),
                        occurred_start=result_dict.get("occurred_start"),
                        occurred_end=result_dict.get("occurred_end"),
@@ -2261,38 +2342,12 @@ class MemoryEngine(MemoryEngineInterface):
                    )
                )

-            # Fetch entity observations if requested
+            # Entity observations removed - always set to None
            entities_dict = None
-            total_entity_tokens = 0
-            total_chunk_tokens = 0
-            if include_entities and fact_entity_map:
-                # Collect unique entities in order of fact relevance (preserving order from top_scored)
-                # Use a list to maintain order, but track seen entities to avoid duplicates
-                entities_ordered = []  # list of (entity_id, entity_name) tuples
-                seen_entity_ids = set()
-
-                # Iterate through facts in relevance order
-                for sr in top_scored:
-                    unit_id = sr.id
-                    if unit_id in fact_entity_map:
-                        for entity in fact_entity_map[unit_id]:
-                            entity_id = entity["entity_id"]
-                            entity_name = entity["canonical_name"]
-                            if entity_id not in seen_entity_ids:
-                                entities_ordered.append((entity_id, entity_name))
-                                seen_entity_ids.add(entity_id)
-
-                # Return entities with empty observations (summaries now live in mental models)
-                entities_dict = {}
-                for entity_id, entity_name in entities_ordered:
-                    entities_dict[entity_name] = EntityState(
-                        entity_id=entity_id,
-                        canonical_name=entity_name,
-                        observations=[],  # Mental models provide this now
-                    )

            # Fetch chunks if requested
            chunks_dict = None
+            total_chunk_tokens = 0
            if include_chunks and top_scored:
                from .response_models import ChunkInfo

@@ -2361,7 +2416,6 @@ class MemoryEngine(MemoryEngineInterface):
            # Log final recall stats
            total_time = time.time() - recall_start
            num_chunks = len(chunks_dict) if chunks_dict else 0
-            num_entities = len(entities_dict) if entities_dict else 0
            # Include wait times in log if significant
            wait_parts = []
            if semaphore_wait > 0.01:
@@ -2370,7 +2424,7 @@ class MemoryEngine(MemoryEngineInterface):
                wait_parts.append(f"conn={max_conn_wait:.3f}s")
            wait_info = f" | waits: {', '.join(wait_parts)}" if wait_parts else ""
            log_buffer.append(
-                f"[RECALL {recall_id}] Complete: {len(top_scored)} facts ({total_tokens} tok), {num_chunks} chunks ({total_chunk_tokens} tok), {num_entities} entities ({total_entity_tokens} tok) | {fact_type_summary} | {total_time:.3f}s{wait_info}"
+                f"[RECALL {recall_id}] Complete: {len(top_scored)} facts ({total_tokens} tok), {num_chunks} chunks ({total_chunk_tokens} tok) | {fact_type_summary} | {total_time:.3f}s{wait_info}"
            )
            if not quiet:
                logger.info("\n" + "\n".join(log_buffer))
@@ -3279,7 +3333,8 @@ class MemoryEngine(MemoryEngineInterface):
                    created_at,
                    updated_at,
                    LENGTH(original_text) as text_length,
-                    retain_params
+                    retain_params,
+                    tags
                FROM {fq_table("documents")}
                {where_clause}
                ORDER BY created_at DESC
@@ -3335,6 +3390,7 @@ class MemoryEngine(MemoryEngineInterface):
                        "text_length": row["text_length"] or 0,
                        "memory_unit_count": unit_count,
                        "retain_params": row["retain_params"] if row["retain_params"] else None,
+                        "tags": row["tags"] if row["tags"] else [],
                    }
                )

@@ -3544,7 +3600,6 @@ class MemoryEngine(MemoryEngineInterface):
            ReflectResult containing:
                - text: Plain text answer
                - based_on: Empty dict (agent retrieves facts dynamically)
-                - new_opinions: Empty list
                - structured_output: None (not yet supported for agentic reflect)
        """
        # Use cached LLM config
@@ -3639,12 +3694,14 @@ class MemoryEngine(MemoryEngineInterface):

        # Load directives from the dedicated directives table
        # Directives are hard rules that must be followed in all responses
+        # Use isolation_mode=True to prevent tag-scoped directives from leaking into untagged operations
        directives_raw = await self.list_directives(
            bank_id=bank_id,
            tags=tags,
            tags_match=tags_match,
            active_only=True,
            request_context=request_context,
+            isolation_mode=True,
        )
        # Convert directive format to the expected format for reflect agent
        # The agent expects: name, description (optional), observations (list of {title, content})
@@ -3713,7 +3770,16 @@ class MemoryEngine(MemoryEngineInterface):
        # Extract memories from recall tool outputs - only include memories the agent actually used
        # agent_result.used_memory_ids contains validated IDs from the done action
        used_memory_ids_set = set(agent_result.used_memory_ids) if agent_result.used_memory_ids else set()
-        based_on: dict[str, list[MemoryFact]] = {"world": [], "experience": [], "opinion": [], "observation": []}
+        # based_on stores facts, mental models, and directives
+        # Note: directives list stores raw directive dicts (not MemoryFact), which will be converted to Directive objects
+        based_on: dict[str, list[MemoryFact] | list[dict[str, Any]]] = {
+            "world": [],
+            "experience": [],
+            "opinion": [],
+            "observation": [],
+            "mental-models": [],
+            "directives": [],
+        }
        seen_memory_ids: set[str] = set()
        for tc in agent_result.tool_trace:
            if tc.tool == "recall" and "memories" in tc.output:
@@ -3815,38 +3881,15 @@ class MemoryEngine(MemoryEngineInterface):
                        )
                # List all models lookup - don't add to based_on (too verbose, just a listing)

-        # Add directives to based_on["mental-models"] (they are mental models with subtype='directive')
-        for directive in directives:
-            # Extract summary from observations
-            summary_parts: list[str] = []
-            for obs in directive.get("observations", []):
-                # Support both Pydantic Observation objects and dicts
-                if hasattr(obs, "content"):
-                    content = obs.content
-                    title = obs.title
-                else:
-                    content = obs.get("content", "")
-                    title = obs.get("title", "")
-                if title and content:
-                    summary_parts.append(f"{title}: {content}")
-                elif content:
-                    summary_parts.append(content)
-
-            # Fallback to description if no observations
-            if not summary_parts and directive.get("description"):
-                summary_parts.append(directive["description"])
-
-            directive_name = directive.get("name", "")
-            directive_summary = "; ".join(summary_parts) if summary_parts else ""
-            based_on["mental-models"].append(
-                MemoryFact(
-                    id=directive.get("id", ""),
-                    text=f"{directive_name}: {directive_summary}",
-                    fact_type="mental-models",
-                    context="directive (directive)",
-                    occurred_start=None,
-                    occurred_end=None,
-                )
+        # Add directives to based_on["directives"]
+        # Store raw directive dicts (with id, name, content) for http.py to convert to ReflectDirective
+        for directive_raw in directives_raw:
+            based_on["directives"].append(
+                {
+                    "id": directive_raw["id"],
+                    "name": directive_raw["name"],
+                    "content": directive_raw["content"],
+                }
            )

        # Build directives_applied from agent result
@@ -3869,7 +3912,6 @@ class MemoryEngine(MemoryEngineInterface):
        result = ReflectResult(
            text=agent_result.text,
            based_on=based_on,
-            new_opinions=[],  # Learnings stored as mental models
            structured_output=agent_result.structured_output,
            usage=usage,
            tool_trace=tool_trace_result,
@@ -3898,32 +3940,6 @@ class MemoryEngine(MemoryEngineInterface):

        return result

-    async def get_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        *,
-        limit: int = 10,
-        request_context: "RequestContext",
-    ) -> list[Any]:
-        """
-        Get observations for an entity.
-
-        NOTE: Entity observations/summaries have been moved to mental models.
-        This method returns an empty list. Use mental models for entity summaries.
-
-        Args:
-            bank_id: bank IDentifier
-            entity_id: Entity UUID to get observations for
-            limit: Ignored (kept for backwards compatibility)
-            request_context: Request context for authentication.
-
-        Returns:
-            Empty list (observations now in mental models)
-        """
-        await self._authenticate_tenant(request_context)
-        return []
-
    async def list_entities(
        self,
        bank_id: str,
@@ -4110,36 +4126,6 @@ class MemoryEngine(MemoryEngineInterface):
        await self._authenticate_tenant(request_context)
        return EntityState(entity_id=entity_id, canonical_name=entity_name, observations=[])

-    async def regenerate_entity_observations(
-        self,
-        bank_id: str,
-        entity_id: str,
-        entity_name: str,
-        *,
-        version: str | None = None,
-        conn=None,
-        request_context: "RequestContext",
-    ) -> list[str]:
-        """
-        Regenerate observations for an entity.
-
-        NOTE: Entity observations/summaries have been moved to mental models.
-        This method is now a no-op and returns an empty list.
-
-        Args:
-            bank_id: bank IDentifier
-            entity_id: Entity UUID
-            entity_name: Canonical name of the entity
-            version: Entity's last_seen timestamp when task was created (for deduplication)
-            conn: Optional database connection (ignored)
-            request_context: Request context for authentication.
-
-        Returns:
-            Empty list (observations now in mental models)
-        """
-        await self._authenticate_tenant(request_context)
-        return []
-
    # =========================================================================
    # Statistics & Operations (for HTTP API layer)
    # =========================================================================
@@ -4250,9 +4236,6 @@ class MemoryEngine(MemoryEngineInterface):
        if not entity_row:
            return None

-        # Get observations for the entity
-        observations = await self.get_entity_observations(bank_id, entity_id, limit=20, request_context=request_context)
-
        return {
            "id": str(entity_row["id"]),
            "canonical_name": entity_row["canonical_name"],
@@ -4260,7 +4243,7 @@ class MemoryEngine(MemoryEngineInterface):
            "first_seen": entity_row["first_seen"].isoformat() if entity_row["first_seen"] else None,
            "last_seen": entity_row["last_seen"].isoformat() if entity_row["last_seen"] else None,
            "metadata": entity_row["metadata"] or {},
-            "observations": observations,
+            "observations": [],
        }

    def _parse_observations(self, observations_raw: list):
@@ -4755,28 +4738,53 @@ class MemoryEngine(MemoryEngineInterface):
        if not mental_model:
            return None

+        # SECURITY: If the mental model has tags, pass them to reflect with "all_strict" matching
+        # to ensure it can only access other mental models/memories with the SAME tags.
+        # This prevents cross-tenant/cross-user information leakage by excluding untagged content.
+        tags = mental_model.get("tags")
+        tags_match = "all_strict" if tags else "any"
+
        # Run reflect with the source query, excluding the mental model being refreshed
        reflect_result = await self.reflect_async(
            bank_id=bank_id,
            query=mental_model["source_query"],
            request_context=request_context,
+            tags=tags,
+            tags_match=tags_match,
            exclude_mental_model_ids=[mental_model_id],
        )

        # Build reflect_response payload to store
+        # based_on contains MemoryFact objects for most types, but plain dicts for directives
+        based_on_serialized_payload: dict[str, list[dict[str, Any]]] = {}
+        for fact_type, facts in reflect_result.based_on.items():
+            serialized_facts = []
+            for fact in facts:
+                if isinstance(fact, dict):
+                    # Plain dict (e.g., directives with id, name, content)
+                    serialized_facts.append(
+                        {
+                            "id": str(fact["id"]),
+                            "text": fact.get("text", fact.get("content", fact.get("name", ""))),
+                            "type": fact_type,
+                            "context": fact.get("context", None),
+                        }
+                    )
+                else:
+                    # MemoryFact object with .id, .text, .context attributes
+                    serialized_facts.append(
+                        {
+                            "id": str(fact.id),
+                            "text": fact.text,
+                            "type": fact_type,
+                            "context": fact.context,
+                        }
+                    )
+            based_on_serialized_payload[fact_type] = serialized_facts
+
        reflect_response_payload = {
            "text": reflect_result.text,
-            "based_on": {
-                fact_type: [
-                    {
-                        "id": str(fact.id),
-                        "text": fact.text,
-                        "type": fact_type,
-                    }
-                    for fact in facts
-                ]
-                for fact_type, facts in reflect_result.based_on.items()
-            },
+            "based_on": based_on_serialized_payload,
            "mental_models": [],  # Mental models are included in based_on["mental-models"]
        }

@@ -4960,6 +4968,7 @@ class MemoryEngine(MemoryEngineInterface):
        limit: int = 100,
        offset: int = 0,
        request_context: "RequestContext",
+        isolation_mode: bool = False,
    ) -> list[dict[str, Any]]:
        """List directives for a bank.

@@ -4971,6 +4980,9 @@ class MemoryEngine(MemoryEngineInterface):
            limit: Maximum number of results
            offset: Offset for pagination
            request_context: Request context for authentication
+            isolation_mode: When True and tags=None, only return directives with no tags.
+                This prevents tag-scoped directives from leaking into untagged operations.
+                Default False (normal API behavior - returns all directives when tags=None)

        Returns:
            List of directive dicts
@@ -4980,6 +4992,8 @@ class MemoryEngine(MemoryEngineInterface):

        async with acquire_with_retry(pool) as conn:
            # Build filters
+            from .search.tags import build_tags_where_clause
+
            filters = ["bank_id = $1"]
            params: list[Any] = [bank_id]
            param_idx = 2
@@ -4987,15 +5001,23 @@ class MemoryEngine(MemoryEngineInterface):
            if active_only:
                filters.append("is_active = TRUE")

+            # Apply tags filter:
+            # - If tags provided: use standard filtering (with strict modes support)
+            # - If tags=None and isolation_mode=True: only include directives with NO tags
+            #   (prevents tag-scoped directives from leaking into untagged reflect/refresh)
+            # - If tags=None and isolation_mode=False: no filtering (normal API behavior)
            if tags:
-                if tags_match == "all":
-                    filters.append(f"tags @> ${param_idx}::varchar[]")
-                elif tags_match == "exact":
-                    filters.append(f"tags = ${param_idx}::varchar[]")
-                else:  # any
-                    filters.append(f"tags && ${param_idx}::varchar[]")
-                params.append(tags)
-                param_idx += 1
+                tags_clause, tags_params, param_idx = build_tags_where_clause(
+                    tags=tags, param_offset=param_idx, table_alias="", match=tags_match
+                )
+                if tags_clause:
+                    # Remove leading "AND " from clause since we're building filters list
+                    filters.append(tags_clause.replace("AND ", "", 1))
+                    params.extend(tags_params)
+            elif isolation_mode:
+                # Isolation mode: only include directives with empty/null tags
+                # This ensures tag-scoped directives don't apply to untagged operations
+                filters.append("(tags IS NULL OR tags = '{}')")

            params.extend([limit, offset])

@@ -5511,6 +5533,13 @@ class MemoryEngine(MemoryEngineInterface):
        task_payload: dict[str, Any] = {"contents": contents}
        if document_tags:
            task_payload["document_tags"] = document_tags
+        # Pass tenant_id and api_key_id through task payload so the worker
+        # can propagate request context to downstream operations (e.g.,
+        # consolidation and mental model refreshes triggered after retain).
+        if request_context.tenant_id:
+            task_payload["_tenant_id"] = request_context.tenant_id
+        if request_context.api_key_id:
+            task_payload["_api_key_id"] = request_context.api_key_id

        result = await self._submit_async_operation(
            bank_id=bank_id,
@@ -5543,11 +5572,21 @@ class MemoryEngine(MemoryEngineInterface):
            Dict with operation_id
        """
        await self._authenticate_tenant(request_context)
+
+        # Pass tenant_id and api_key_id through task payload so the worker
+        # can provide request context to extension hooks (e.g., usage metering
+        # for mental model refreshes triggered by consolidation).
+        task_payload: dict[str, Any] = {}
+        if request_context.tenant_id:
+            task_payload["_tenant_id"] = request_context.tenant_id
+        if request_context.api_key_id:
+            task_payload["_api_key_id"] = request_context.api_key_id
+
        return await self._submit_async_operation(
            bank_id=bank_id,
            operation_type="consolidation",
            task_type="consolidation",
-            task_payload={},
+            task_payload=task_payload,
            dedupe_by_bank=True,
        )

@@ -5577,13 +5616,21 @@ class MemoryEngine(MemoryEngineInterface):
        if not mental_model:
            raise ValueError(f"Mental model {mental_model_id} not found in bank {bank_id}")

+        # Pass tenant_id and api_key_id through task payload so the worker
+        # can provide request context to extension hooks.
+        task_payload: dict[str, Any] = {
+            "mental_model_id": mental_model_id,
+        }
+        if request_context.tenant_id:
+            task_payload["_tenant_id"] = request_context.tenant_id
+        if request_context.api_key_id:
+            task_payload["_api_key_id"] = request_context.api_key_id
+
        return await self._submit_async_operation(
            bank_id=bank_id,
            operation_type="refresh_mental_model",
            task_type="refresh_mental_model",
-            task_payload={
-                "mental_model_id": mental_model_id,
-            },
+            task_payload=task_payload,
            result_metadata={"mental_model_id": mental_model_id, "name": mental_model["name"]},
            dedupe_by_bank=False,
        )
@@ -0,0 +1,14 @@
+"""
+LLM provider implementations.
+
+This package contains concrete implementations of the LLMInterface for various providers.
+"""
+
+from .anthropic_llm import AnthropicLLM
+from .claude_code_llm import ClaudeCodeLLM
+from .codex_llm import CodexLLM
+from .gemini_llm import GeminiLLM
+from .mock_llm import MockLLM
+from .openai_compatible_llm import OpenAICompatibleLLM
+
+__all__ = ["AnthropicLLM", "ClaudeCodeLLM", "CodexLLM", "GeminiLLM", "MockLLM", "OpenAICompatibleLLM"]
@@ -0,0 +1,434 @@
+"""
+Anthropic LLM provider using the Anthropic Python SDK.
+
+This provider enables using Claude models from Anthropic with support for:
+- Structured JSON output
+- Tool/function calling with proper format conversion
+- Extended thinking mode
+- Retry logic with exponential backoff
+"""
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any
+
+from hindsight_api.engine.llm_interface import LLMInterface, OutputTooLongError
+from hindsight_api.engine.response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+from hindsight_api.metrics import get_metrics_collector
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicLLM(LLMInterface):
+    """
+    LLM provider using Anthropic's Claude models.
+
+    Supports structured output, tool calling, and extended thinking mode.
+    Handles format conversion between OpenAI-style messages and Anthropic's format.
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        timeout: float = 300.0,
+        **kwargs: Any,
+    ):
+        """
+        Initialize Anthropic LLM provider.
+
+        Args:
+            provider: Provider name (should be "anthropic").
+            api_key: Anthropic API key.
+            base_url: Base URL for the API (optional, uses Anthropic default if empty).
+            model: Model name (e.g., "claude-sonnet-4-20250514").
+            reasoning_effort: Reasoning effort level (not used by Anthropic).
+            timeout: Request timeout in seconds.
+            **kwargs: Additional provider-specific parameters.
+        """
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        if not self.api_key:
+            raise ValueError("API key is required for Anthropic provider")
+
+        # Import and initialize Anthropic client
+        try:
+            from anthropic import AsyncAnthropic
+
+            client_kwargs: dict[str, Any] = {"api_key": self.api_key}
+            if self.base_url:
+                client_kwargs["base_url"] = self.base_url
+            if timeout:
+                client_kwargs["timeout"] = timeout
+
+            self._client = AsyncAnthropic(**client_kwargs)
+            logger.info(f"Anthropic client initialized for model: {self.model}")
+        except ImportError as e:
+            raise RuntimeError("Anthropic SDK not installed. Run: uv add anthropic or pip install anthropic") from e
+
+    async def verify_connection(self) -> None:
+        """
+        Verify that the Anthropic provider is configured correctly by making a simple test call.
+
+        Raises:
+            RuntimeError: If the connection test fails.
+        """
+        try:
+            test_messages = [{"role": "user", "content": "test"}]
+            await self.call(
+                messages=test_messages,
+                max_completion_tokens=10,
+                temperature=0.0,
+                scope="test",
+                max_retries=0,
+            )
+            logger.info("Anthropic connection verified successfully")
+        except Exception as e:
+            logger.error(f"Anthropic connection verification failed: {e}")
+            raise RuntimeError(f"Failed to verify Anthropic connection: {e}") from e
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make an LLM API call with retry logic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Use strict JSON schema enforcement (not supported by Anthropic).
+            return_usage: If True, return tuple (result, TokenUsage) instead of just result.
+
+        Returns:
+            If return_usage=False: Parsed response if response_format is provided, otherwise text content.
+            If return_usage=True: Tuple of (result, TokenUsage) with token counts.
+
+        Raises:
+            OutputTooLongError: If output exceeds token limits.
+            Exception: Re-raises API errors after retries exhausted.
+        """
+        from anthropic import APIConnectionError, APIStatusError, RateLimitError
+
+        start_time = time.time()
+
+        # Convert OpenAI-style messages to Anthropic format
+        system_prompt = None
+        anthropic_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                if system_prompt:
+                    system_prompt += "\n\n" + content
+                else:
+                    system_prompt = content
+            else:
+                anthropic_messages.append({"role": role, "content": content})
+
+        # Add JSON schema instruction if response_format is provided
+        if response_format is not None and hasattr(response_format, "model_json_schema"):
+            schema = response_format.model_json_schema()
+            schema_msg = f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}"
+            if system_prompt:
+                system_prompt += schema_msg
+            else:
+                system_prompt = schema_msg
+
+        # Prepare parameters
+        call_params: dict[str, Any] = {
+            "model": self.model,
+            "messages": anthropic_messages,
+            "max_tokens": max_completion_tokens if max_completion_tokens is not None else 4096,
+        }
+
+        if system_prompt:
+            call_params["system"] = system_prompt
+
+        if temperature is not None:
+            call_params["temperature"] = temperature
+
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.messages.create(**call_params)
+
+                # Anthropic response content is a list of blocks
+                content = ""
+                for block in response.content:
+                    if block.type == "text":
+                        content += block.text
+
+                if response_format is not None:
+                    # Models may wrap JSON in markdown code blocks
+                    clean_content = content
+                    if "```json" in content:
+                        clean_content = content.split("```json")[1].split("```")[0].strip()
+                    elif "```" in content:
+                        clean_content = content.split("```")[1].split("```")[0].strip()
+
+                    try:
+                        json_data = json.loads(clean_content)
+                    except json.JSONDecodeError:
+                        # Fallback to parsing raw content if markdown stripping failed
+                        json_data = json.loads(content)
+
+                    if skip_validation:
+                        result = json_data
+                    else:
+                        result = response_format.model_validate(json_data)
+                else:
+                    result = content
+
+                # Record metrics and log slow calls
+                duration = time.time() - start_time
+                input_tokens = response.usage.input_tokens or 0 if response.usage else 0
+                output_tokens = response.usage.output_tokens or 0 if response.usage else 0
+                total_tokens = input_tokens + output_tokens
+
+                # Record LLM metrics
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0:
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, "
+                        f"input_tokens={input_tokens}, output_tokens={output_tokens}, "
+                        f"time={duration:.3f}s"
+                    )
+
+                if return_usage:
+                    token_usage = TokenUsage(
+                        input_tokens=input_tokens,
+                        output_tokens=output_tokens,
+                        total_tokens=total_tokens,
+                    )
+                    return result, token_usage
+                return result
+
+            except json.JSONDecodeError as e:
+                last_exception = e
+                if attempt < max_retries:
+                    logger.warning("Anthropic returned invalid JSON, retrying...")
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Anthropic returned invalid JSON after {max_retries + 1} attempts")
+                    raise
+
+            except (APIConnectionError, RateLimitError, APIStatusError) as e:
+                # Fast fail on 401/403
+                if isinstance(e, APIStatusError) and e.status_code in (401, 403):
+                    logger.error(f"Anthropic auth error (HTTP {e.status_code}), not retrying: {str(e)}")
+                    raise
+
+                last_exception = e
+                if attempt < max_retries:
+                    # Check if it's a rate limit or server error
+                    should_retry = isinstance(e, (APIConnectionError, RateLimitError)) or (
+                        isinstance(e, APIStatusError) and e.status_code >= 500
+                    )
+
+                    if should_retry:
+                        backoff = min(initial_backoff * (2**attempt), max_backoff)
+                        jitter = backoff * 0.2 * (2 * (time.time() % 1) - 1)
+                        await asyncio.sleep(backoff + jitter)
+                        continue
+
+                logger.error(f"Anthropic API error after {max_retries + 1} attempts: {str(e)}")
+                raise
+
+            except Exception as e:
+                logger.error(f"Unexpected error during Anthropic call: {type(e).__name__}: {str(e)}")
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Anthropic call failed after all retries")
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make an LLM API call with tool/function calling support.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        from anthropic import APIConnectionError, APIStatusError
+
+        start_time = time.time()
+
+        # Convert OpenAI tool format to Anthropic format
+        anthropic_tools = []
+        for tool in tools:
+            func = tool.get("function", {})
+            anthropic_tools.append(
+                {
+                    "name": func.get("name", ""),
+                    "description": func.get("description", ""),
+                    "input_schema": func.get("parameters", {"type": "object", "properties": {}}),
+                }
+            )
+
+        # Convert messages - handle tool results
+        system_prompt = None
+        anthropic_messages = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = (system_prompt + "\n\n" + content) if system_prompt else content
+            elif role == "tool":
+                # Anthropic uses tool_result blocks
+                anthropic_messages.append(
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "tool_result", "tool_use_id": msg.get("tool_call_id", ""), "content": content}
+                        ],
+                    }
+                )
+            elif role == "assistant" and msg.get("tool_calls"):
+                # Convert assistant tool calls
+                tool_use_blocks = []
+                for tc in msg["tool_calls"]:
+                    tool_use_blocks.append(
+                        {
+                            "type": "tool_use",
+                            "id": tc.get("id", ""),
+                            "name": tc.get("function", {}).get("name", ""),
+                            "input": json.loads(tc.get("function", {}).get("arguments", "{}")),
+                        }
+                    )
+                anthropic_messages.append({"role": "assistant", "content": tool_use_blocks})
+            else:
+                anthropic_messages.append({"role": role, "content": content})
+
+        call_params: dict[str, Any] = {
+            "model": self.model,
+            "messages": anthropic_messages,
+            "tools": anthropic_tools,
+            "max_tokens": max_completion_tokens or 4096,
+        }
+        if system_prompt:
+            call_params["system"] = system_prompt
+
+        if temperature is not None:
+            call_params["temperature"] = temperature
+
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.messages.create(**call_params)
+
+                # Extract content and tool calls
+                content_parts = []
+                tool_calls: list[LLMToolCall] = []
+
+                for block in response.content:
+                    if block.type == "text":
+                        content_parts.append(block.text)
+                    elif block.type == "tool_use":
+                        tool_calls.append(LLMToolCall(id=block.id, name=block.name, arguments=block.input or {}))
+
+                content = "".join(content_parts) if content_parts else None
+                finish_reason = "tool_calls" if tool_calls else "stop"
+
+                # Extract token usage
+                input_tokens = response.usage.input_tokens or 0
+                output_tokens = response.usage.output_tokens or 0
+
+                # Record metrics
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=time.time() - start_time,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                return LLMToolCallResult(
+                    content=content,
+                    tool_calls=tool_calls,
+                    finish_reason=finish_reason,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                )
+
+            except (APIConnectionError, APIStatusError) as e:
+                if isinstance(e, APIStatusError) and e.status_code in (401, 403):
+                    raise
+                last_exception = e
+                if attempt < max_retries:
+                    await asyncio.sleep(min(initial_backoff * (2**attempt), max_backoff))
+                    continue
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Anthropic tool call failed")
+
+    async def cleanup(self) -> None:
+        """Clean up resources (close Anthropic client connections)."""
+        if hasattr(self, "_client") and self._client:
+            await self._client.close()
@@ -0,0 +1,493 @@
+"""
+Claude Code LLM provider using Claude Agent SDK.
+
+This provider enables using Claude Pro/Max subscriptions for API calls
+via the Claude CLI authentication. It uses the Claude Agent SDK which
+automatically handles authentication via `claude auth login` credentials.
+"""
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any
+
+from hindsight_api.engine.llm_interface import LLMInterface, OutputTooLongError
+from hindsight_api.engine.response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+from hindsight_api.metrics import get_metrics_collector
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeCodeLLM(LLMInterface):
+    """
+    LLM provider using Claude Code authentication.
+
+    Authenticates using Claude Pro/Max credentials via `claude auth login`
+    and makes API calls through the Claude Agent SDK.
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,  # Will be ignored, uses CLI auth
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        **kwargs: Any,
+    ):
+        """Initialize Claude Code LLM provider."""
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        # Verify Claude Agent SDK is available
+        try:
+            self._verify_claude_code_available()
+            logger.info("Claude Code: Using Claude Agent SDK (authentication via claude auth login)")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to initialize Claude Code provider: {e}\n\n"
+                "To set up Claude Code authentication:\n"
+                "1. Install Claude Code CLI: npm install -g @anthropics/claude-code\n"
+                "2. Login with your Pro/Max plan: claude auth login\n"
+                "3. Verify authentication: claude --version\n\n"
+                "Or use a different provider (anthropic, openai, gemini) with API keys."
+            ) from e
+
+        # Metrics collector is imported at module level
+
+    def _verify_claude_code_available(self) -> None:
+        """
+        Verify that Claude Agent SDK can be imported and is properly configured.
+
+        Raises:
+            ImportError: If Claude Agent SDK is not installed.
+            RuntimeError: If Claude Code is not authenticated.
+        """
+        try:
+            # Import Claude Agent SDK
+            # Reduce Claude Agent SDK logging verbosity
+            import logging as sdk_logging
+
+            from claude_agent_sdk import query  # noqa: F401
+
+            sdk_logging.getLogger("claude_agent_sdk").setLevel(sdk_logging.WARNING)
+            sdk_logging.getLogger("claude_agent_sdk._internal").setLevel(sdk_logging.WARNING)
+
+            logger.debug("Claude Agent SDK imported successfully")
+        except ImportError as e:
+            raise ImportError(
+                "Claude Agent SDK not installed. Run: uv add claude-agent-sdk or pip install claude-agent-sdk"
+            ) from e
+
+        # SDK will automatically check for authentication when first used
+        # No need to verify here - let it fail gracefully on first call with helpful error
+
+    async def verify_connection(self) -> None:
+        """
+        Verify that the Claude Code provider is configured correctly by making a simple test call.
+
+        Raises:
+            RuntimeError: If the connection test fails.
+        """
+        try:
+            test_messages = [{"role": "user", "content": "test"}]
+            await self.call(
+                messages=test_messages,
+                max_completion_tokens=10,
+                temperature=0.0,
+                scope="test",
+                max_retries=0,
+            )
+            logger.info("Claude Code connection verified successfully")
+        except Exception as e:
+            logger.error(f"Claude Code connection verification failed: {e}")
+            raise RuntimeError(f"Failed to verify Claude Code connection: {e}") from e
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make an LLM API call with retry logic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Maximum tokens in response (ignored by Claude Agent SDK).
+            temperature: Sampling temperature (ignored by Claude Agent SDK).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Use strict JSON schema enforcement (not supported).
+            return_usage: If True, return tuple (result, TokenUsage) instead of just result.
+
+        Returns:
+            If return_usage=False: Parsed response if response_format is provided, otherwise text content.
+            If return_usage=True: Tuple of (result, TokenUsage) with estimated token counts.
+
+        Raises:
+            OutputTooLongError: If output exceeds token limits (not supported by Claude Agent SDK).
+            Exception: Re-raises API errors after retries exhausted.
+        """
+        from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
+
+        start_time = time.time()
+
+        # Build system prompt
+        system_prompt = ""
+        user_content = ""
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt += ("\n\n" + content) if system_prompt else content
+            elif role == "user":
+                user_content += ("\n\n" + content) if user_content else content
+            elif role == "assistant":
+                # Claude Agent SDK doesn't support multi-turn easily in query()
+                # For now, prepend assistant messages to user content
+                user_content += f"\n\n[Previous assistant response: {content}]"
+
+        # Add JSON schema instruction if response_format is provided
+        if response_format is not None and hasattr(response_format, "model_json_schema"):
+            schema = response_format.model_json_schema()
+            schema_instruction = (
+                f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}\n\n"
+                "Respond with ONLY the JSON, no markdown formatting."
+            )
+            user_content += schema_instruction
+
+        # Configure SDK options
+        options = ClaudeAgentOptions(
+            system_prompt=system_prompt if system_prompt else None,
+            max_turns=1,  # Single-turn for API-style interactions
+            allowed_tools=[],  # Disable tools for standard LLM calls
+        )
+
+        # Call Claude Agent SDK
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                # Collect streaming response
+                full_text = ""
+
+                async for message in query(prompt=user_content, options=options):
+                    if isinstance(message, AssistantMessage):
+                        for block in message.content:
+                            if isinstance(block, TextBlock):
+                                full_text += block.text
+
+                # Handle structured output
+                if response_format is not None:
+                    # Models may wrap JSON in markdown
+                    clean_text = full_text
+                    if "```json" in full_text:
+                        clean_text = full_text.split("```json")[1].split("```")[0].strip()
+                    elif "```" in full_text:
+                        clean_text = full_text.split("```")[1].split("```")[0].strip()
+
+                    try:
+                        json_data = json.loads(clean_text)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"Claude Code JSON parse error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                        if attempt < max_retries:
+                            backoff = min(initial_backoff * (2**attempt), max_backoff)
+                            await asyncio.sleep(backoff)
+                            last_exception = e
+                            continue
+                        raise
+
+                    if skip_validation:
+                        result = json_data
+                    else:
+                        result = response_format.model_validate(json_data)
+                else:
+                    result = full_text
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+
+                # Estimate token usage (Claude Agent SDK doesn't report exact counts)
+                # Use character count / 4 as rough estimate (1 token ≈ 4 characters)
+                estimated_input = sum(len(m.get("content", "")) for m in messages) // 4
+                estimated_output = len(full_text) // 4
+
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=estimated_input,
+                    output_tokens=estimated_output,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0:
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, time={duration:.3f}s"
+                    )
+
+                if return_usage:
+                    token_usage = TokenUsage(
+                        input_tokens=estimated_input,
+                        output_tokens=estimated_output,
+                        total_tokens=estimated_input + estimated_output,
+                    )
+                    return result, token_usage
+
+                return result
+
+            except Exception as e:
+                last_exception = e
+
+                # Check for authentication errors
+                error_str = str(e).lower()
+                if "auth" in error_str or "login" in error_str or "credential" in error_str:
+                    logger.error(f"Claude Code authentication error: {e}")
+                    raise RuntimeError(
+                        f"Claude Code authentication failed: {e}\n\n"
+                        "Run 'claude auth login' to authenticate with Claude Pro/Max."
+                    ) from e
+
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    logger.warning(f"Claude Code error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Claude Code error after {max_retries + 1} attempts: {e}")
+                    raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Claude Code call failed after all retries")
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make an LLM API call with tool/function calling support using Claude Agent SDK.
+
+        This implementation uses ClaudeSDKClient (not query()) because custom tools via
+        SDK MCP servers are only supported with the client. Tools are converted from OpenAI
+        format to SDK MCP tools, and tool names are formatted as mcp__hindsight_tools__{name}.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response (not used by Claude Agent SDK).
+            temperature: Sampling temperature (not used by Claude Agent SDK).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools (not used by Claude Agent SDK).
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        from claude_agent_sdk import (
+            AssistantMessage,
+            ClaudeAgentOptions,
+            ClaudeSDKClient,
+            SdkMcpTool,
+            TextBlock,
+            ToolUseBlock,
+            create_sdk_mcp_server,
+        )
+
+        start_time = time.time()
+
+        # Convert OpenAI tool format to Claude Agent SDK SdkMcpTool format
+        sdk_tools: list[SdkMcpTool] = []
+        tool_names: list[str] = []
+
+        for tool in tools:
+            func = tool.get("function", {})
+            tool_name = func.get("name", "")
+            tool_description = func.get("description", "")
+            parameters = func.get("parameters", {})
+
+            # Create a handler with proper closure to avoid transport issues
+            def make_handler(name: str):
+                async def handler(args: dict[str, Any]) -> dict[str, Any]:
+                    # Return immediately with success - tool execution happens externally
+                    return {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": f"[Tool {name} called successfully]",
+                            }
+                        ]
+                    }
+
+                return handler
+
+            sdk_tools.append(
+                SdkMcpTool(
+                    name=tool_name,
+                    description=tool_description,
+                    input_schema=parameters,
+                    handler=make_handler(tool_name),
+                )
+            )
+            tool_names.append(tool_name)
+
+        # Create an MCP server with the tools
+        mcp_server = create_sdk_mcp_server(
+            name="hindsight_tools",
+            version="1.0.0",
+            tools=sdk_tools if sdk_tools else None,
+        )
+
+        # Build system prompt and user content from messages
+        system_prompt = ""
+        user_content = ""
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt += ("\n\n" + content) if system_prompt else content
+            elif role == "user":
+                user_content += ("\n\n" + content) if user_content else content
+            elif role == "assistant":
+                # Include previous assistant messages as context
+                user_content += f"\n\n[Previous assistant response: {content}]"
+            elif role == "tool":
+                # Tool results are already in tool_results_map, append to user context
+                tool_call_id = msg.get("tool_call_id", "")
+                user_content += f"\n\n[Tool result for {tool_call_id}: {content}]"
+
+        # Format tool names for SDK MCP servers: mcp__{server_name}__{tool_name}
+        # This is required by the Claude Agent SDK for MCP server tools
+        allowed_tool_names = [f"mcp__hindsight_tools__{name}" for name in tool_names]
+
+        # Configure SDK options with MCP server
+        options = ClaudeAgentOptions(
+            system_prompt=system_prompt if system_prompt else None,
+            max_turns=1,  # Single-turn for API-style interactions
+            mcp_servers={"hindsight_tools": mcp_server} if sdk_tools else {},
+            allowed_tools=allowed_tool_names if allowed_tool_names else [],
+        )
+
+        # Call Claude Agent SDK with retry logic
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                full_text = ""
+                tool_calls: list[LLMToolCall] = []
+
+                # Use ClaudeSDKClient for tool calling support
+                # Note: query() does NOT support custom tools, only ClaudeSDKClient does
+                async with ClaudeSDKClient(options=options) as client:
+                    # Send the query
+                    await client.query(user_content)
+
+                    # Receive response
+                    async for message in client.receive_response():
+                        if isinstance(message, AssistantMessage):
+                            for block in message.content:
+                                if isinstance(block, TextBlock):
+                                    full_text += block.text
+                                elif isinstance(block, ToolUseBlock):
+                                    # SDK returns tool names with MCP prefix (mcp__hindsight_tools__{name})
+                                    # Strip the prefix to return original tool name expected by caller
+                                    tool_name = block.name
+                                    if tool_name.startswith("mcp__hindsight_tools__"):
+                                        tool_name = tool_name.replace("mcp__hindsight_tools__", "", 1)
+
+                                    tool_calls.append(
+                                        LLMToolCall(
+                                            id=block.id,
+                                            name=tool_name,
+                                            arguments=block.input,
+                                        )
+                                    )
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+
+                # Estimate token usage (Claude Agent SDK doesn't report exact counts)
+                estimated_input = sum(len(m.get("content", "")) for m in messages) // 4
+                estimated_output = len(full_text) // 4
+
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=estimated_input,
+                    output_tokens=estimated_output,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0:
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, time={duration:.3f}s"
+                    )
+
+                return LLMToolCallResult(
+                    content=full_text if full_text else None,
+                    tool_calls=tool_calls,
+                    finish_reason="tool_calls" if tool_calls else "stop",
+                    input_tokens=estimated_input,
+                    output_tokens=estimated_output,
+                )
+
+            except Exception as e:
+                last_exception = e
+
+                # Check for authentication errors
+                error_str = str(e).lower()
+                if "auth" in error_str or "login" in error_str or "credential" in error_str:
+                    logger.error(f"Claude Code authentication error: {e}")
+                    raise RuntimeError(
+                        f"Claude Code authentication failed: {e}\n\n"
+                        "Run 'claude auth login' to authenticate with Claude Pro/Max."
+                    ) from e
+
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    logger.warning(f"Claude Code tool call error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Claude Code tool call error after {max_retries + 1} attempts: {e}")
+                    raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Claude Code tool call failed after all retries")
+
+    async def cleanup(self) -> None:
+        """Clean up resources (no HTTP client to close for Claude Agent SDK)."""
+        pass
@@ -0,0 +1,578 @@
+"""
+OpenAI Codex LLM provider using ChatGPT Plus/Pro OAuth authentication.
+
+This provider enables using ChatGPT Plus/Pro subscriptions for API calls
+without separate OpenAI Platform API credits. It uses OAuth tokens from
+~/.codex/auth.json and communicates with the ChatGPT backend API.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from hindsight_api.engine.llm_interface import LLMInterface, OutputTooLongError
+from hindsight_api.engine.response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+from hindsight_api.metrics import get_metrics_collector
+
+logger = logging.getLogger(__name__)
+
+
+class CodexLLM(LLMInterface):
+    """
+    LLM provider using OpenAI Codex OAuth authentication.
+
+    Authenticates using ChatGPT Plus/Pro credentials stored in ~/.codex/auth.json
+    and makes API calls to chatgpt.com/backend-api/codex/responses.
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,  # Will be ignored, reads from ~/.codex/auth.json
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        **kwargs: Any,
+    ):
+        """Initialize Codex LLM provider."""
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        # Load Codex OAuth credentials
+        try:
+            self.access_token, self.account_id = self._load_codex_auth()
+            logger.info(f"Loaded Codex OAuth credentials for account: {self.account_id}")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to load Codex OAuth credentials from ~/.codex/auth.json: {e}\n\n"
+                "To set up Codex authentication:\n"
+                "1. Install Codex CLI: npm install -g @openai/codex\n"
+                "2. Login: codex auth login\n"
+                "3. Verify: ls ~/.codex/auth.json\n\n"
+                "Or use a different provider (openai, anthropic, gemini) with API keys."
+            ) from e
+
+        # Use ChatGPT backend API endpoint
+        if not self.base_url:
+            self.base_url = "https://chatgpt.com/backend-api"
+
+        # Normalize model name (strip openai/ prefix if present)
+        if self.model.startswith("openai/"):
+            self.model = self.model[len("openai/") :]
+
+        # Map reasoning effort to Codex reasoning summary format
+        # Codex supports: "auto", "concise", "detailed"
+        self.reasoning_summary = self._map_reasoning_effort(reasoning_effort)
+
+        # HTTP client for SSE streaming
+        self._client = httpx.AsyncClient(timeout=120.0)
+
+    def _load_codex_auth(self) -> tuple[str, str]:
+        """
+        Load OAuth credentials from ~/.codex/auth.json.
+
+        Returns:
+            Tuple of (access_token, account_id).
+
+        Raises:
+            FileNotFoundError: If auth file doesn't exist.
+            ValueError: If auth file is invalid.
+        """
+        auth_file = Path.home() / ".codex" / "auth.json"
+
+        if not auth_file.exists():
+            raise FileNotFoundError(
+                f"Codex auth file not found: {auth_file}\nRun 'codex auth login' to authenticate with ChatGPT Plus/Pro."
+            )
+
+        with open(auth_file) as f:
+            data = json.load(f)
+
+        # Validate auth structure
+        auth_mode = data.get("auth_mode")
+        if auth_mode != "chatgpt":
+            raise ValueError(f"Expected auth_mode='chatgpt', got: {auth_mode}")
+
+        tokens = data.get("tokens", {})
+        access_token = tokens.get("access_token")
+        account_id = tokens.get("account_id")
+
+        if not access_token:
+            raise ValueError("No access_token found in Codex auth file. Run 'codex auth login' again.")
+
+        return access_token, account_id
+
+    def _map_reasoning_effort(self, effort: str) -> str:
+        """
+        Map standard reasoning effort to Codex reasoning summary format.
+
+        Args:
+            effort: Standard effort level ("low", "medium", "high", "xhigh").
+
+        Returns:
+            Codex reasoning summary: "concise", "detailed", or "auto".
+        """
+        mapping = {
+            "low": "concise",
+            "medium": "auto",
+            "high": "detailed",
+            "xhigh": "detailed",
+        }
+        return mapping.get(effort.lower(), "auto")
+
+    async def verify_connection(self) -> None:
+        """Verify Codex connection by making a simple test call."""
+        try:
+            logger.info(f"Verifying Codex LLM: model={self.model}, account={self.account_id}...")
+            await self.call(
+                messages=[{"role": "user", "content": "Say 'ok'"}],
+                max_completion_tokens=10,
+                max_retries=2,
+                initial_backoff=0.5,
+                max_backoff=2.0,
+            )
+            logger.info(f"Codex LLM verified: {self.model}")
+        except Exception as e:
+            raise RuntimeError(f"Codex LLM connection verification failed for {self.model}: {e}") from e
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """Make API call to Codex backend with SSE streaming."""
+        start_time = time.time()
+
+        # Prepare system instructions
+        system_instruction = ""
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_instruction += ("\n\n" + content) if system_instruction else content
+            else:
+                user_messages.append(msg)
+
+        # Add JSON schema instruction if response_format is provided
+        if response_format is not None and hasattr(response_format, "model_json_schema"):
+            schema = response_format.model_json_schema()
+            schema_msg = f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}"
+            system_instruction += schema_msg
+
+        # gpt-5.2-codex only supports "detailed" reasoning summary
+        reasoning_summary = "detailed" if "5.2" in self.model else self.reasoning_summary
+
+        # Build Codex request payload
+        payload = {
+            "model": self.model,
+            "instructions": system_instruction,
+            "input": [
+                {
+                    "type": "message",
+                    "role": msg.get("role", "user"),
+                    "content": msg.get("content", ""),
+                }
+                for msg in user_messages
+            ],
+            "tools": [],
+            "tool_choice": "auto",
+            "parallel_tool_calls": True,
+            "reasoning": {"summary": reasoning_summary},
+            "store": False,  # Codex uses stateless mode
+            "stream": True,  # SSE streaming
+            "include": ["reasoning.encrypted_content"],
+            "prompt_cache_key": str(uuid.uuid4()),
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+            "OpenAI-Account-ID": self.account_id,
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+            "Origin": "https://chatgpt.com",
+        }
+
+        url = f"{self.base_url}/codex/responses"
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.post(url, json=payload, headers=headers, timeout=120.0)
+                response.raise_for_status()
+
+                # Parse SSE stream
+                content = await self._parse_sse_stream(response)
+
+                # Handle structured output
+                if response_format is not None:
+                    # Models may wrap JSON in markdown
+                    clean_content = content
+                    if "```json" in content:
+                        clean_content = content.split("```json")[1].split("```")[0].strip()
+                    elif "```" in content:
+                        clean_content = content.split("```")[1].split("```")[0].strip()
+
+                    try:
+                        json_data = json.loads(clean_content)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"Codex JSON parse error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                        if attempt < max_retries:
+                            backoff = min(initial_backoff * (2**attempt), max_backoff)
+                            await asyncio.sleep(backoff)
+                            last_exception = e
+                            continue
+                        raise
+
+                    if skip_validation:
+                        result = json_data
+                    else:
+                        result = response_format.model_validate(json_data)
+                else:
+                    result = content
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=0,  # Codex doesn't report token counts in SSE
+                    output_tokens=0,
+                    success=True,
+                )
+
+                if return_usage:
+                    # Codex doesn't provide token counts, estimate based on content
+                    estimated_input = sum(len(m.get("content", "")) for m in messages) // 4
+                    estimated_output = len(content) // 4
+                    token_usage = TokenUsage(
+                        input_tokens=estimated_input,
+                        output_tokens=estimated_output,
+                        total_tokens=estimated_input + estimated_output,
+                    )
+                    return result, token_usage
+
+                return result
+
+            except httpx.HTTPStatusError as e:
+                last_exception = e
+                status_code = e.response.status_code
+
+                # Fast fail on auth errors
+                if status_code in (401, 403):
+                    logger.error(f"Codex auth error (HTTP {status_code}): {e.response.text[:200]}")
+                    raise RuntimeError(
+                        "Codex authentication failed. Your OAuth token may have expired.\n"
+                        "Run 'codex auth login' to re-authenticate."
+                    ) from e
+
+                # Log the actual error message from the API
+                error_detail = e.response.text[:500] if hasattr(e.response, "text") else str(e)
+
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    logger.warning(
+                        f"Codex HTTP error {status_code} (attempt {attempt + 1}/{max_retries + 1}): {error_detail}"
+                    )
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(
+                        f"Codex HTTP error after {max_retries + 1} attempts: Status {status_code}, Detail: {error_detail}"
+                    )
+                    raise
+
+            except httpx.RequestError as e:
+                last_exception = e
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    logger.warning(f"Codex connection error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Codex connection error after {max_retries + 1} attempts: {e}")
+                    raise
+
+            except Exception as e:
+                logger.error(f"Unexpected Codex error: {type(e).__name__}: {e}")
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Codex call failed after all retries")
+
+    async def _parse_sse_stream(self, response: httpx.Response) -> str:
+        """
+        Parse Server-Sent Events (SSE) stream from Codex API.
+
+        Args:
+            response: HTTP response with SSE stream.
+
+        Returns:
+            Extracted text content from stream.
+        """
+        full_text = ""
+        event_type = None
+
+        async for line in response.aiter_lines():
+            if not line:
+                continue
+
+            # Track event type
+            if line.startswith("event: "):
+                event_type = line[7:]
+
+            # Parse data
+            elif line.startswith("data: "):
+                data_str = line[6:]
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    data = json.loads(data_str)
+
+                    # Extract content based on event type
+                    if event_type == "response.text.delta" and "delta" in data:
+                        full_text += data["delta"]
+                    elif event_type == "response.content_part.delta" and "delta" in data:
+                        full_text += data["delta"]
+                    # Check for item content
+                    elif "item" in data:
+                        item = data["item"]
+                        if "content" in item:
+                            content = item["content"]
+                            if isinstance(content, list):
+                                for part in content:
+                                    if isinstance(part, dict) and "text" in part:
+                                        full_text += part["text"]
+                            elif isinstance(content, str):
+                                full_text += content
+
+                except json.JSONDecodeError:
+                    # Skip malformed JSON events
+                    pass
+
+        return full_text
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make API call with tool calling support.
+
+        Parses Codex SSE stream to extract tool calls from response.output_item.done events.
+        Tools are converted from OpenAI format to Codex format (flat structure at top level).
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature.
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        start_time = time.time()
+
+        # Prepare system instructions
+        system_instruction = ""
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_instruction += ("\n\n" + content) if system_instruction else content
+            elif role == "tool":
+                # Handle tool results
+                user_messages.append(
+                    {
+                        "type": "message",
+                        "role": "user",
+                        "content": f"Tool result: {content}",
+                    }
+                )
+            else:
+                user_messages.append(
+                    {
+                        "type": "message",
+                        "role": role,
+                        "content": content,
+                    }
+                )
+
+        # Convert tools to Codex format
+        # Codex expects tools with type and name/description/parameters at top level
+        codex_tools = []
+        for tool in tools:
+            func = tool.get("function", {})
+            codex_tools.append(
+                {
+                    "type": "function",
+                    "name": func.get("name", ""),
+                    "description": func.get("description", ""),
+                    "parameters": func.get("parameters", {}),
+                }
+            )
+
+        # gpt-5.2-codex only supports "detailed" reasoning summary
+        reasoning_summary = "detailed" if "5.2" in self.model else self.reasoning_summary
+
+        payload = {
+            "model": self.model,
+            "instructions": system_instruction,
+            "input": user_messages,
+            "tools": codex_tools,
+            "tool_choice": tool_choice,
+            "parallel_tool_calls": True,
+            "reasoning": {"summary": reasoning_summary},
+            "store": False,
+            "stream": True,
+            "include": ["reasoning.encrypted_content"],
+            "prompt_cache_key": str(uuid.uuid4()),
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+            "OpenAI-Account-ID": self.account_id,
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+            "Origin": "https://chatgpt.com",
+        }
+
+        url = f"{self.base_url}/codex/responses"
+
+        # Debug logging for troubleshooting
+        logger.debug(f"Codex tool call request: url={url}, model={payload['model']}, tools={len(codex_tools)}")
+
+        try:
+            response = await self._client.post(url, json=payload, headers=headers, timeout=120.0)
+
+            # Log response details on error
+            if response.status_code != 200:
+                logger.error(f"Codex API error {response.status_code}: {response.text[:500]}")
+
+            response.raise_for_status()
+
+            # Parse SSE for tool calls and content
+            content, tool_calls = await self._parse_sse_tool_stream(response)
+
+            duration = time.time() - start_time
+            metrics = get_metrics_collector()
+            metrics.record_llm_call(
+                provider=self.provider,
+                model=self.model,
+                scope=scope,
+                duration=duration,
+                input_tokens=0,
+                output_tokens=0,
+                success=True,
+            )
+
+            return LLMToolCallResult(
+                content=content,
+                tool_calls=tool_calls,
+                finish_reason="tool_calls" if tool_calls else "stop",
+                input_tokens=0,
+                output_tokens=0,
+            )
+
+        except Exception as e:
+            logger.error(f"Codex tool call error: {e}")
+            raise
+
+    async def _parse_sse_tool_stream(self, response: httpx.Response) -> tuple[str | None, list[LLMToolCall]]:
+        """
+        Parse SSE stream for tool calls and content.
+
+        Returns:
+            Tuple of (content, tool_calls).
+        """
+        content = ""
+        tool_calls: list[LLMToolCall] = []
+        event_type = None
+
+        async for line in response.aiter_lines():
+            if not line:
+                continue
+
+            if line.startswith("event: "):
+                event_type = line[7:]
+
+            elif line.startswith("data: "):
+                data_str = line[6:]
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    data = json.loads(data_str)
+
+                    # Extract text content
+                    if event_type == "response.text.delta" and "delta" in data:
+                        content += data["delta"]
+
+                    # Extract completed tool calls from response.output_item.done
+                    elif event_type == "response.output_item.done":
+                        item = data.get("item", {})
+                        if item.get("type") == "function_call" and item.get("status") == "completed":
+                            tool_name = item.get("name", "")
+                            arguments_str = item.get("arguments", "{}")
+                            call_id = item.get("call_id", "")
+
+                            try:
+                                arguments = json.loads(arguments_str)
+                            except json.JSONDecodeError:
+                                logger.warning(f"Failed to parse tool arguments: {arguments_str}")
+                                arguments = {}
+
+                            tool_calls.append(
+                                LLMToolCall(
+                                    id=call_id,
+                                    name=tool_name,
+                                    arguments=arguments,
+                                )
+                            )
+
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Failed to parse SSE data: {e}, data_str: {data_str[:200]}")
+
+        return content if content else None, tool_calls
+
+    async def cleanup(self) -> None:
+        """Clean up HTTP client."""
+        await self._client.aclose()
@@ -0,0 +1,502 @@
+"""
+Google Gemini/VertexAI LLM provider.
+
+This provider supports both:
+1. Gemini API (api.generativeai.google.com) with API key authentication
+2. Vertex AI with service account or Application Default Credentials (ADC)
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+from typing import Any
+
+from google import genai
+from google.genai import errors as genai_errors
+from google.genai import types as genai_types
+
+from hindsight_api.engine.llm_interface import LLMInterface, OutputTooLongError
+from hindsight_api.engine.response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+from hindsight_api.metrics import get_metrics_collector
+
+logger = logging.getLogger(__name__)
+
+# Vertex AI imports (optional)
+try:
+    import google.auth
+    from google.oauth2 import service_account
+
+    VERTEXAI_AVAILABLE = True
+except ImportError:
+    VERTEXAI_AVAILABLE = False
+
+
+class GeminiLLM(LLMInterface):
+    """
+    LLM provider for Google Gemini and Vertex AI.
+
+    Supports:
+    - Gemini API: provider="gemini", requires api_key
+    - Vertex AI: provider="vertexai", requires project_id and region, uses ADC or service account
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        **kwargs: Any,
+    ):
+        """Initialize Gemini/VertexAI LLM provider."""
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        self._client = None
+        self._is_vertexai = self.provider == "vertexai"
+
+        if self._is_vertexai:
+            self._init_vertexai(**kwargs)
+        else:
+            self._init_gemini()
+
+    def _init_gemini(self) -> None:
+        """Initialize Gemini API client."""
+        if not self.api_key:
+            raise ValueError("Gemini provider requires api_key")
+
+        self._client = genai.Client(api_key=self.api_key)
+        logger.info(f"Gemini API: model={self.model}")
+
+    def _init_vertexai(self, **kwargs: Any) -> None:
+        """Initialize Vertex AI client with project, region, and credentials."""
+        # Extract Vertex AI config from kwargs
+        project_id = kwargs.get("vertexai_project_id")
+        region = kwargs.get("vertexai_region", "us-central1")
+        service_account_key = kwargs.get("vertexai_service_account_key")
+        credentials = kwargs.get("vertexai_credentials")  # Pre-loaded credentials object
+
+        if not project_id:
+            raise ValueError(
+                "HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID is required for Vertex AI provider. "
+                "Set it to your GCP project ID."
+            )
+
+        auth_method = "ADC"
+
+        # Use pre-loaded credentials if provided (passed from LLMProvider)
+        if credentials is not None:
+            auth_method = "service_account"
+        # Otherwise, load explicit service account credentials if path provided
+        elif service_account_key:
+            if not VERTEXAI_AVAILABLE:
+                raise ValueError(
+                    "Vertex AI service account auth requires 'google-auth' package. "
+                    "Install with: pip install google-auth"
+                )
+            credentials = service_account.Credentials.from_service_account_file(
+                service_account_key,
+                scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            )
+            auth_method = "service_account"
+            logger.info(f"Vertex AI: Using service account key: {service_account_key}")
+
+        # Strip google/ prefix from model name — native SDK uses bare names
+        # e.g. "google/gemini-2.0-flash-lite-001" -> "gemini-2.0-flash-lite-001"
+        if self.model.startswith("google/"):
+            self.model = self.model[len("google/") :]
+
+        # Create Vertex AI client
+        client_kwargs: dict[str, Any] = {
+            "vertexai": True,
+            "project": project_id,
+            "location": region,
+        }
+        if credentials is not None:
+            client_kwargs["credentials"] = credentials
+
+        self._client = genai.Client(**client_kwargs)
+
+        logger.info(f"Vertex AI: project={project_id}, region={region}, model={self.model}, auth={auth_method}")
+
+    async def verify_connection(self) -> None:
+        """
+        Verify that the Gemini/VertexAI provider is configured correctly.
+
+        Raises:
+            RuntimeError: If the connection test fails.
+        """
+        try:
+            logger.info(f"Verifying {self.provider.upper()}: model={self.model}...")
+            await self.call(
+                messages=[{"role": "user", "content": "Say 'ok'"}],
+                max_completion_tokens=100,
+                max_retries=2,
+                initial_backoff=0.5,
+                max_backoff=2.0,
+            )
+            logger.info(f"{self.provider.upper()} connection verified successfully")
+        except Exception as e:
+            raise RuntimeError(f"Failed to verify {self.provider.upper()} connection: {e}") from e
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make a Gemini/VertexAI API call with retry logic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Maximum tokens in response (not supported by Gemini).
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Use strict JSON schema enforcement (not supported by Gemini).
+            return_usage: If True, return tuple (result, TokenUsage).
+
+        Returns:
+            If return_usage=False: Parsed response if response_format provided, else text.
+            If return_usage=True: Tuple of (result, TokenUsage).
+        """
+        start_time = time.time()
+
+        # Convert OpenAI-style messages to Gemini format
+        system_instruction = None
+        gemini_contents = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                if system_instruction:
+                    system_instruction += "\n\n" + content
+                else:
+                    system_instruction = content
+            elif role == "assistant":
+                gemini_contents.append(genai_types.Content(role="model", parts=[genai_types.Part(text=content)]))
+            else:
+                gemini_contents.append(genai_types.Content(role="user", parts=[genai_types.Part(text=content)]))
+
+        # Add JSON schema instruction if response_format is provided
+        if response_format is not None and hasattr(response_format, "model_json_schema"):
+            schema = response_format.model_json_schema()
+            schema_msg = f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}"
+            if system_instruction:
+                system_instruction += schema_msg
+            else:
+                system_instruction = schema_msg
+
+        # Build generation config
+        config_kwargs: dict[str, Any] = {}
+        if system_instruction:
+            config_kwargs["system_instruction"] = system_instruction
+        if response_format is not None:
+            config_kwargs["response_mime_type"] = "application/json"
+            config_kwargs["response_schema"] = response_format
+        if temperature is not None:
+            config_kwargs["temperature"] = temperature
+
+        generation_config = genai_types.GenerateContentConfig(**config_kwargs) if config_kwargs else None
+
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.aio.models.generate_content(
+                    model=self.model,
+                    contents=gemini_contents,
+                    config=generation_config,
+                )
+
+                content = response.text
+
+                # Handle empty response
+                if content is None:
+                    block_reason = None
+                    if hasattr(response, "candidates") and response.candidates:
+                        candidate = response.candidates[0]
+                        if hasattr(candidate, "finish_reason"):
+                            block_reason = candidate.finish_reason
+
+                    if attempt < max_retries:
+                        logger.warning(f"Gemini returned empty response (reason: {block_reason}), retrying...")
+                        backoff = min(initial_backoff * (2**attempt), max_backoff)
+                        await asyncio.sleep(backoff)
+                        continue
+                    else:
+                        raise RuntimeError(f"Gemini returned empty response after {max_retries + 1} attempts")
+
+                # Parse structured output if requested
+                if response_format is not None:
+                    json_data = json.loads(content)
+                    if skip_validation:
+                        result = json_data
+                    else:
+                        result = response_format.model_validate(json_data)
+                else:
+                    result = content
+
+                # Extract token usage
+                input_tokens = 0
+                output_tokens = 0
+                if hasattr(response, "usage_metadata") and response.usage_metadata:
+                    usage = response.usage_metadata
+                    input_tokens = usage.prompt_token_count or 0
+                    output_tokens = usage.candidates_token_count or 0
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0 and input_tokens > 0:
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, "
+                        f"input_tokens={input_tokens}, output_tokens={output_tokens}, "
+                        f"time={duration:.3f}s"
+                    )
+
+                if return_usage:
+                    token_usage = TokenUsage(
+                        input_tokens=input_tokens,
+                        output_tokens=output_tokens,
+                        total_tokens=input_tokens + output_tokens,
+                    )
+                    return result, token_usage
+                return result
+
+            except json.JSONDecodeError as e:
+                last_exception = e
+                if attempt < max_retries:
+                    logger.warning("Gemini returned invalid JSON, retrying...")
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Gemini returned invalid JSON after {max_retries + 1} attempts")
+                    raise
+
+            except genai_errors.APIError as e:
+                # Fast fail on auth errors - these won't recover with retries
+                if e.code in (401, 403):
+                    logger.error(f"Gemini auth error (HTTP {e.code}), not retrying: {str(e)}")
+                    raise
+
+                # Retry on retryable errors (rate limits, server errors, client errors)
+                if e.code in (400, 429, 500, 502, 503, 504) or (e.code and e.code >= 500):
+                    last_exception = e
+                    if attempt < max_retries:
+                        backoff = min(initial_backoff * (2**attempt), max_backoff)
+                        jitter = backoff * 0.2 * (2 * (time.time() % 1) - 1)
+                        await asyncio.sleep(backoff + jitter)
+                    else:
+                        logger.error(f"Gemini API error after {max_retries + 1} attempts: {str(e)}")
+                        raise
+                else:
+                    logger.error(f"Gemini API error: {type(e).__name__}: {str(e)}")
+                    raise
+
+            except Exception as e:
+                logger.error(f"Unexpected error during Gemini call: {type(e).__name__}: {str(e)}")
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Gemini call failed after all retries")
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make a Gemini/VertexAI API call with tool/function calling support.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens (not supported by Gemini).
+            temperature: Sampling temperature.
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools (Gemini uses "auto" only).
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        start_time = time.time()
+
+        # Convert tools to Gemini format
+        gemini_tools = []
+        for tool in tools:
+            func = tool.get("function", {})
+            gemini_tools.append(
+                genai_types.Tool(
+                    function_declarations=[
+                        genai_types.FunctionDeclaration(
+                            name=func.get("name", ""),
+                            description=func.get("description", ""),
+                            parameters=func.get("parameters"),
+                        )
+                    ]
+                )
+            )
+
+        # Convert messages
+        system_instruction = None
+        gemini_contents = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_instruction = (system_instruction + "\n\n" + content) if system_instruction else content
+            elif role == "tool":
+                # Gemini uses function_response
+                gemini_contents.append(
+                    genai_types.Content(
+                        role="user",
+                        parts=[
+                            genai_types.Part(
+                                function_response=genai_types.FunctionResponse(
+                                    name=msg.get("name", ""),
+                                    response={"result": content},
+                                )
+                            )
+                        ],
+                    )
+                )
+            elif role == "assistant":
+                gemini_contents.append(genai_types.Content(role="model", parts=[genai_types.Part(text=content)]))
+            else:
+                gemini_contents.append(genai_types.Content(role="user", parts=[genai_types.Part(text=content)]))
+
+        config_kwargs: dict[str, Any] = {"tools": gemini_tools}
+        if system_instruction:
+            config_kwargs["system_instruction"] = system_instruction
+        if temperature is not None:
+            config_kwargs["temperature"] = temperature
+
+        config = genai_types.GenerateContentConfig(**config_kwargs)
+
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.aio.models.generate_content(
+                    model=self.model,
+                    contents=gemini_contents,
+                    config=config,
+                )
+
+                # Extract content and tool calls
+                content = None
+                tool_calls: list[LLMToolCall] = []
+
+                if response.candidates and response.candidates[0].content:
+                    parts = response.candidates[0].content.parts
+                    if parts:
+                        for part in parts:
+                            if hasattr(part, "text") and part.text:
+                                content = part.text
+                            if hasattr(part, "function_call") and part.function_call:
+                                fc = part.function_call
+                                tool_calls.append(
+                                    LLMToolCall(
+                                        id=f"gemini_{len(tool_calls)}",
+                                        name=fc.name,
+                                        arguments=dict(fc.args) if fc.args else {},
+                                    )
+                                )
+
+                finish_reason = "tool_calls" if tool_calls else "stop"
+
+                # Extract token usage
+                input_tokens = 0
+                output_tokens = 0
+                if response.usage_metadata:
+                    input_tokens = response.usage_metadata.prompt_token_count or 0
+                    output_tokens = response.usage_metadata.candidates_token_count or 0
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                return LLMToolCallResult(
+                    content=content,
+                    tool_calls=tool_calls,
+                    finish_reason=finish_reason,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                )
+
+            except genai_errors.APIError as e:
+                # Fast fail on auth errors
+                if e.code in (401, 403):
+                    logger.error(f"Gemini auth error (HTTP {e.code}), not retrying: {str(e)}")
+                    raise
+
+                # Retry on retryable errors
+                last_exception = e
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    await asyncio.sleep(backoff)
+                    continue
+                raise
+
+            except Exception as e:
+                logger.error(f"Unexpected error during Gemini tool call: {type(e).__name__}: {str(e)}")
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Gemini tool call failed")
+
+    async def cleanup(self) -> None:
+        """Clean up resources (close connections, etc.)."""
+        # Gemini client doesn't require explicit cleanup
+        pass
@@ -0,0 +1,254 @@
+"""
+Mock LLM provider for testing.
+
+This provider allows tests to record LLM calls and return configurable mock responses
+without making actual API calls to external LLM services.
+"""
+
+import logging
+from typing import Any
+
+from ..llm_interface import LLMInterface
+from ..response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+
+logger = logging.getLogger(__name__)
+
+
+class MockLLM(LLMInterface):
+    """
+    Mock LLM provider for testing.
+
+    This provider records all calls and returns configurable mock responses,
+    enabling tests to verify LLM interactions without making real API calls.
+
+    Example:
+        # Create mock provider
+        mock_llm = MockLLM(provider="mock", api_key="", base_url="", model="mock-model")
+
+        # Set mock response
+        mock_llm.set_mock_response({"answer": "test"})
+
+        # Make calls
+        result = await mock_llm.call(
+            messages=[{"role": "user", "content": "test"}],
+            response_format=MyResponseModel
+        )
+
+        # Verify calls
+        calls = mock_llm.get_mock_calls()
+        assert len(calls) == 1
+        assert calls[0]["scope"] == "memory"
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        **kwargs: Any,
+    ):
+        """
+        Initialize mock LLM provider.
+
+        Args:
+            provider: Provider name (should be "mock").
+            api_key: Not used for mock provider.
+            base_url: Not used for mock provider.
+            model: Model name for tracking.
+            reasoning_effort: Not used for mock provider.
+            **kwargs: Additional parameters (not used).
+        """
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        # Storage for test verification
+        self._mock_calls: list[dict] = []
+        self._mock_response: Any = None
+        self._mock_exception: Exception | None = None
+
+    async def verify_connection(self) -> None:
+        """
+        Verify mock provider (always succeeds).
+
+        Mock provider doesn't need connection verification since it doesn't
+        make real API calls.
+        """
+        logger.debug("Mock LLM: connection verification (always succeeds)")
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make a mock LLM API call.
+
+        Records the call for test verification and returns the configured mock response.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Not used in mock.
+            temperature: Not used in mock.
+            scope: Scope identifier for tracking.
+            max_retries: Not used in mock.
+            initial_backoff: Not used in mock.
+            max_backoff: Not used in mock.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Not used in mock.
+            return_usage: If True, return tuple (result, TokenUsage) instead of just result.
+
+        Returns:
+            If return_usage=False: Parsed response if response_format is provided, otherwise text content.
+            If return_usage=True: Tuple of (result, TokenUsage) with mock token counts.
+        """
+        # Record the call for test verification
+        call_record = {
+            "provider": self.provider,
+            "model": self.model,
+            "messages": messages,
+            "response_format": response_format.__name__
+            if response_format and hasattr(response_format, "__name__")
+            else str(response_format),
+            "scope": scope,
+        }
+        self._mock_calls.append(call_record)
+        logger.debug(f"Mock LLM call recorded: scope={scope}, model={self.model}")
+
+        # Raise mock exception if configured
+        if self._mock_exception is not None:
+            raise self._mock_exception
+
+        # Return mock response
+        if self._mock_response is not None:
+            result = self._mock_response
+        elif response_format is not None:
+            # Try to create a minimal valid instance of the response format
+            try:
+                # For Pydantic models, try to create with minimal valid data
+                result = {"mock": True}
+            except Exception:
+                result = {"mock": True}
+        else:
+            result = "mock response"
+
+        if return_usage:
+            token_usage = TokenUsage(input_tokens=10, output_tokens=5, total_tokens=15)
+            return result, token_usage
+        return result
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make a mock LLM API call with tool/function calling support.
+
+        Records the call for test verification and returns the configured mock response.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Not used in mock.
+            temperature: Not used in mock.
+            scope: Scope identifier for tracking.
+            max_retries: Not used in mock.
+            initial_backoff: Not used in mock.
+            max_backoff: Not used in mock.
+            tool_choice: Not used in mock.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        # Record the call for test verification
+        call_record = {
+            "provider": self.provider,
+            "model": self.model,
+            "messages": messages,
+            "tools": [t.get("function", {}).get("name") for t in tools],
+            "scope": scope,
+        }
+        self._mock_calls.append(call_record)
+
+        # Raise mock exception if configured
+        if self._mock_exception is not None:
+            raise self._mock_exception
+
+        if self._mock_response is not None:
+            if isinstance(self._mock_response, LLMToolCallResult):
+                return self._mock_response
+            # Allow setting just tool calls as a list
+            if isinstance(self._mock_response, list):
+                return LLMToolCallResult(
+                    tool_calls=[
+                        LLMToolCall(id=f"mock_{i}", name=tc["name"], arguments=tc.get("arguments", {}))
+                        for i, tc in enumerate(self._mock_response)
+                    ],
+                    finish_reason="tool_calls",
+                )
+
+        return LLMToolCallResult(content="mock response", finish_reason="stop")
+
+    async def cleanup(self) -> None:
+        """Clean up resources (no-op for mock provider)."""
+        pass
+
+    def set_mock_response(self, response: Any) -> None:
+        """
+        Set the response to return from mock calls.
+
+        Args:
+            response: The response to return. Can be:
+                - A dict/Pydantic model for regular calls
+                - An LLMToolCallResult for tool calls
+                - A list of tool call dicts for tool calls
+                - Any other value to return as-is
+        """
+        self._mock_response = response
+
+    def set_mock_exception(self, exception: Exception) -> None:
+        """
+        Set an exception to raise from mock calls.
+
+        Args:
+            exception: The exception to raise on the next call.
+                      After raising, the exception is cleared.
+        """
+        self._mock_exception = exception
+
+    def get_mock_calls(self) -> list[dict]:
+        """
+        Get the list of recorded mock calls.
+
+        Returns:
+            List of call records, each containing:
+                - provider: Provider name
+                - model: Model name
+                - messages: Messages sent
+                - response_format/tools: Format or tools used
+                - scope: Call scope
+        """
+        return self._mock_calls
+
+    def clear_mock_calls(self) -> None:
+        """Clear the recorded mock calls and any set exception."""
+        self._mock_calls = []
+        self._mock_exception = None
@@ -0,0 +1,745 @@
+"""
+OpenAI-compatible LLM provider supporting OpenAI, Groq, Ollama, and LMStudio.
+
+This provider handles all OpenAI API-compatible models including:
+- OpenAI: GPT-4, GPT-4o, GPT-5, o1, o3 (reasoning models)
+- Groq: Fast inference with seed control and service tiers
+- Ollama: Local models with native streaming API support
+- LMStudio: Local models with OpenAI-compatible API
+
+Features:
+- Reasoning models with extended thinking (o1, o3, GPT-5 families)
+- Strict JSON schema enforcement (OpenAI)
+- Provider-specific parameters (Groq seed, service tier)
+- Native Ollama streaming for better structured output
+- Automatic token limit handling per model family
+"""
+
+import asyncio
+import json
+import logging
+import os
+import re
+import time
+from typing import Any
+
+import httpx
+from openai import APIConnectionError, APIStatusError, AsyncOpenAI, LengthFinishReasonError
+
+from hindsight_api.config import DEFAULT_LLM_TIMEOUT, ENV_LLM_TIMEOUT
+from hindsight_api.engine.llm_interface import LLMInterface, OutputTooLongError
+from hindsight_api.engine.response_models import LLMToolCall, LLMToolCallResult, TokenUsage
+from hindsight_api.metrics import get_metrics_collector
+
+logger = logging.getLogger(__name__)
+
+# Seed applied to every Groq request for deterministic behavior
+DEFAULT_LLM_SEED = 4242
+
+
+class OpenAICompatibleLLM(LLMInterface):
+    """
+    LLM provider for OpenAI-compatible APIs.
+
+    Supports:
+    - OpenAI: Standard models (GPT-4, GPT-4o) and reasoning models (o1, o3, GPT-5)
+    - Groq: Fast inference with seed control and service tiers
+    - Ollama: Local models with native streaming API for better structured output
+    - LMStudio: Local models with OpenAI-compatible API
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        reasoning_effort: str = "low",
+        timeout: float | None = None,
+        groq_service_tier: str | None = None,
+        **kwargs: Any,
+    ):
+        """
+        Initialize OpenAI-compatible LLM provider.
+
+        Args:
+            provider: Provider name ("openai", "groq", "ollama", "lmstudio").
+            api_key: API key (optional for ollama/lmstudio).
+            base_url: Base URL for the API (uses defaults for groq/ollama/lmstudio if empty).
+            model: Model name.
+            reasoning_effort: Reasoning effort level for supported models ("low", "medium", "high").
+            timeout: Request timeout in seconds (uses env var or 300s default).
+            groq_service_tier: Groq service tier ("on_demand", "flex", "auto").
+            **kwargs: Additional provider-specific parameters.
+        """
+        super().__init__(provider, api_key, base_url, model, reasoning_effort, **kwargs)
+
+        # Validate provider
+        valid_providers = ["openai", "groq", "ollama", "lmstudio"]
+        if self.provider not in valid_providers:
+            raise ValueError(f"OpenAICompatibleLLM only supports: {', '.join(valid_providers)}. Got: {self.provider}")
+
+        # Set default base URLs
+        if not self.base_url:
+            if self.provider == "groq":
+                self.base_url = "https://api.groq.com/openai/v1"
+            elif self.provider == "ollama":
+                self.base_url = "http://localhost:11434/v1"
+            elif self.provider == "lmstudio":
+                self.base_url = "http://localhost:1234/v1"
+
+        # For ollama/lmstudio, use dummy key if not provided
+        if self.provider in ("ollama", "lmstudio") and not self.api_key:
+            self.api_key = "local"
+
+        # Validate API key for cloud providers
+        if self.provider in ("openai", "groq") and not self.api_key:
+            raise ValueError(f"API key is required for {self.provider}")
+
+        # Groq service tier configuration
+        self.groq_service_tier = groq_service_tier or os.getenv("HINDSIGHT_API_LLM_GROQ_SERVICE_TIER", "auto")
+
+        # Get timeout config
+        self.timeout = timeout or float(os.getenv(ENV_LLM_TIMEOUT, str(DEFAULT_LLM_TIMEOUT)))
+
+        # Create OpenAI client
+        client_kwargs: dict[str, Any] = {"api_key": self.api_key, "max_retries": 0}
+        if self.base_url:
+            client_kwargs["base_url"] = self.base_url
+        if self.timeout:
+            client_kwargs["timeout"] = self.timeout
+
+        self._client = AsyncOpenAI(**client_kwargs)
+        logger.info(
+            f"OpenAI-compatible client initialized: provider={self.provider}, model={self.model}, "
+            f"base_url={self.base_url or 'default'}"
+        )
+
+    async def verify_connection(self) -> None:
+        """
+        Verify that the provider is configured correctly by making a simple test call.
+
+        Raises:
+            RuntimeError: If the connection test fails.
+        """
+        try:
+            logger.info(f"Verifying connection: {self.provider}/{self.model}")
+            await self.call(
+                messages=[{"role": "user", "content": "Say 'ok'"}],
+                max_completion_tokens=100,
+                max_retries=2,
+                initial_backoff=0.5,
+                max_backoff=2.0,
+            )
+            logger.info(f"Connection verified: {self.provider}/{self.model}")
+        except Exception as e:
+            raise RuntimeError(f"Connection verification failed for {self.provider}/{self.model}: {e}") from e
+
+    def _supports_reasoning_model(self) -> bool:
+        """Check if the current model is a reasoning model (o1, o3, GPT-5, DeepSeek)."""
+        model_lower = self.model.lower()
+        return any(x in model_lower for x in ["gpt-5", "o1", "o3", "deepseek"])
+
+    def _get_max_reasoning_tokens(self) -> int | None:
+        """Get max reasoning tokens for reasoning models."""
+        model_lower = self.model.lower()
+
+        # GPT-4 and GPT-4.1 models have different caps
+        if any(x in model_lower for x in ["gpt-4.1", "gpt-4-"]):
+            return 32000
+        elif "gpt-4o" in model_lower:
+            return 16384
+
+        return None
+
+    async def call(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any | None = None,
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "memory",
+        max_retries: int = 10,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 60.0,
+        skip_validation: bool = False,
+        strict_schema: bool = False,
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Make an LLM API call with retry logic.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            response_format: Optional Pydantic model for structured output.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            skip_validation: Return raw JSON without Pydantic validation.
+            strict_schema: Use strict JSON schema enforcement (OpenAI only).
+            return_usage: If True, return tuple (result, TokenUsage) instead of just result.
+
+        Returns:
+            If return_usage=False: Parsed response if response_format is provided, otherwise text content.
+            If return_usage=True: Tuple of (result, TokenUsage) with token counts.
+
+        Raises:
+            OutputTooLongError: If output exceeds token limits.
+            Exception: Re-raises API errors after retries exhausted.
+        """
+        # Handle Ollama with native API for structured output (better schema enforcement)
+        if self.provider == "ollama" and response_format is not None:
+            return await self._call_ollama_native(
+                messages=messages,
+                response_format=response_format,
+                max_completion_tokens=max_completion_tokens,
+                temperature=temperature,
+                max_retries=max_retries,
+                initial_backoff=initial_backoff,
+                max_backoff=max_backoff,
+                skip_validation=skip_validation,
+                scope=scope,
+                return_usage=return_usage,
+            )
+
+        start_time = time.time()
+
+        # Build call parameters
+        call_params: dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+        }
+
+        # Check if model supports reasoning parameter
+        is_reasoning_model = self._supports_reasoning_model()
+
+        # Apply model-specific token limits
+        if max_completion_tokens is not None:
+            max_tokens_cap = self._get_max_reasoning_tokens()
+            if max_tokens_cap and max_completion_tokens > max_tokens_cap:
+                max_completion_tokens = max_tokens_cap
+            # For reasoning models, enforce minimum to ensure space for reasoning + output
+            if is_reasoning_model and max_completion_tokens < 16000:
+                max_completion_tokens = 16000
+            call_params["max_completion_tokens"] = max_completion_tokens
+
+        # Temperature - reasoning models don't support custom temperature
+        if temperature is not None and not is_reasoning_model:
+            call_params["temperature"] = temperature
+
+        # Set reasoning_effort for reasoning models
+        if is_reasoning_model:
+            call_params["reasoning_effort"] = self.reasoning_effort
+
+        # Provider-specific parameters
+        if self.provider == "groq":
+            call_params["seed"] = DEFAULT_LLM_SEED
+            extra_body: dict[str, Any] = {}
+            # Add service_tier if configured
+            if self.groq_service_tier:
+                extra_body["service_tier"] = self.groq_service_tier
+            # Add reasoning parameters for reasoning models
+            if is_reasoning_model:
+                extra_body["include_reasoning"] = False
+            if extra_body:
+                call_params["extra_body"] = extra_body
+
+        # Prepare response format ONCE before retry loop
+        if response_format is not None:
+            schema = None
+            if hasattr(response_format, "model_json_schema"):
+                schema = response_format.model_json_schema()
+
+            if strict_schema and schema is not None:
+                # Use OpenAI's strict JSON schema enforcement
+                call_params["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "strict": True,
+                        "schema": schema,
+                    },
+                }
+            else:
+                # Soft enforcement: add schema to prompt and use json_object mode
+                if schema is not None:
+                    schema_msg = (
+                        f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}"
+                    )
+
+                    if call_params["messages"] and call_params["messages"][0].get("role") == "system":
+                        first_msg = call_params["messages"][0]
+                        if isinstance(first_msg, dict) and isinstance(first_msg.get("content"), str):
+                            first_msg["content"] += schema_msg
+                    elif call_params["messages"]:
+                        first_msg = call_params["messages"][0]
+                        if isinstance(first_msg, dict) and isinstance(first_msg.get("content"), str):
+                            first_msg["content"] = schema_msg + "\n\n" + first_msg["content"]
+                if self.provider not in ("lmstudio", "ollama"):
+                    # LM Studio and Ollama don't support json_object response format reliably
+                    call_params["response_format"] = {"type": "json_object"}
+
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                if response_format is not None:
+                    response = await self._client.chat.completions.create(**call_params)
+
+                    content = response.choices[0].message.content
+
+                    # Strip reasoning model thinking tags
+                    # Supports: <think>, <thinking>, <reasoning>, |startthink|/|endthink|
+                    if content:
+                        original_len = len(content)
+                        content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL)
+                        content = re.sub(r"<thinking>.*?</thinking>", "", content, flags=re.DOTALL)
+                        content = re.sub(r"<reasoning>.*?</reasoning>", "", content, flags=re.DOTALL)
+                        content = re.sub(r"\|startthink\|.*?\|endthink\|", "", content, flags=re.DOTALL)
+                        content = content.strip()
+                        if len(content) < original_len:
+                            logger.debug(f"Stripped {original_len - len(content)} chars of reasoning tokens")
+
+                    # For local models, they may wrap JSON in markdown code blocks
+                    if self.provider in ("lmstudio", "ollama"):
+                        clean_content = content
+                        if "```json" in content:
+                            clean_content = content.split("```json")[1].split("```")[0].strip()
+                        elif "```" in content:
+                            clean_content = content.split("```")[1].split("```")[0].strip()
+                        try:
+                            json_data = json.loads(clean_content)
+                        except json.JSONDecodeError:
+                            # Fallback to parsing raw content
+                            json_data = json.loads(content)
+                    else:
+                        # Log raw LLM response for debugging JSON parse issues
+                        try:
+                            json_data = json.loads(content)
+                        except json.JSONDecodeError as json_err:
+                            # Truncate content for logging
+                            content_preview = content[:500] if content else "<empty>"
+                            if content and len(content) > 700:
+                                content_preview = f"{content[:500]}...TRUNCATED...{content[-200:]}"
+                            logger.warning(
+                                f"JSON parse error from LLM response (attempt {attempt + 1}/{max_retries + 1}): {json_err}\n"
+                                f"  Model: {self.provider}/{self.model}\n"
+                                f"  Content length: {len(content) if content else 0} chars\n"
+                                f"  Content preview: {content_preview!r}\n"
+                                f"  Finish reason: {response.choices[0].finish_reason if response.choices else 'unknown'}"
+                            )
+                            # Retry on JSON parse errors
+                            if attempt < max_retries:
+                                backoff = min(initial_backoff * (2**attempt), max_backoff)
+                                await asyncio.sleep(backoff)
+                                last_exception = json_err
+                                continue
+                            else:
+                                logger.error(f"JSON parse error after {max_retries + 1} attempts, giving up")
+                                raise
+
+                    if skip_validation:
+                        result = json_data
+                    else:
+                        result = response_format.model_validate(json_data)
+                else:
+                    response = await self._client.chat.completions.create(**call_params)
+                    result = response.choices[0].message.content
+
+                # Record token usage metrics
+                duration = time.time() - start_time
+                usage = response.usage
+                input_tokens = usage.prompt_tokens or 0 if usage else 0
+                output_tokens = usage.completion_tokens or 0 if usage else 0
+                total_tokens = usage.total_tokens or 0 if usage else 0
+
+                # Record LLM metrics
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0 and usage:
+                    ratio = max(1, output_tokens) / max(1, input_tokens)
+                    cached_tokens = 0
+                    if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details:
+                        cached_tokens = getattr(usage.prompt_tokens_details, "cached_tokens", 0) or 0
+                    cache_info = f", cached_tokens={cached_tokens}" if cached_tokens > 0 else ""
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, "
+                        f"input_tokens={input_tokens}, output_tokens={output_tokens}, "
+                        f"total_tokens={total_tokens}{cache_info}, time={duration:.3f}s, ratio out/in={ratio:.2f}"
+                    )
+
+                if return_usage:
+                    token_usage = TokenUsage(
+                        input_tokens=input_tokens,
+                        output_tokens=output_tokens,
+                        total_tokens=total_tokens,
+                    )
+                    return result, token_usage
+                return result
+
+            except LengthFinishReasonError as e:
+                logger.warning(f"LLM output exceeded token limits: {str(e)}")
+                raise OutputTooLongError(
+                    "LLM output exceeded token limits. Input may need to be split into smaller chunks."
+                ) from e
+
+            except APIConnectionError as e:
+                last_exception = e
+                status_code = getattr(e, "status_code", None) or getattr(
+                    getattr(e, "response", None), "status_code", None
+                )
+                logger.warning(f"APIConnectionError (HTTP {status_code}), attempt {attempt + 1}: {str(e)[:200]}")
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Connection error after {max_retries + 1} attempts: {str(e)}")
+                    raise
+
+            except APIStatusError as e:
+                # Fast fail only on 401 (unauthorized) and 403 (forbidden)
+                if e.status_code in (401, 403):
+                    logger.error(f"Auth error (HTTP {e.status_code}), not retrying: {str(e)}")
+                    raise
+
+                # Handle tool_use_failed error - model outputted in tool call format
+                if e.status_code == 400 and response_format is not None:
+                    try:
+                        error_body = e.body if hasattr(e, "body") else {}
+                        if isinstance(error_body, dict):
+                            error_info: dict[str, Any] = error_body.get("error") or {}
+                            if error_info.get("code") == "tool_use_failed":
+                                failed_gen = error_info.get("failed_generation", "")
+                                if failed_gen:
+                                    # Parse tool call format and convert to expected format
+                                    tool_call = json.loads(failed_gen)
+                                    tool_name = tool_call.get("name", "")
+                                    tool_args = tool_call.get("arguments", {})
+                                    converted = {"actions": [{"tool": tool_name, **tool_args}]}
+                                    if skip_validation:
+                                        result = converted
+                                    else:
+                                        result = response_format.model_validate(converted)
+
+                                    # Record metrics
+                                    duration = time.time() - start_time
+                                    metrics = get_metrics_collector()
+                                    metrics.record_llm_call(
+                                        provider=self.provider,
+                                        model=self.model,
+                                        scope=scope,
+                                        duration=duration,
+                                        input_tokens=0,
+                                        output_tokens=0,
+                                        success=True,
+                                    )
+                                    if return_usage:
+                                        return result, TokenUsage(input_tokens=0, output_tokens=0, total_tokens=0)
+                                    return result
+                    except (json.JSONDecodeError, KeyError, TypeError):
+                        pass  # Failed to parse tool_use_failed, continue with normal retry
+
+                last_exception = e
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    jitter = backoff * 0.2 * (2 * (time.time() % 1) - 1)
+                    sleep_time = backoff + jitter
+                    await asyncio.sleep(sleep_time)
+                else:
+                    logger.error(f"API error after {max_retries + 1} attempts: {str(e)}")
+                    raise
+
+            except Exception:
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("LLM call failed after all retries with no exception captured")
+
+    async def call_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        max_completion_tokens: int | None = None,
+        temperature: float | None = None,
+        scope: str = "tools",
+        max_retries: int = 5,
+        initial_backoff: float = 1.0,
+        max_backoff: float = 30.0,
+        tool_choice: str | dict[str, Any] = "auto",
+    ) -> LLMToolCallResult:
+        """
+        Make an LLM API call with tool/function calling support.
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature (0.0-2.0).
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
+        """
+        start_time = time.time()
+
+        # Build call parameters
+        call_params: dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+            "tools": tools,
+            "tool_choice": tool_choice,
+        }
+
+        if max_completion_tokens is not None:
+            call_params["max_completion_tokens"] = max_completion_tokens
+        if temperature is not None:
+            call_params["temperature"] = temperature
+
+        # Provider-specific parameters
+        if self.provider == "groq":
+            call_params["seed"] = DEFAULT_LLM_SEED
+
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = await self._client.chat.completions.create(**call_params)
+
+                message = response.choices[0].message
+                finish_reason = response.choices[0].finish_reason
+
+                # Extract tool calls if present
+                tool_calls: list[LLMToolCall] = []
+                if message.tool_calls:
+                    for tc in message.tool_calls:
+                        try:
+                            args = json.loads(tc.function.arguments) if tc.function.arguments else {}
+                        except json.JSONDecodeError:
+                            args = {"_raw": tc.function.arguments}
+                        tool_calls.append(LLMToolCall(id=tc.id, name=tc.function.name, arguments=args))
+
+                content = message.content
+
+                # Record metrics
+                duration = time.time() - start_time
+                usage = response.usage
+                input_tokens = usage.prompt_tokens or 0 if usage else 0
+                output_tokens = usage.completion_tokens or 0 if usage else 0
+
+                metrics = get_metrics_collector()
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    success=True,
+                )
+
+                return LLMToolCallResult(
+                    content=content,
+                    tool_calls=tool_calls,
+                    finish_reason=finish_reason,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                )
+
+            except APIConnectionError as e:
+                last_exception = e
+                if attempt < max_retries:
+                    await asyncio.sleep(min(initial_backoff * (2**attempt), max_backoff))
+                    continue
+                raise
+
+            except APIStatusError as e:
+                if e.status_code in (401, 403):
+                    raise
+                last_exception = e
+                if attempt < max_retries:
+                    await asyncio.sleep(min(initial_backoff * (2**attempt), max_backoff))
+                    continue
+                raise
+
+            except Exception:
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Tool call failed after all retries")
+
+    async def _call_ollama_native(
+        self,
+        messages: list[dict[str, str]],
+        response_format: Any,
+        max_completion_tokens: int | None,
+        temperature: float | None,
+        max_retries: int,
+        initial_backoff: float,
+        max_backoff: float,
+        skip_validation: bool,
+        scope: str = "memory",
+        return_usage: bool = False,
+    ) -> Any:
+        """
+        Call Ollama using native API with JSON schema enforcement.
+
+        Ollama's native API supports passing a full JSON schema in the 'format' parameter,
+        which provides better structured output control than the OpenAI-compatible API.
+        """
+        start_time = time.time()
+
+        # Get the JSON schema from the Pydantic model
+        schema = response_format.model_json_schema() if hasattr(response_format, "model_json_schema") else None
+
+        # Build the base URL for Ollama's native API
+        # Default OpenAI-compatible URL is http://localhost:11434/v1
+        # Native API is at http://localhost:11434/api/chat
+        base_url = self.base_url or "http://localhost:11434/v1"
+        if base_url.endswith("/v1"):
+            native_url = base_url[:-3] + "/api/chat"
+        else:
+            native_url = base_url.rstrip("/") + "/api/chat"
+
+        # Build request payload
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+        }
+
+        # Add schema as format parameter for structured output
+        if schema:
+            payload["format"] = schema
+
+        # Add optional parameters with optimized defaults for Ollama
+        options: dict[str, Any] = {
+            "num_ctx": 16384,  # 16k context window for larger prompts
+            "num_batch": 512,  # Optimal batch size for prompt processing
+        }
+        if max_completion_tokens:
+            options["num_predict"] = max_completion_tokens
+        if temperature is not None:
+            options["temperature"] = temperature
+        payload["options"] = options
+
+        last_exception = None
+
+        async with httpx.AsyncClient(timeout=300.0) as client:
+            for attempt in range(max_retries + 1):
+                try:
+                    response = await client.post(native_url, json=payload)
+                    response.raise_for_status()
+
+                    result = response.json()
+                    content = result.get("message", {}).get("content", "")
+
+                    # Parse JSON response
+                    try:
+                        json_data = json.loads(content)
+                    except json.JSONDecodeError as json_err:
+                        content_preview = content[:500] if content else "<empty>"
+                        if content and len(content) > 700:
+                            content_preview = f"{content[:500]}...TRUNCATED...{content[-200:]}"
+                        logger.warning(
+                            f"Ollama JSON parse error (attempt {attempt + 1}/{max_retries + 1}): {json_err}\n"
+                            f"  Model: ollama/{self.model}\n"
+                            f"  Content length: {len(content) if content else 0} chars\n"
+                            f"  Content preview: {content_preview!r}"
+                        )
+                        if attempt < max_retries:
+                            backoff = min(initial_backoff * (2**attempt), max_backoff)
+                            await asyncio.sleep(backoff)
+                            last_exception = json_err
+                            continue
+                        else:
+                            raise
+
+                    # Extract token usage from Ollama response
+                    duration = time.time() - start_time
+                    input_tokens = result.get("prompt_eval_count", 0) or 0
+                    output_tokens = result.get("eval_count", 0) or 0
+                    total_tokens = input_tokens + output_tokens
+
+                    # Record LLM metrics
+                    metrics = get_metrics_collector()
+                    metrics.record_llm_call(
+                        provider=self.provider,
+                        model=self.model,
+                        scope=scope,
+                        duration=duration,
+                        input_tokens=input_tokens,
+                        output_tokens=output_tokens,
+                        success=True,
+                    )
+
+                    # Validate against Pydantic model or return raw JSON
+                    if skip_validation:
+                        validated_result = json_data
+                    else:
+                        validated_result = response_format.model_validate(json_data)
+
+                    if return_usage:
+                        token_usage = TokenUsage(
+                            input_tokens=input_tokens,
+                            output_tokens=output_tokens,
+                            total_tokens=total_tokens,
+                        )
+                        return validated_result, token_usage
+                    return validated_result
+
+                except httpx.HTTPStatusError as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(
+                            f"Ollama HTTP error (attempt {attempt + 1}/{max_retries + 1}): {e.response.status_code}"
+                        )
+                        backoff = min(initial_backoff * (2**attempt), max_backoff)
+                        await asyncio.sleep(backoff)
+                        continue
+                    else:
+                        logger.error(f"Ollama HTTP error after {max_retries + 1} attempts: {e}")
+                        raise
+
+                except httpx.RequestError as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(f"Ollama connection error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                        backoff = min(initial_backoff * (2**attempt), max_backoff)
+                        await asyncio.sleep(backoff)
+                        continue
+                    else:
+                        logger.error(f"Ollama connection error after {max_retries + 1} attempts: {e}")
+                        raise
+
+                except Exception as e:
+                    logger.error(f"Unexpected error during Ollama call: {type(e).__name__}: {e}")
+                    raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Ollama call failed after all retries")
+
+    async def cleanup(self) -> None:
+        """Clean up resources (close OpenAI client connections)."""
+        if hasattr(self, "_client") and self._client:
+            await self._client.close()
@@ -871,21 +871,21 @@ async def _execute_tool(
        query = args.get("query")
        if not query:
            return {"error": "search_mental_models requires a query parameter"}
-        max_results = args.get("max_results") or 5
+        max_results = int(args.get("max_results") or 5)
        return await search_mental_models_fn(query, max_results)

    elif tool_name == "search_observations":
        query = args.get("query")
        if not query:
            return {"error": "search_observations requires a query parameter"}
-        max_tokens = max(args.get("max_tokens") or 5000, 1000)  # Default 5000, min 1000
+        max_tokens = max(int(args.get("max_tokens") or 5000), 1000)  # Default 5000, min 1000
        return await search_observations_fn(query, max_tokens)

    elif tool_name == "recall":
        query = args.get("query")
        if not query:
            return {"error": "recall requires a query parameter"}
-        max_tokens = max(args.get("max_tokens") or 2048, 1000)  # Default 2048, min 1000
+        max_tokens = max(int(args.get("max_tokens") or 2048), 1000)  # Default 2048, min 1000
        return await recall_fn(query, max_tokens)

    elif tool_name == "expand":
@@ -904,18 +904,18 @@ def _summarize_input(tool_name: str, args: dict[str, Any]) -> str:
    if tool_name == "search_mental_models":
        query = args.get("query", "")
        query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
-        max_results = args.get("max_results") or 5
+        max_results = int(args.get("max_results") or 5)
        return f"(query={query_preview}, max_results={max_results})"
    elif tool_name == "search_observations":
        query = args.get("query", "")
        query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
-        max_tokens = max(args.get("max_tokens") or 5000, 1000)
+        max_tokens = max(int(args.get("max_tokens") or 5000), 1000)
        return f"(query={query_preview}, max_tokens={max_tokens})"
    elif tool_name == "recall":
        query = args.get("query", "")
        query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
        # Show actual value used (default 2048, min 1000)
-        max_tokens = max(args.get("max_tokens") or 2048, 1000)
+        max_tokens = max(int(args.get("max_tokens") or 2048), 1000)
        return f"(query={query_preview}, max_tokens={max_tokens})"
    elif tool_name == "expand":
        memory_ids = args.get("memory_ids", [])
@@ -31,7 +31,7 @@ class ReflectAction(BaseModel):
        default=None, description="Observation sections for done action (when output_mode=observations)"
    )
    # Plain text answer fields (for output_mode=answer)
-    answer: str | None = Field(default=None, description="Plain text answer for done action (no markdown)")
+    answer: str | None = Field(default=None, description="Well-formatted markdown answer for done action")
    answer_memory_ids: list[str] | None = Field(
        default=None, description="Memory IDs supporting the answer", alias="memory_ids"
    )
@@ -148,7 +148,15 @@ def build_system_prompt_for_tools(

    parts = []

-    # Inject directives at the VERY START for maximum prominence
+    # Anti-hallucination rule at the very top
+    parts.extend(
+        [
+            "CRITICAL: You MUST ONLY use information from retrieved tool results. NEVER make up names, people, events, or entities.",
+            "",
+        ]
+    )
+
+    # Inject directives after anti-hallucination rule
    if directives:
        parts.append(build_directives_section(directives))

@@ -162,7 +170,7 @@ def build_system_prompt_for_tools(
    parts.extend(
        [
            "## CRITICAL RULES",
-            "- You must NEVER fabricate information that has no basis in retrieved data",
+            "- ONLY use information from tool results - no external knowledge or guessing",
            "- You SHOULD synthesize, infer, and reason from the retrieved memories",
            "- You MUST search before saying you don't have information",
            "",
@@ -300,9 +308,11 @@ def build_system_prompt_for_tools(
    parts.extend(
        [
            "",
-            "## Output Format: Plain Text Answer",
-            "Call done() with a plain text 'answer' field.",
-            "- Do NOT use markdown formatting",
+            "## Output Format: Well-Formatted Markdown Answer",
+            "Call done() with a well-formatted markdown 'answer' field.",
+            "- USE markdown formatting for structure (headers, lists, bold, italic, code blocks, tables, etc.)",
+            "- CRITICAL: Add blank lines before and after block elements (tables, code blocks, lists)",
+            "- Format for clarity and readability with proper spacing and hierarchy",
            "- NEVER include memory IDs, UUIDs, or 'Memory references' in the answer text",
            "- Put IDs ONLY in the memory_ids/mental_model_ids/observation_ids arrays, not in the answer",
        ]
@@ -463,21 +473,41 @@ def build_final_prompt(
    parts.append(
        "\n## Instructions\n"
        "Provide a thoughtful answer by synthesizing and reasoning from the retrieved data above. "
-        "You can make reasonable inferences from the memories, but don't completely fabricate information."
+        "You can make reasonable inferences from the memories, but don't completely fabricate information. "
        "If the exact answer isn't stated, use what IS stated to give the best possible answer. "
-        "Only say 'I don't have information' if the retrieved data is truly unrelated to the question."
+        "Only say 'I don't have information' if the retrieved data is truly unrelated to the question.\n\n"
+        "IMPORTANT: Output ONLY the final answer. Do NOT include meta-commentary like "
+        '"I\'ll search..." or "Let me analyze...". Do NOT explain your reasoning process. '
+        "Just provide the direct synthesized answer."
    )

    return "\n".join(parts)


-FINAL_SYSTEM_PROMPT = """You are a thoughtful assistant that synthesizes answers from retrieved memories.
+FINAL_SYSTEM_PROMPT = """CRITICAL: You MUST ONLY use information from retrieved tool results. NEVER make up names, people, events, or entities.
+
+You are a thoughtful assistant that synthesizes answers from retrieved memories.

 Your approach:
 - Reason over the retrieved memories to answer the question
 - Make reasonable inferences when the exact answer isn't explicitly stated
 - Connect related memories to form a complete picture
 - Be helpful - if you have related information, use it to give the best possible answer
+- ONLY use information from tool results - no external knowledge or guessing

 Only say "I don't have information" if the retrieved data is truly unrelated to the question.
-Do NOT fabricate information that has no basis in the retrieved data."""
+
+FORMATTING: Use proper markdown formatting in your answer:
+- Headers (##, ###) for sections
+- Lists (bullet or numbered) for enumerations
+- Bold/italic for emphasis
+- Tables with proper syntax (ensure blank line before and after)
+- Code blocks where appropriate
+- CRITICAL: Always add blank lines before and after block elements (tables, code blocks, lists)
+- Proper spacing between sections
+
+CRITICAL: Output ONLY the final synthesized answer. Do NOT include:
+- Meta-commentary about what you're doing ("I'll search...", "Let me analyze...")
+- Explanations of your reasoning process
+- Descriptions of your approach
+Just provide the direct answer with proper markdown formatting."""
@@ -54,22 +54,21 @@ async def tool_search_mental_models(
        Dict with matching mental models including content and freshness info
    """
    from ..memory_engine import fq_table
+    from ..search.tags import build_tags_where_clause

    # Build filters dynamically
    filters = ""
    params: list[Any] = [bank_id, str(query_embedding), max_results]
    next_param = 4

+    # Use the centralized tag filtering logic
    if tags:
-        if tags_match == "all":
-            filters += f" AND tags @> ${next_param}::varchar[]"
-        else:
-            filters += f" AND (tags && ${next_param}::varchar[] OR tags IS NULL OR tags = '{{}}')"
-        params.append(tags)
-        next_param += 1
+        tag_clause, tag_params, next_param = build_tags_where_clause(tags, param_offset=next_param, match=tags_match)
+        filters += f" {tag_clause}"
+        params.extend(tag_params)

    if exclude_ids:
-        filters += f" AND id != ALL(${next_param}::uuid[])"
+        filters += f" AND id != ALL(${next_param}::text[])"
        params.append(exclude_ids)
        next_param += 1

@@ -139,7 +139,7 @@ TOOL_DONE_ANSWER = {
            "properties": {
                "answer": {
                    "type": "string",
-                    "description": "Your response as plain text. Do NOT use markdown formatting. NEVER include memory IDs, UUIDs, or 'Memory references' in this text - put IDs only in memory_ids array.",
+                    "description": "Your response as well-formatted markdown. Use headers, lists, bold/italic, and code blocks for clarity. NEVER include memory IDs, UUIDs, or 'Memory references' in this text - put IDs only in memory_ids array.",
                },
                "memory_ids": {
                    "type": "array",
@@ -190,7 +190,7 @@ def _build_done_tool_with_directives(directive_rules: list[str]) -> dict:
                "properties": {
                    "answer": {
                        "type": "string",
-                        "description": "Your response as plain text. Do NOT use markdown formatting. NEVER include memory IDs, UUIDs, or 'Memory references' in this text - put IDs only in memory_ids array.",
+                        "description": "Your response as well-formatted markdown. Use headers, lists, bold/italic, and code blocks for clarity. NEVER include memory IDs, UUIDs, or 'Memory references' in this text - put IDs only in memory_ids array.",
                    },
                    "memory_ids": {
                        "type": "array",
@@ -263,7 +263,6 @@ class ReflectResult(BaseModel):
                        }
                    ],
                },
-                "new_opinions": ["Machine learning has great potential in healthcare"],
                "structured_output": {"summary": "ML in healthcare", "confidence": 0.9},
                "usage": {"input_tokens": 1500, "output_tokens": 500, "total_tokens": 2000},
            }
@@ -272,9 +271,8 @@ class ReflectResult(BaseModel):

    text: str = Field(description="The formulated answer text")
    based_on: dict[str, Any] = Field(
-        description="Facts used to formulate the answer, organized by type (world, experience, opinion, mental_models, directives)"
+        description="Facts used to formulate the answer, organized by type (world, experience, mental_models, directives)"
    )
-    new_opinions: list[str] = Field(default_factory=list, description="List of newly formed opinions during reflection")
    structured_output: dict[str, Any] | None = Field(
        default=None,
        description="Structured output parsed according to the provided response schema. Only present when response_schema was provided.",
@@ -297,24 +295,6 @@ class ReflectResult(BaseModel):
    )


-class Opinion(BaseModel):
-    """
-    An opinion with confidence score.
-
-    Opinions represent the bank's formed perspectives on topics,
-    with a confidence level indicating strength of belief.
-    """
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "example": {"text": "Machine learning has great potential in healthcare", "confidence": 0.85}
-        }
-    )
-
-    text: str = Field(description="The opinion text")
-    confidence: float = Field(description="Confidence score between 0.0 and 1.0")
-
-
 class EntityObservation(BaseModel):
    """
    An observation about an entity.
@@ -57,21 +57,25 @@ def _infer_temporal_date(fact_text: str, event_date: datetime) -> str | None:
    return None


-def _sanitize_text(text: str) -> str:
+def _sanitize_text(text: str | None) -> str | None:
    """
-    Sanitize text by removing invalid Unicode surrogate characters.
+    Sanitize text by removing characters that break downstream systems.

-    Surrogate characters (U+D800 to U+DFFF) are used in UTF-16 encoding
-    but cannot be encoded in UTF-8. They can appear in Python strings
-    from improperly decoded data (e.g., from JavaScript or broken files).
+    Removes:
+    - Null bytes (\\x00): Invalid in PostgreSQL UTF-8 encoding
+    - Unicode surrogates (U+D800-U+DFFF): Invalid in UTF-8, break LLM APIs

-    This function removes unpaired surrogates to prevent UnicodeEncodeError
-    when the text is sent to the LLM API.
+    Surrogate characters are used in UTF-16 encoding but cannot be encoded
+    in UTF-8. They can appear in Python strings from improperly decoded data
+    (e.g., from JavaScript or broken files). Null bytes commonly appear in
+    OCR output, PDF extraction, or copy-paste from binary sources.
    """
+    if text is None:
+        return None
    if not text:
        return text
-    # Remove surrogate characters (U+D800 to U+DFFF) using regex
-    # These are invalid in UTF-8 and cause encoding errors
+    # Remove null bytes and surrogate characters
+    text = text.replace("\x00", "")
    return re.sub(r"[\ud800-\udfff]", "", text)


@@ -538,7 +542,12 @@ Output: ONLY 2 facts (skip coffee preference - too trivial):
 QUALITY OVER QUANTITY
 ══════════════════════════════════════════════════════════════════════════

-Ask: "Would this be useful to recall in 6 months?" If no, skip it."""
+Ask: "Would this be useful to recall in 6 months?" If no, skip it.
+
+IMPORTANT: Sensory/emotional details and observations that provide meaningful context
+about experiences ARE important to remember, even if they seem small (e.g., how food
+tasted, how someone looked, how loud music was). Extract these if they characterize
+an experience or person."""

 # Assembled concise prompt (backward compatible - exact same output as before)
 CONCISE_FACT_EXTRACTION_PROMPT = _BASE_FACT_EXTRACTION_PROMPT.format(
@@ -637,6 +646,7 @@ For EVENTS (fact_kind="event") - MUST SET BOTH occurred_start AND occurred_end:
 - Convert relative dates → absolute using Event Date as reference
 - If Event Date is "Saturday, March 15, 2020", then "yesterday" = Friday, March 14, 2020
 - Dates mentioned in text (e.g., "in March 2020") should use THAT year, not current year
+- CRITICAL: If the content mentions an absolute date (e.g., "March 15, 2024", "2024-03-15"), you MUST extract it and set occurred_start in ISO format
 - Always include the day name (Monday, Tuesday, etc.) in the 'when' field
 - Set occurred_start AND occurred_end to WHEN IT HAPPENED (not when mentioned)
 - For single-day/point events: set occurred_end = occurred_start (same timestamp)
@@ -693,7 +703,6 @@ async def _extract_facts_from_chunk(
    context: str,
    llm_config: "LLMConfig",
    agent_name: str = None,
-    extract_opinions: bool = False,
 ) -> tuple[list[dict[str, str]], TokenUsage]:
    """
    Extract facts from a single chunk (internal helper for parallel processing).
@@ -707,17 +716,9 @@ async def _extract_facts_from_chunk(

    logger = logging.getLogger(__name__)

-    memory_bank_context = f"\n- Your name: {agent_name}" if agent_name and extract_opinions else ""
-
-    # Determine which fact types to extract based on the flag
+    # Determine which fact types to extract
    # Note: We use "assistant" in the prompt but convert to "bank" for storage
-    if extract_opinions:
-        # Opinion extraction uses a separate prompt (not this one)
-        fact_types_instruction = "Extract ONLY 'opinion' type facts (formed opinions, beliefs, and perspectives). DO NOT extract 'world' or 'assistant' facts."
-    else:
-        fact_types_instruction = (
-            "Extract ONLY 'world' and 'assistant' type facts. DO NOT extract opinions - those are extracted separately."
-        )
+    fact_types_instruction = "Extract ONLY 'world' and 'assistant' type facts."

    # Check config for extraction mode and causal link extraction
    config = get_config()
@@ -768,9 +769,12 @@ async def _extract_facts_from_chunk(

    # Build user message with metadata and chunk content in a clear format
    # Format event_date with day of week for better temporal reasoning
+    # Handle both datetime objects and ISO string formats (from deserialized async tasks)
+    from .orchestrator import parse_datetime_flexible
+
+    event_date = parse_datetime_flexible(event_date)
    event_date_formatted = event_date.strftime("%A, %B %d, %Y")  # e.g., "Monday, June 10, 2024"
    user_message = f"""Extract facts from the following text chunk.
-{memory_bank_context}

 Chunk: {chunk_index + 1}/{total_chunks}
 Event Date: {event_date_formatted} ({event_date.isoformat()})
@@ -782,12 +786,28 @@ Text:
    usage = TokenUsage()  # Track cumulative usage across retries
    for attempt in range(max_retries):
        try:
+            # Use retain-specific overrides if set, otherwise fall back to global LLM config
+            max_retries = (
+                config.retain_llm_max_retries if config.retain_llm_max_retries is not None else config.llm_max_retries
+            )
+            initial_backoff = (
+                config.retain_llm_initial_backoff
+                if config.retain_llm_initial_backoff is not None
+                else config.llm_initial_backoff
+            )
+            max_backoff = (
+                config.retain_llm_max_backoff if config.retain_llm_max_backoff is not None else config.llm_max_backoff
+            )
+
            extraction_response_json, call_usage = await llm_config.call(
                messages=[{"role": "system", "content": prompt}, {"role": "user", "content": user_message}],
                response_format=response_schema,
                scope="memory_extract_facts",
                temperature=0.1,
                max_completion_tokens=config.retain_max_completion_tokens,
+                max_retries=max_retries,
+                initial_backoff=initial_backoff,
+                max_backoff=max_backoff,
                skip_validation=True,  # Get raw JSON, we'll validate leniently
                return_usage=True,
            )
@@ -991,6 +1011,29 @@ Text:

        except BadRequestError as e:
            last_error = e
+            error_str = str(e).lower()
+
+            # Check if error is related to max_tokens/completion_tokens not being supported
+            if any(
+                keyword in error_str
+                for keyword in [
+                    "max_tokens",
+                    "max_completion_tokens",
+                    "maximum context",
+                    "token limit",
+                    "context length",
+                ]
+            ):
+                # Provide helpful error message with configuration suggestions
+                raise ValueError(
+                    f"Model does not support the required output token limit.\n\n"
+                    f"The model '{llm_config.model}' (provider: {llm_config.provider}) failed with: {e}\n\n"
+                    f"You have two options to fix this:\n"
+                    f"  1. Use a different model that supports at least {config.retain_max_completion_tokens} output tokens\n"
+                    f"  2. Decrease HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS to a value your model supports\n"
+                    f"     (current value: {config.retain_max_completion_tokens}, must be > RETAIN_CHUNK_SIZE={config.retain_chunk_size})"
+                ) from e
+
            if "json_validate_failed" in str(e):
                logger.warning(
                    f"          [1.3.{chunk_index + 1}] Attempt {attempt + 1}/{max_retries} failed with JSON validation error: {e}"
@@ -1013,7 +1056,6 @@ async def _extract_facts_with_auto_split(
    context: str,
    llm_config: LLMConfig,
    agent_name: str = None,
-    extract_opinions: bool = False,
 ) -> tuple[list[dict[str, str]], TokenUsage]:
    """
    Extract facts from a chunk with automatic splitting if output exceeds token limits.
@@ -1029,7 +1071,6 @@ async def _extract_facts_with_auto_split(
        context: Context about the conversation/document
        llm_config: LLM configuration to use
        agent_name: Optional agent name (memory owner)
-        extract_opinions: If True, extract ONLY opinions. If False, extract world and agent facts (no opinions)

    Returns:
        Tuple of (facts list, token usage) extracted from the chunk (possibly from sub-chunks)
@@ -1048,7 +1089,6 @@ async def _extract_facts_with_auto_split(
            context=context,
            llm_config=llm_config,
            agent_name=agent_name,
-            extract_opinions=extract_opinions,
        )
    except OutputTooLongError:
        # Output exceeded token limits - split the chunk in half and retry
@@ -1093,7 +1133,6 @@ async def _extract_facts_with_auto_split(
                context=context,
                llm_config=llm_config,
                agent_name=agent_name,
-                extract_opinions=extract_opinions,
            ),
            _extract_facts_with_auto_split(
                chunk=second_half,
@@ -1103,7 +1142,6 @@ async def _extract_facts_with_auto_split(
                context=context,
                llm_config=llm_config,
                agent_name=agent_name,
-                extract_opinions=extract_opinions,
            ),
        ]

@@ -1127,7 +1165,6 @@ async def extract_facts_from_text(
    llm_config: LLMConfig,
    agent_name: str,
    context: str = "",
-    extract_opinions: bool = False,
 ) -> tuple[list[Fact], list[tuple[str, int]], TokenUsage]:
    """
    Extract semantic facts from conversational or narrative text using LLM.
@@ -1144,7 +1181,6 @@ async def extract_facts_from_text(
        context: Context about the conversation/document
        llm_config: LLM configuration to use
        agent_name: Agent name (memory owner)
-        extract_opinions: If True, extract ONLY opinions. If False, extract world and bank facts (no opinions)

    Returns:
        Tuple of (facts, chunks, usage) where:
@@ -1172,7 +1208,6 @@ async def extract_facts_from_text(
            context=context,
            llm_config=llm_config,
            agent_name=agent_name,
-            extract_opinions=extract_opinions,
        )
        for i, chunk in enumerate(chunks)
    ]
@@ -1204,7 +1239,7 @@ SECONDS_PER_FACT = 10


 async def extract_facts_from_contents(
-    contents: list[RetainContent], llm_config, agent_name: str, extract_opinions: bool = False
+    contents: list[RetainContent], llm_config, agent_name: str
 ) -> tuple[list[ExtractedFactType], list[ChunkMetadata], TokenUsage]:
    """
    Extract facts from multiple content items in parallel.
@@ -1219,7 +1254,6 @@ async def extract_facts_from_contents(
        contents: List of RetainContent objects to process
        llm_config: LLM configuration for fact extraction
        agent_name: Name of the agent (for agent-related fact detection)
-        extract_opinions: If True, extract only opinions; otherwise world/bank facts

    Returns:
        Tuple of (extracted_facts, chunks_metadata, usage)
@@ -1238,7 +1272,6 @@ async def extract_facts_from_contents(
            context=item.context,
            llm_config=llm_config,
            agent_name=agent_name,
-            extract_opinions=extract_opinions,
        )
        fact_extraction_tasks.append(task)

@@ -1343,31 +1376,26 @@ def _convert_causal_relations(relations_from_llm, fact_start_idx: int) -> list[C

 def _add_temporal_offsets(facts: list[ExtractedFactType], contents: list[RetainContent]) -> None:
    """
-    Add time offsets to preserve fact ordering within each content.
+    Add time offsets to preserve fact ordering across all contents.

-    This allows retrieval to distinguish between facts that happened earlier vs later
-    in the same conversation, even when the base event_date is the same.
+    This allows retrieval to distinguish between facts from different documents/conversations
+    even when they have the same base event_date, and also between facts within the same
+    conversation.
+
+    Uses absolute position across all facts to ensure unique timestamps.

    Modifies facts in place.
    """
-    # Group facts by content_index
-    current_content_idx = 0
-    content_fact_start = 0
+    from .orchestrator import parse_datetime_flexible

    for i, fact in enumerate(facts):
-        if fact.content_index != current_content_idx:
-            # Moved to next content
-            current_content_idx = fact.content_index
-            content_fact_start = i
+        # Use absolute position across all facts to ensure uniqueness across different contents
+        offset = timedelta(seconds=i * SECONDS_PER_FACT)

-        # Calculate position within this content
-        fact_position = i - content_fact_start
-        offset = timedelta(seconds=fact_position * SECONDS_PER_FACT)
-
-        # Apply offset to all temporal fields
+        # Apply offset to all temporal fields (handle both datetime objects and ISO strings)
        if fact.occurred_start:
-            fact.occurred_start = fact.occurred_start + offset
+            fact.occurred_start = parse_datetime_flexible(fact.occurred_start) + offset
        if fact.occurred_end:
-            fact.occurred_end = fact.occurred_end + offset
+            fact.occurred_end = parse_datetime_flexible(fact.occurred_end) + offset
        if fact.mentioned_at:
-            fact.mentioned_at = fact.mentioned_at + offset
+            fact.mentioned_at = parse_datetime_flexible(fact.mentioned_at) + offset
@@ -8,6 +8,7 @@ import json
 import logging

 from ..memory_engine import fq_table
+from .fact_extraction import _sanitize_text
 from .types import ProcessedFact

 logger = logging.getLogger(__name__)
@@ -47,7 +48,7 @@ async def insert_facts_batch(
    tags_list = []

    for fact in facts:
-        fact_texts.append(fact.fact_text)
+        fact_texts.append(_sanitize_text(fact.fact_text))
        # Convert embedding to string for asyncpg vector type
        embeddings.append(str(fact.embedding))
        # event_date: Use occurred_start if available, otherwise use mentioned_at
@@ -56,7 +57,7 @@ async def insert_facts_batch(
        occurred_starts.append(fact.occurred_start)
        occurred_ends.append(fact.occurred_end)
        mentioned_ats.append(fact.mentioned_at)
-        contexts.append(fact.context)
+        contexts.append(_sanitize_text(fact.context))
        fact_types.append(fact.fact_type)
        # confidence_score is only for opinion facts
        confidence_scores.append(1.0 if fact.fact_type == "opinion" else None)
@@ -157,7 +158,8 @@ async def handle_document_tracking(
    """
    import hashlib

-    # Calculate content hash
+    # Sanitize and calculate content hash
+    combined_content = _sanitize_text(combined_content) or ""
    content_hash = hashlib.sha256(combined_content.encode()).hexdigest()

    # Always delete old document first if it exists (cascades to units and links)
@@ -8,6 +8,7 @@ import logging
 import time
 import uuid
 from datetime import UTC, datetime
+from typing import Any

 from ..db_utils import acquire_with_retry
 from . import bank_utils
@@ -18,6 +19,39 @@ def utcnow():
    return datetime.now(UTC)


+def parse_datetime_flexible(value: Any) -> datetime:
+    """
+    Parse a datetime value that could be either a datetime object or an ISO string.
+
+    This handles datetime values from both direct Python calls and deserialized JSON
+    (where datetime objects are serialized as ISO strings).
+
+    Args:
+        value: Either a datetime object or an ISO format string
+
+    Returns:
+        datetime object (timezone-aware)
+
+    Raises:
+        TypeError: If value is neither datetime nor string
+        ValueError: If string is not a valid ISO datetime
+    """
+    if isinstance(value, datetime):
+        # Ensure timezone-aware
+        if value.tzinfo is None:
+            return value.replace(tzinfo=UTC)
+        return value
+    elif isinstance(value, str):
+        # Parse ISO format string (handles both 'Z' and '+00:00' timezone formats)
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        # Ensure timezone-aware
+        if dt.tzinfo is None:
+            return dt.replace(tzinfo=UTC)
+        return dt
+    else:
+        raise TypeError(f"Expected datetime or string, got {type(value).__name__}")
+
+
 from ..response_models import TokenUsage
 from . import (
    chunk_storage,
@@ -89,10 +123,18 @@ async def retain_batch(
        # Merge item-level tags with document-level tags
        item_tags = item.get("tags", []) or []
        merged_tags = list(set(item_tags + (document_tags or [])))
+
+        # Handle event_date: parse flexibly (handles both datetime objects and ISO strings)
+        event_date_value = item.get("event_date")
+        if event_date_value:
+            event_date_value = parse_datetime_flexible(event_date_value)
+        else:
+            event_date_value = utcnow()
+
        content = RetainContent(
            content=item["content"],
            context=item.get("context", ""),
-            event_date=item.get("event_date") or utcnow(),
+            event_date=event_date_value,
            metadata=item.get("metadata", {}),
            entities=item.get("entities", []),
            tags=merged_tags,
@@ -101,11 +143,8 @@ async def retain_batch(

    # Step 1: Extract facts from all contents
    step_start = time.time()
-    extract_opinions = fact_type_override == "opinion"

-    extracted_facts, chunks, usage = await fact_extraction.extract_facts_from_contents(
-        contents, llm_config, agent_name, extract_opinions
-    )
+    extracted_facts, chunks, usage = await fact_extraction.extract_facts_from_contents(contents, llm_config, agent_name)
    log_buffer.append(
        f"[1] Extract facts: {len(extracted_facts)} facts, {len(chunks)} chunks from {len(contents)} contents in {time.time() - step_start:.3f}s"
    )
@@ -119,6 +158,13 @@ async def retain_batch(
                # Handle document tracking even with no facts
                if document_id:
                    combined_content = "\n".join([c.get("content", "") for c in contents_dicts])
+                    # Collect tags from all content items and merge with document_tags
+                    all_tags = set(document_tags or [])
+                    for item in contents_dicts:
+                        item_tags = item.get("tags", []) or []
+                        all_tags.update(item_tags)
+                    merged_tags = list(all_tags)
+
                    retain_params = {}
                    if contents_dicts:
                        first_item = contents_dicts[0]
@@ -133,7 +179,7 @@ async def retain_batch(
                        if first_item.get("metadata"):
                            retain_params["metadata"] = first_item["metadata"]
                    await fact_storage.handle_document_tracking(
-                        conn, bank_id, document_id, combined_content, is_first_batch, retain_params, document_tags
+                        conn, bank_id, document_id, combined_content, is_first_batch, retain_params, merged_tags
                    )
                else:
                    # Check for per-item document_ids
@@ -147,6 +193,13 @@ async def retain_batch(

                    for doc_id, doc_contents in contents_by_doc.items():
                        combined_content = "\n".join([c.get("content", "") for _, c in doc_contents])
+                        # Collect tags from all content items for this document and merge with document_tags
+                        all_tags = set(document_tags or [])
+                        for _, item in doc_contents:
+                            item_tags = item.get("tags", []) or []
+                            all_tags.update(item_tags)
+                        merged_tags = list(all_tags)
+
                        retain_params = {}
                        if doc_contents:
                            first_item = doc_contents[0][1]
@@ -161,7 +214,7 @@ async def retain_batch(
                            if first_item.get("metadata"):
                                retain_params["metadata"] = first_item["metadata"]
                        await fact_storage.handle_document_tracking(
-                            conn, bank_id, doc_id, combined_content, is_first_batch, retain_params, document_tags
+                            conn, bank_id, doc_id, combined_content, is_first_batch, retain_params, merged_tags
                        )

        total_time = time.time() - start_time
@@ -213,6 +266,13 @@ async def retain_batch(
                # Legacy: single document_id parameter
                combined_content = "\n".join([c.get("content", "") for c in contents_dicts])
                retain_params = {}
+                # Collect tags from all content items and merge with document_tags
+                all_tags = set(document_tags or [])
+                for item in contents_dicts:
+                    item_tags = item.get("tags", []) or []
+                    all_tags.update(item_tags)
+                merged_tags = list(all_tags)
+
                if contents_dicts:
                    first_item = contents_dicts[0]
                    if first_item.get("context"):
@@ -227,7 +287,7 @@ async def retain_batch(
                        retain_params["metadata"] = first_item["metadata"]

                await fact_storage.handle_document_tracking(
-                    conn, bank_id, document_id, combined_content, is_first_batch, retain_params, document_tags
+                    conn, bank_id, document_id, combined_content, is_first_batch, retain_params, merged_tags
                )
                document_ids_added.append(document_id)
                doc_id_mapping[None] = document_id  # For backwards compatibility
@@ -255,6 +315,13 @@ async def retain_batch(
                            # Combine content for this document
                            combined_content = "\n".join([c.get("content", "") for _, c in doc_contents])

+                            # Collect tags from all content items for this document and merge with document_tags
+                            all_tags = set(document_tags or [])
+                            for _, item in doc_contents:
+                                item_tags = item.get("tags", []) or []
+                                all_tags.update(item_tags)
+                            merged_tags = list(all_tags)
+
                            # Extract retain params from first content item
                            retain_params = {}
                            if doc_contents:
@@ -277,7 +344,7 @@ async def retain_batch(
                                combined_content,
                                is_first_batch,
                                retain_params,
-                                document_tags,
+                                merged_tags,
                            )
                            document_ids_added.append(actual_doc_id)

@@ -188,7 +188,7 @@ def get_system_message(disposition: DispositionTraits) -> str:
        " ".join(instructions) if instructions else "Balance your disposition traits when interpreting information."
    )

-    return f"You are a person with your own thoughts, experiences, opinions, and disposition. When asked a question, respond naturally like a human would - share what you genuinely think based on what you know and have experienced. {disposition_instruction} Be direct, express your views confidently, and use 'I think', 'I believe', 'in my view', etc. Respond in plain text without markdown formatting. IMPORTANT: Detect the language of the question and respond in the SAME language. Do not translate to English if the question is in another language."
+    return f"You are a person with your own thoughts, experiences, opinions, and disposition. When asked a question, respond naturally like a human would - share what you genuinely think based on what you know and have experienced. {disposition_instruction} Be direct, express your views confidently, and use 'I think', 'I believe', 'in my view', etc. Respond in plain text without markdown formatting. CRITICAL: ONLY use the facts and information provided in the prompt - do not make up names, events, or information that weren't mentioned. If you don't have enough information to answer, say so. IMPORTANT: Detect the language of the question and respond in the SAME language. Do not translate to English if the question is in another language."


 async def reflect(
@@ -182,7 +182,16 @@ class BrokerTaskBackend(TaskBackend):
        operation_id = task_dict.get("operation_id")
        task_type = task_dict.get("type", "unknown")
        bank_id = task_dict.get("bank_id")
-        payload_json = json.dumps(task_dict)
+
+        # Custom encoder to handle datetime objects
+        from datetime import datetime
+
+        def datetime_encoder(obj):
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+        payload_json = json.dumps(task_dict, default=datetime_encoder)

        schema = self._schema_getter() if self._schema_getter else self._schema
        table = fq_table("async_operations", schema)
@@ -19,7 +19,6 @@ async def extract_facts(
    context: str = "",
    llm_config: "LLMConfig" = None,
    agent_name: str = None,
-    extract_opinions: bool = False,
 ) -> tuple[list["Fact"], list[tuple[str, int]]]:
    """
    Extract semantic facts from text using LLM.
@@ -36,7 +35,6 @@ async def extract_facts(
        context: Context about the conversation/document
        llm_config: LLM configuration to use
        agent_name: Optional agent name to help identify agent-related facts
-        extract_opinions: If True, extract ONLY opinions. If False, extract world and agent facts (no opinions)

    Returns:
        Tuple of (facts, chunks) where:
@@ -55,7 +53,6 @@ async def extract_facts(
        context=context,
        llm_config=llm_config,
        agent_name=agent_name,
-        extract_opinions=extract_opinions,
    )

    if not facts:
@@ -16,14 +16,20 @@ with the system (e.g., running migrations for tenant schemas).
 """

 from hindsight_api.extensions.base import Extension
-from hindsight_api.extensions.builtin import ApiKeyTenantExtension
+from hindsight_api.extensions.builtin import ApiKeyTenantExtension, SupabaseTenantExtension
 from hindsight_api.extensions.context import DefaultExtensionContext, ExtensionContext
 from hindsight_api.extensions.http import HttpExtension
 from hindsight_api.extensions.loader import load_extension
+from hindsight_api.extensions.mcp import MCPExtension
 from hindsight_api.extensions.operation_validator import (
    # Consolidation operation
    ConsolidateContext,
    ConsolidateResult,
+    # Mental Model operations
+    MentalModelGetContext,
+    MentalModelGetResult,
+    MentalModelRefreshContext,
+    MentalModelRefreshResult,
    # Core operations
    OperationValidationError,
    OperationValidatorExtension,
@@ -52,6 +58,8 @@ __all__ = [
    "DefaultExtensionContext",
    # HTTP Extension
    "HttpExtension",
+    # MCP Extension
+    "MCPExtension",
    # Operation Validator - Core
    "OperationValidationError",
    "OperationValidatorExtension",
@@ -65,8 +73,14 @@ __all__ = [
    # Operation Validator - Consolidation
    "ConsolidateContext",
    "ConsolidateResult",
+    # Operation Validator - Mental Model
+    "MentalModelGetContext",
+    "MentalModelGetResult",
+    "MentalModelRefreshContext",
+    "MentalModelRefreshResult",
    # Tenant/Auth
    "ApiKeyTenantExtension",
+    "SupabaseTenantExtension",
    "AuthenticationError",
    "RequestContext",
    "Tenant",
@@ -6,13 +6,17 @@ They can be used directly or serve as examples for custom implementations.

 Available built-in extensions:
    - ApiKeyTenantExtension: Simple API key validation with public schema
+    - SupabaseTenantExtension: Supabase JWT validation with per-user schema isolation

 Example usage:
    HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
+    HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.supabase_tenant:SupabaseTenantExtension
 """

+from hindsight_api.extensions.builtin.supabase_tenant import SupabaseTenantExtension
 from hindsight_api.extensions.builtin.tenant import ApiKeyTenantExtension

 __all__ = [
    "ApiKeyTenantExtension",
+    "SupabaseTenantExtension",
 ]
@@ -0,0 +1,433 @@
+"""
+Supabase Tenant Extension for Hindsight
+
+Validates Supabase JWTs and maps authenticated users to isolated memory banks.
+Each user gets their own PostgreSQL schema based on their Supabase user ID.
+
+This extension enables multi-tenant memory isolation for applications using
+Supabase Auth - each authenticated user's memories are stored in a separate
+schema, ensuring complete data isolation.
+
+Features:
+    - Local JWT Verification: Validates tokens locally using JWKS public keys
+      (no network call per request)
+    - Automatic Schema Isolation: Each user gets {prefix}_{user_id} schema
+    - Zero User Management: Leverages your existing Supabase Auth setup
+    - Production Ready: Includes health checks, timeouts, key rotation handling,
+      and error handling
+    - Built-in: Ships with Hindsight, no extra installation needed
+    - Legacy Support: Falls back to /auth/v1/user endpoint for HS256 projects
+
+JWT Verification Strategy:
+    By default, JWTs are verified locally using public keys from the Supabase
+    JWKS endpoint (/auth/v1/.well-known/jwks.json). This is the Supabase-recommended
+    approach: no network call per request, fast, and secure.
+
+    If JWKS keys are unavailable (e.g., legacy HS256 projects), the extension
+    falls back to calling /auth/v1/user per request for validation. This requires
+    the service_role key to be configured.
+
+Configuration via environment variables:
+    HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.supabase_tenant:SupabaseTenantExtension
+    HINDSIGHT_API_TENANT_SUPABASE_URL=https://your-project.supabase.co
+
+    # Optional - only required for legacy HS256 projects or health checks
+    HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY=your-service-role-key
+
+    # Optional
+    HINDSIGHT_API_TENANT_SCHEMA_PREFIX=user  # Default: "user" (creates user_<uuid> schemas)
+
+Usage:
+    Clients pass their Supabase JWT in the Authorization header:
+
+    curl -H "Authorization: Bearer <supabase_jwt>" \\
+        https://your-hindsight-server/v1/default/banks/my-bank/memories/recall
+
+Author: BrighterBalance (https://brighterbalance.app)
+License: MIT
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import time
+
+import httpx
+import jwt as pyjwt
+from jwt import PyJWK
+
+from hindsight_api.extensions.tenant import AuthenticationError, Tenant, TenantContext, TenantExtension
+from hindsight_api.models import RequestContext
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["SupabaseTenantExtension"]
+
+# Minimum expected JWT length (JWTs are typically 100+ characters)
+MIN_TOKEN_LENGTH = 20
+
+# Timeout for Supabase API calls
+REQUEST_TIMEOUT_SECONDS = 10.0
+
+# JWKS cache TTL — Supabase Edge caches JWKS for 10 minutes, so we match that
+JWKS_CACHE_TTL_SECONDS = 600
+
+# Minimum interval between JWKS refreshes to avoid hammering the endpoint
+JWKS_MIN_REFRESH_INTERVAL_SECONDS = 30
+
+# Algorithms supported by Supabase Auth for asymmetric JWT signing
+SUPPORTED_ALGORITHMS = ["RS256", "ES256"]
+
+# Supabase user IDs are UUIDs — validate before using in schema names
+_UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
+# Schema prefix must be a valid Postgres identifier component (letters, digits, underscores)
+_SCHEMA_PREFIX_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
+
+class SupabaseTenantExtension(TenantExtension):
+    """
+    TenantExtension that validates Supabase JWTs for multi-tenant isolation.
+
+    Each authenticated user gets their own PostgreSQL schema, ensuring complete
+    memory isolation between users. The schema name is derived from the user's
+    Supabase user ID (the ``sub`` claim in the JWT).
+
+    JWT verification uses JWKS (local, no network call per request) when
+    asymmetric keys are configured in Supabase, and falls back to the
+    ``/auth/v1/user`` endpoint for legacy HS256 projects.
+
+    Example:
+        User with ID "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+        gets schema "user_a1b2c3d4_e5f6_7890_abcd_ef1234567890"
+    """
+
+    def __init__(self, config: dict[str, str]) -> None:
+        """
+        Initialize with configuration from environment variables.
+
+        Config keys are derived from HINDSIGHT_API_TENANT_* env vars:
+        - HINDSIGHT_API_TENANT_SUPABASE_URL -> config["supabase_url"] (required)
+        - HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY -> config["supabase_service_key"] (optional)
+        - HINDSIGHT_API_TENANT_SCHEMA_PREFIX -> config["schema_prefix"] (optional)
+
+        Args:
+            config: Dictionary of configuration values from environment
+
+        Raises:
+            ValueError: If required configuration is missing
+        """
+        super().__init__(config)
+
+        self.supabase_url = (config.get("supabase_url") or "").rstrip("/")
+        self.supabase_service_key = config.get("supabase_service_key")
+        self.schema_prefix = config.get("schema_prefix", "user")
+
+        # Track initialized schemas to avoid redundant migrations
+        self._initialized_schemas: set[str] = set()
+
+        # Reusable HTTP client (created on startup)
+        self._http_client: httpx.AsyncClient | None = None
+
+        # JWKS state
+        self._jwks_keys: dict[str, PyJWK] = {}
+        self._jwks_last_fetched: float = 0
+        self._use_jwks: bool = False
+
+        if not self.supabase_url:
+            raise ValueError(
+                "HINDSIGHT_API_TENANT_SUPABASE_URL is required. "
+                "Set it to your Supabase project URL (e.g., https://xxx.supabase.co)"
+            )
+
+        if not _SCHEMA_PREFIX_RE.match(self.schema_prefix):
+            raise ValueError(
+                f"Invalid schema_prefix '{self.schema_prefix}'. "
+                "Must be a valid Postgres identifier (letters, digits, underscores, starting with a letter or underscore)."
+            )
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def on_startup(self) -> None:
+        """
+        Called when Hindsight starts.
+
+        Creates a reusable HTTP client, fetches JWKS for local JWT verification,
+        and optionally verifies connectivity to Supabase.
+        """
+        logger.info("Initializing Supabase tenant extension")
+        logger.info("Supabase URL: %s", self.supabase_url)
+        logger.info("Schema prefix: %s_", self.schema_prefix)
+
+        self._http_client = httpx.AsyncClient(timeout=REQUEST_TIMEOUT_SECONDS)
+
+        # Attempt to fetch JWKS for fast local JWT verification
+        await self._try_init_jwks()
+
+        # Optional health check using service key
+        if self.supabase_service_key:
+            await self._health_check()
+
+    async def on_shutdown(self) -> None:
+        """Called when Hindsight shuts down. Closes the HTTP client."""
+        logger.info("Shutting down Supabase tenant extension")
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+
+    # ------------------------------------------------------------------
+    # JWKS management
+    # ------------------------------------------------------------------
+
+    async def _try_init_jwks(self) -> None:
+        """Fetch JWKS and decide verification mode (local JWKS vs legacy endpoint)."""
+        try:
+            await self._fetch_jwks()
+            if self._jwks_keys:
+                self._use_jwks = True
+                logger.info(
+                    "JWKS loaded — using local JWT verification with %d key(s)",
+                    len(self._jwks_keys),
+                )
+                return
+
+            # JWKS endpoint returned no keys — project likely uses legacy HS256
+            logger.warning(
+                "JWKS endpoint returned no signing keys. "
+                "Falling back to /auth/v1/user endpoint for JWT verification. "
+                "For better performance, enable asymmetric JWT signing in your "
+                "Supabase dashboard (Project Settings → Auth → JWT Algorithm)."
+            )
+        except Exception as e:
+            logger.warning(
+                "Could not fetch JWKS (%s). Falling back to /auth/v1/user endpoint for JWT verification.",
+                e,
+            )
+
+        # Legacy mode requires service key
+        if not self.supabase_service_key:
+            raise ValueError(
+                "HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY is required when JWKS "
+                "is not available. Either enable asymmetric JWT signing in your "
+                "Supabase project or provide the service_role key."
+            )
+        self._use_jwks = False
+
+    async def _fetch_jwks(self) -> None:
+        """Fetch public signing keys from the Supabase JWKS endpoint."""
+        if self._http_client is None:
+            raise RuntimeError("HTTP client not initialized")
+
+        url = f"{self.supabase_url}/auth/v1/.well-known/jwks.json"
+        response = await self._http_client.get(url)
+        response.raise_for_status()
+
+        jwks_data = response.json()
+        keys: dict[str, PyJWK] = {}
+        for key_data in jwks_data.get("keys", []):
+            kid = key_data.get("kid")
+            if kid:
+                keys[kid] = PyJWK(key_data)
+
+        self._jwks_keys = keys
+        self._jwks_last_fetched = time.monotonic()
+
+    async def _get_signing_key(self, token: str) -> PyJWK:
+        """
+        Resolve the signing key for a token from the JWKS cache.
+
+        If the key ID (``kid``) is not in the cache, triggers one JWKS refresh
+        to handle key rotation before raising an error.
+        """
+        header = pyjwt.get_unverified_header(token)
+        kid = header.get("kid")
+        if not kid:
+            raise AuthenticationError("Token missing key ID (kid) header")
+
+        # Refresh cache if stale
+        now = time.monotonic()
+        if now - self._jwks_last_fetched > JWKS_CACHE_TTL_SECONDS:
+            logger.debug("JWKS cache expired, refreshing")
+            await self._fetch_jwks()
+
+        if kid in self._jwks_keys:
+            return self._jwks_keys[kid]
+
+        # Key not found — try one forced refresh to handle key rotation,
+        # but only if we haven't just refreshed
+        if now - self._jwks_last_fetched > JWKS_MIN_REFRESH_INTERVAL_SECONDS:
+            logger.info("Signing key %s not in cache, refreshing JWKS for possible key rotation", kid)
+            await self._fetch_jwks()
+            if kid in self._jwks_keys:
+                return self._jwks_keys[kid]
+
+        raise AuthenticationError("Unable to find signing key for token")
+
+    # ------------------------------------------------------------------
+    # Authentication
+    # ------------------------------------------------------------------
+
+    async def authenticate(self, context: RequestContext) -> TenantContext:
+        """
+        Validate a Supabase JWT and return tenant context.
+
+        Uses local JWKS verification when available (no network call per
+        request), falling back to the ``/auth/v1/user`` endpoint for legacy
+        HS256 projects.
+
+        Args:
+            context: Request context containing the API key (JWT)
+
+        Returns:
+            TenantContext with schema_name set to ``{prefix}_{user_uuid}``
+
+        Raises:
+            AuthenticationError: If token is missing, invalid, or expired
+        """
+        token = context.api_key
+
+        if not token:
+            raise AuthenticationError("Missing Authorization header. Expected: Bearer <supabase_jwt>")
+
+        if len(token) < MIN_TOKEN_LENGTH:
+            raise AuthenticationError("Invalid token format")
+
+        if self._http_client is None:
+            raise AuthenticationError("Extension not initialized")
+
+        # Verify the JWT and extract user ID
+        if self._use_jwks:
+            user_id = await self._verify_token_jwks(token)
+        else:
+            user_id = await self._verify_token_legacy(token)
+
+        # Validate user ID format before using in schema name
+        if not _UUID_RE.match(user_id):
+            raise AuthenticationError("Invalid user ID format in token")
+
+        # Build isolated schema name — hyphens to underscores for Postgres compatibility
+        safe_user_id = user_id.replace("-", "_")
+        schema_name = f"{self.schema_prefix}_{safe_user_id}"
+
+        # Initialize schema on first access
+        if schema_name not in self._initialized_schemas:
+            await self._initialize_schema(schema_name)
+
+        return TenantContext(schema_name=schema_name)
+
+    async def _verify_token_jwks(self, token: str) -> str:
+        """
+        Verify a JWT locally using cached JWKS public keys.
+
+        Validates signature, expiration, issuer, and audience. Returns the
+        user ID from the ``sub`` claim.
+
+        Raises:
+            AuthenticationError: If the token is invalid or expired.
+        """
+        try:
+            signing_key = await self._get_signing_key(token)
+            payload = pyjwt.decode(
+                token,
+                signing_key.key,
+                algorithms=SUPPORTED_ALGORITHMS,
+                audience="authenticated",
+                issuer=f"{self.supabase_url}/auth/v1",
+            )
+        except pyjwt.ExpiredSignatureError:
+            raise AuthenticationError("Token has expired")
+        except pyjwt.InvalidAudienceError:
+            raise AuthenticationError("Invalid token audience")
+        except pyjwt.InvalidIssuerError:
+            raise AuthenticationError("Invalid token issuer")
+        except pyjwt.DecodeError:
+            raise AuthenticationError("Invalid token")
+        except AuthenticationError:
+            raise
+        except Exception as e:
+            raise AuthenticationError(f"Token verification failed: {e!s}")
+
+        user_id = payload.get("sub")
+        if not user_id:
+            raise AuthenticationError("Token valid but missing subject (sub) claim")
+        return user_id
+
+    async def _verify_token_legacy(self, token: str) -> str:
+        """
+        Verify a JWT by calling the Supabase ``/auth/v1/user`` endpoint.
+
+        This is the fallback for projects using legacy HS256 JWT signing.
+        Adds a network round-trip per request.
+
+        Raises:
+            AuthenticationError: If the token is invalid or the request fails.
+        """
+        try:
+            response = await self._http_client.get(
+                f"{self.supabase_url}/auth/v1/user",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "apikey": self.supabase_service_key,
+                },
+            )
+
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid or expired token")
+
+            if response.status_code != 200:
+                raise AuthenticationError(f"Authentication failed: {response.status_code}")
+
+            user_data = response.json()
+            user_id = user_data.get("id")
+
+            if not user_id:
+                raise AuthenticationError("Token valid but no user ID found")
+
+            return user_id
+
+        except AuthenticationError:
+            raise
+        except httpx.TimeoutException:
+            raise AuthenticationError("Authentication timeout - please retry")
+        except httpx.RequestError as e:
+            raise AuthenticationError(f"Connection error: {e!s}")
+
+    # ------------------------------------------------------------------
+    # Schema management
+    # ------------------------------------------------------------------
+
+    async def _initialize_schema(self, schema_name: str) -> None:
+        """Run migrations for a new tenant schema and cache the result."""
+        logger.info("Initializing schema: %s", schema_name)
+        try:
+            await self.context.run_migration(schema_name)
+            self._initialized_schemas.add(schema_name)
+            logger.info("Schema ready: %s", schema_name)
+        except Exception as e:
+            logger.error("Schema initialization failed for %s: %s", schema_name, e)
+            raise AuthenticationError(f"Failed to initialize tenant: {e!s}")
+
+    async def list_tenants(self) -> list[Tenant]:
+        """Return all tenant schemas that have been initialized."""
+        return [Tenant(schema=schema) for schema in self._initialized_schemas]
+
+    # ------------------------------------------------------------------
+    # Health check
+    # ------------------------------------------------------------------
+
+    async def _health_check(self) -> None:
+        """Verify connectivity to Supabase using the auth health endpoint."""
+        try:
+            response = await self._http_client.get(
+                f"{self.supabase_url}/auth/v1/health",
+                headers={"apikey": self.supabase_service_key},
+            )
+            if response.status_code == 200:
+                logger.info("Supabase connection verified")
+            else:
+                logger.warning("Supabase health check returned %d", response.status_code)
+        except Exception as e:
+            logger.warning("Could not verify Supabase connection: %s", e)
@@ -1,20 +1,60 @@
 """Built-in tenant extension implementations."""

+from hindsight_api.config import get_config
 from hindsight_api.extensions.tenant import AuthenticationError, Tenant, TenantContext, TenantExtension
 from hindsight_api.models import RequestContext


+class DefaultTenantExtension(TenantExtension):
+    """
+    Default single-tenant extension with no authentication.
+
+    This is the default extension used when no tenant extension is configured.
+    It provides single-tenant behavior using the configured schema from
+    HINDSIGHT_API_DATABASE_SCHEMA (defaults to 'public').
+
+    Features:
+    - No authentication required (passes all requests)
+    - Uses configured schema from environment
+    - Perfect for single-tenant deployments without auth
+
+    Configuration:
+        HINDSIGHT_API_DATABASE_SCHEMA=your-schema (optional, defaults to 'public')
+
+    This is automatically enabled by default. To use custom authentication,
+    configure a different tenant extension:
+        HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
+    """
+
+    def __init__(self, config: dict[str, str]):
+        super().__init__(config)
+        # Cache the schema at initialization for consistency
+        # Support explicit schema override via config, otherwise use environment
+        self._schema = config.get("schema", get_config().database_schema)
+
+    async def authenticate(self, context: RequestContext) -> TenantContext:
+        """Return configured schema without any authentication."""
+        return TenantContext(schema_name=self._schema)
+
+    async def list_tenants(self) -> list[Tenant]:
+        """Return configured schema for single-tenant setup."""
+        return [Tenant(schema=self._schema)]
+
+
 class ApiKeyTenantExtension(TenantExtension):
    """
    Built-in tenant extension that validates API key against an environment variable.

    This is a simple implementation that:
    1. Validates the API key matches HINDSIGHT_API_TENANT_API_KEY
-    2. Returns 'public' as the schema for all authenticated requests
+    2. Returns the configured schema (HINDSIGHT_API_DATABASE_SCHEMA, default 'public')
+       for all authenticated requests

    Configuration:
        HINDSIGHT_API_TENANT_EXTENSION=hindsight_api.extensions.builtin.tenant:ApiKeyTenantExtension
        HINDSIGHT_API_TENANT_API_KEY=your-secret-key
+        HINDSIGHT_API_DATABASE_SCHEMA=your-schema (optional, defaults to 'public')
+        HINDSIGHT_API_TENANT_MCP_AUTH_DISABLED=true (optional, disable auth for MCP endpoints)

    For multi-tenant setups with separate schemas per tenant, implement a custom
    TenantExtension that looks up the schema based on the API key or token claims.
@@ -25,13 +65,26 @@ class ApiKeyTenantExtension(TenantExtension):
        self.expected_api_key = config.get("api_key")
        if not self.expected_api_key:
            raise ValueError("HINDSIGHT_API_TENANT_API_KEY is required when using ApiKeyTenantExtension")
+        # Allow disabling MCP auth for backwards compatibility
+        self.mcp_auth_disabled = config.get("mcp_auth_disabled", "").lower() in ("true", "1", "yes")

    async def authenticate(self, context: RequestContext) -> TenantContext:
-        """Validate API key and return public schema context."""
+        """Validate API key and return configured schema context."""
        if context.api_key != self.expected_api_key:
            raise AuthenticationError("Invalid API key")
-        return TenantContext(schema_name="public")
+        return TenantContext(schema_name=get_config().database_schema)

    async def list_tenants(self) -> list[Tenant]:
-        """Return public schema for single-tenant setup."""
-        return [Tenant(schema="public")]
+        """Return configured schema for single-tenant setup."""
+        return [Tenant(schema=get_config().database_schema)]
+
+    async def authenticate_mcp(self, context: RequestContext) -> TenantContext:
+        """
+        Authenticate MCP requests.
+
+        If mcp_auth_disabled is set, skip authentication for backwards compatibility.
+        Otherwise, delegate to authenticate().
+        """
+        if self.mcp_auth_disabled:
+            return TenantContext(schema_name=get_config().database_schema)
+        return await self.authenticate(context)
@@ -0,0 +1,42 @@
+"""MCP Extension for registering additional MCP tools.
+
+This extension allows external packages (like hindsight-cloud) to register
+additional MCP tools on the Hindsight MCP server.
+
+Example:
+    HINDSIGHT_API_MCP_EXTENSION=hindsight_cloud.extensions:CloudMCPExtension
+"""
+
+import logging
+from abc import abstractmethod
+
+from fastmcp import FastMCP
+
+from hindsight_api import MemoryEngine
+from hindsight_api.extensions.base import Extension
+
+logger = logging.getLogger(__name__)
+
+
+class MCPExtension(Extension):
+    """Base class for MCP extensions that register additional tools.
+
+    Subclass this to add MCP tools in extension packages.
+
+    Example:
+        class CloudMCPExtension(MCPExtension):
+            def register_tools(self, mcp: FastMCP, memory: MemoryEngine) -> None:
+                @mcp.tool()
+                async def my_custom_tool(query: str) -> str:
+                    return "result"
+    """
+
+    @abstractmethod
+    def register_tools(self, mcp: FastMCP, memory: MemoryEngine) -> None:
+        """Register additional MCP tools.
+
+        Args:
+            mcp: FastMCP server instance to register tools on
+            memory: MemoryEngine instance for accessing memory operations
+        """
+        pass
@@ -196,6 +196,57 @@ class ConsolidateResult:
    error: str | None = None


+# =============================================================================
+# Mental Model Contexts
+# =============================================================================
+
+
+@dataclass
+class MentalModelGetContext:
+    """Context for a mental model GET operation validation (pre-operation)."""
+
+    bank_id: str
+    mental_model_id: str
+    request_context: "RequestContext"
+
+
+@dataclass
+class MentalModelRefreshContext:
+    """Context for a mental model refresh/create operation validation (pre-operation)."""
+
+    bank_id: str
+    mental_model_id: str | None  # None for create (not yet assigned)
+    request_context: "RequestContext"
+
+
+@dataclass
+class MentalModelGetResult:
+    """Result context for post-mental-model-GET hook."""
+
+    bank_id: str
+    mental_model_id: str
+    request_context: "RequestContext"
+    output_tokens: int  # tokens in the returned content
+    success: bool = True
+    error: str | None = None
+
+
+@dataclass
+class MentalModelRefreshResult:
+    """Result context for post-mental-model-refresh hook."""
+
+    bank_id: str
+    mental_model_id: str
+    request_context: "RequestContext"
+    query_tokens: int  # tokens in source_query
+    output_tokens: int  # tokens in generated content
+    context_tokens: int  # tokens in context (if any)
+    facts_used: int  # facts referenced in based_on
+    mental_models_used: int  # mental models referenced in based_on
+    success: bool = True
+    error: str | None = None
+
+
 class OperationValidatorExtension(Extension, ABC):
    """
    Validates and hooks into retain/recall/reflect/consolidate operations.
@@ -402,3 +453,81 @@ class OperationValidatorExtension(Extension, ABC):
                - error: Error message (if failed)
        """
        pass
+
+    # =========================================================================
+    # Mental Model - Pre-operation validation hook (optional - override to implement)
+    # =========================================================================
+
+    async def validate_mental_model_get(self, ctx: MentalModelGetContext) -> ValidationResult:
+        """
+        Validate a mental model GET operation before execution.
+
+        Override to implement custom validation logic for mental model retrieval.
+
+        Args:
+            ctx: Context containing:
+                - bank_id: Bank identifier
+                - mental_model_id: Mental model identifier
+                - request_context: Request context with auth info
+
+        Returns:
+            ValidationResult indicating whether the operation is allowed.
+        """
+        return ValidationResult.accept()
+
+    async def validate_mental_model_refresh(self, ctx: MentalModelRefreshContext) -> ValidationResult:
+        """
+        Validate a mental model refresh/create operation before execution.
+
+        Override to implement custom validation logic for mental model refresh.
+
+        Args:
+            ctx: Context containing:
+                - bank_id: Bank identifier
+                - mental_model_id: Mental model identifier (None for create)
+                - request_context: Request context with auth info
+
+        Returns:
+            ValidationResult indicating whether the operation is allowed.
+        """
+        return ValidationResult.accept()
+
+    # =========================================================================
+    # Mental Model - Post-operation hooks (optional - override to implement)
+    # =========================================================================
+
+    async def on_mental_model_get_complete(self, result: MentalModelGetResult) -> None:
+        """
+        Called after a mental model GET operation completes (success or failure).
+
+        Override to implement post-operation logic such as tracking or audit logging.
+
+        Args:
+            result: Result context containing:
+                - bank_id: Bank identifier
+                - mental_model_id: Mental model identifier
+                - output_tokens: Token count of the returned content
+                - success: Whether the operation succeeded
+                - error: Error message (if failed)
+        """
+        pass
+
+    async def on_mental_model_refresh_complete(self, result: MentalModelRefreshResult) -> None:
+        """
+        Called after a mental model refresh operation completes (success or failure).
+
+        Override to implement post-operation logic such as tracking or audit logging.
+
+        Args:
+            result: Result context containing:
+                - bank_id: Bank identifier
+                - mental_model_id: Mental model identifier
+                - query_tokens: Tokens in source_query
+                - output_tokens: Tokens in generated content
+                - context_tokens: Tokens in context
+                - facts_used: Number of facts referenced
+                - mental_models_used: Number of mental models referenced
+                - success: Whether the operation succeeded
+                - error: Error message (if failed)
+        """
+        pass
@@ -87,3 +87,22 @@ class TenantExtension(Extension, ABC):
            For single-tenant setups, return [Tenant(schema="public")].
        """
        ...
+
+    async def authenticate_mcp(self, context: RequestContext) -> TenantContext:
+        """
+        Authenticate MCP requests.
+
+        By default, this calls authenticate(). Override this method to provide
+        different authentication behavior for MCP endpoints (e.g., to disable
+        auth for backwards compatibility with existing MCP servers).
+
+        Args:
+            context: The action context containing API key and other auth data.
+
+        Returns:
+            TenantContext with the schema_name for database operations.
+
+        Raises:
+            AuthenticationError: If authentication fails.
+        """
+        return await self.authenticate(context)
@@ -20,14 +20,13 @@ import warnings

 import uvicorn

-from . import MemoryEngine
+from . import MemoryEngine, __version__
 from .api import create_app
 from .banner import print_banner
 from .config import DEFAULT_WORKERS, ENV_WORKERS, HindsightConfig, get_config
 from .daemon import (
    DEFAULT_DAEMON_PORT,
    DEFAULT_IDLE_TIMEOUT,
-    DaemonLock,
    IdleTimeoutMiddleware,
    daemonize,
 )
@@ -136,30 +135,15 @@ def main():

    # Daemon mode handling
    if args.daemon:
-        # Use fixed daemon port
-        args.port = DEFAULT_DAEMON_PORT
+        # Use port from args (may be custom for profiles)
+        if args.port == config.port:  # No custom port specified
+            args.port = DEFAULT_DAEMON_PORT
        args.host = "127.0.0.1"  # Only bind to localhost for security

-        # Check if another daemon is already running
-        daemon_lock = DaemonLock()
-        if not daemon_lock.acquire():
-            print(f"Daemon already running (PID: {daemon_lock.get_pid()})", file=sys.stderr)
-            sys.exit(1)
-
        # Fork into background
+        # No lockfile needed - port binding prevents duplicate daemons
        daemonize()

-        # Re-acquire lock in child process
-        daemon_lock = DaemonLock()
-        if not daemon_lock.acquire():
-            sys.exit(1)
-
-        # Register cleanup to release lock
-        def release_lock():
-            daemon_lock.release()
-
-        atexit.register(release_lock)
-
    # Print banner (not in daemon mode)
    if not args.daemon:
        print()
@@ -170,31 +154,56 @@ def main():
    if args.log_level != config.log_level:
        config = HindsightConfig(
            database_url=config.database_url,
+            database_schema=config.database_schema,
            llm_provider=config.llm_provider,
            llm_api_key=config.llm_api_key,
            llm_model=config.llm_model,
            llm_base_url=config.llm_base_url,
            llm_max_concurrent=config.llm_max_concurrent,
+            llm_max_retries=config.llm_max_retries,
+            llm_initial_backoff=config.llm_initial_backoff,
+            llm_max_backoff=config.llm_max_backoff,
            llm_timeout=config.llm_timeout,
+            llm_vertexai_project_id=config.llm_vertexai_project_id,
+            llm_vertexai_region=config.llm_vertexai_region,
+            llm_vertexai_service_account_key=config.llm_vertexai_service_account_key,
            retain_llm_provider=config.retain_llm_provider,
            retain_llm_api_key=config.retain_llm_api_key,
            retain_llm_model=config.retain_llm_model,
            retain_llm_base_url=config.retain_llm_base_url,
+            retain_llm_max_concurrent=config.retain_llm_max_concurrent,
+            retain_llm_max_retries=config.retain_llm_max_retries,
+            retain_llm_initial_backoff=config.retain_llm_initial_backoff,
+            retain_llm_max_backoff=config.retain_llm_max_backoff,
+            retain_llm_timeout=config.retain_llm_timeout,
            reflect_llm_provider=config.reflect_llm_provider,
            reflect_llm_api_key=config.reflect_llm_api_key,
            reflect_llm_model=config.reflect_llm_model,
            reflect_llm_base_url=config.reflect_llm_base_url,
+            reflect_llm_max_concurrent=config.reflect_llm_max_concurrent,
+            reflect_llm_max_retries=config.reflect_llm_max_retries,
+            reflect_llm_initial_backoff=config.reflect_llm_initial_backoff,
+            reflect_llm_max_backoff=config.reflect_llm_max_backoff,
+            reflect_llm_timeout=config.reflect_llm_timeout,
            consolidation_llm_provider=config.consolidation_llm_provider,
            consolidation_llm_api_key=config.consolidation_llm_api_key,
            consolidation_llm_model=config.consolidation_llm_model,
            consolidation_llm_base_url=config.consolidation_llm_base_url,
+            consolidation_llm_max_concurrent=config.consolidation_llm_max_concurrent,
+            consolidation_llm_max_retries=config.consolidation_llm_max_retries,
+            consolidation_llm_initial_backoff=config.consolidation_llm_initial_backoff,
+            consolidation_llm_max_backoff=config.consolidation_llm_max_backoff,
+            consolidation_llm_timeout=config.consolidation_llm_timeout,
            embeddings_provider=config.embeddings_provider,
            embeddings_local_model=config.embeddings_local_model,
+            embeddings_local_force_cpu=config.embeddings_local_force_cpu,
            embeddings_tei_url=config.embeddings_tei_url,
            embeddings_openai_base_url=config.embeddings_openai_base_url,
            embeddings_cohere_base_url=config.embeddings_cohere_base_url,
            reranker_provider=config.reranker_provider,
            reranker_local_model=config.reranker_local_model,
+            reranker_local_force_cpu=config.reranker_local_force_cpu,
+            reranker_local_max_concurrent=config.reranker_local_max_concurrent,
            reranker_tei_url=config.reranker_tei_url,
            reranker_tei_batch_size=config.reranker_tei_batch_size,
            reranker_tei_max_concurrent=config.reranker_tei_max_concurrent,
@@ -214,9 +223,9 @@ def main():
            retain_extract_causal_links=config.retain_extract_causal_links,
            retain_extraction_mode=config.retain_extraction_mode,
            retain_custom_instructions=config.retain_custom_instructions,
-            retain_observations_async=config.retain_observations_async,
            enable_observations=config.enable_observations,
            consolidation_batch_size=config.consolidation_batch_size,
+            consolidation_max_tokens=config.consolidation_max_tokens,
            skip_llm_verification=config.skip_llm_verification,
            lazy_reranker=config.lazy_reranker,
            run_migrations_on_startup=config.run_migrations_on_startup,
@@ -228,8 +237,9 @@ def main():
            worker_id=config.worker_id,
            worker_poll_interval_ms=config.worker_poll_interval_ms,
            worker_max_retries=config.worker_max_retries,
-            worker_batch_size=config.worker_batch_size,
            worker_http_port=config.worker_http_port,
+            worker_max_slots=config.worker_max_slots,
+            worker_consolidation_max_slots=config.worker_consolidation_max_slots,
            reflect_max_iterations=config.reflect_max_iterations,
            mental_model_refresh_concurrency=config.mental_model_refresh_concurrency,
        )
@@ -336,11 +346,13 @@ def main():
            embeddings_provider=config.embeddings_provider,
            reranker_provider=config.reranker_provider,
            mcp_enabled=config.mcp_enabled,
+            version=__version__,
        )

    # Start idle checker in daemon mode
    if idle_middleware is not None:
        # Start the idle checker in a background thread with its own event loop
+        import logging
        import threading

        def run_idle_checker():
@@ -351,12 +363,12 @@ def main():
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                loop.run_until_complete(idle_middleware._check_idle())
-            except Exception:
-                pass
+            except Exception as e:
+                logging.error(f"Idle checker error: {e}", exc_info=True)

        threading.Thread(target=run_idle_checker, daemon=True).start()

-    uvicorn.run(**uvicorn_config)  # type: ignore[invalid-argument-type] - dict kwargs
+    uvicorn.run(**uvicorn_config)


 if __name__ == "__main__":
@@ -32,6 +32,15 @@ class MCPToolsConfig:
    # How to resolve bank_id for operations
    bank_id_resolver: Callable[[], str | None]

+    # How to resolve API key for tenant auth (optional)
+    api_key_resolver: Callable[[], str | None] | None = None
+
+    # How to resolve tenant_id for usage metering (set by MCP middleware after auth)
+    tenant_id_resolver: Callable[[], str | None] | None = None
+
+    # How to resolve api_key_id for usage metering (set by MCP middleware after auth)
+    api_key_id_resolver: Callable[[], str | None] | None = None
+
    # Whether to include bank_id as a parameter on tools (for multi-bank support)
    include_bank_id_param: bool = False

@@ -46,6 +55,18 @@ class MCPToolsConfig:
    retain_fire_and_forget: bool = False  # If True, use asyncio.create_task pattern


+def _get_request_context(config: MCPToolsConfig) -> RequestContext:
+    """Create RequestContext with auth details from resolvers.
+
+    This enables tenant auth and usage metering to work with MCP tools by propagating
+    the authentication results from the MCP middleware to the memory engine.
+    """
+    api_key = config.api_key_resolver() if config.api_key_resolver else None
+    tenant_id = config.tenant_id_resolver() if config.tenant_id_resolver else None
+    api_key_id = config.api_key_id_resolver() if config.api_key_id_resolver else None
+    return RequestContext(api_key=api_key, tenant_id=tenant_id, api_key_id=api_key_id)
+
+
 def parse_timestamp(timestamp: str) -> datetime | None:
    """Parse an ISO format timestamp string.

@@ -155,12 +176,14 @@ def _register_retain(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig)
                if error:
                    return {"status": "error", "message": error}

+                request_context = _get_request_context(config)
+
                async def _retain():
                    try:
                        await memory.retain_batch_async(
                            bank_id=target_bank,
                            contents=[content_dict],
-                            request_context=RequestContext(),
+                            request_context=request_context,
                        )
                    except Exception as e:
                        logger.error(f"Error storing memory: {e}", exc_info=True)
@@ -196,16 +219,17 @@ def _register_retain(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig)
                        return f"Error: {error}"

                    contents = [content_dict]
+                    request_context = _get_request_context(config)
                    if async_processing:
                        result = await memory.submit_async_retain(
-                            bank_id=target_bank, contents=contents, request_context=RequestContext()
+                            bank_id=target_bank, contents=contents, request_context=request_context
                        )
                        return f"Memory queued for background processing (operation_id: {result.get('operation_id', 'N/A')})"
                    else:
                        await memory.retain_batch_async(
                            bank_id=target_bank,
                            contents=contents,
-                            request_context=RequestContext(),
+                            request_context=request_context,
                        )
                        return f"Memory stored successfully in bank '{target_bank}'"
                except Exception as e:
@@ -237,12 +261,14 @@ def _register_retain(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig)
            if error:
                return {"status": "error", "message": error}

+            request_context = _get_request_context(config)
+
            async def _retain():
                try:
                    await memory.retain_batch_async(
                        bank_id=target_bank,
                        contents=[content_dict],
-                        request_context=RequestContext(),
+                        request_context=request_context,
                    )
                except Exception as e:
                    logger.error(f"Error storing memory: {e}", exc_info=True)
@@ -280,7 +306,7 @@ def _register_recall(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig)
                    fact_type=list(VALID_RECALL_FACT_TYPES),
                    budget=Budget.HIGH,
                    max_tokens=max_tokens,
-                    request_context=RequestContext(),
+                    request_context=_get_request_context(config),
                )

                return recall_result.model_dump_json(indent=2)
@@ -311,7 +337,7 @@ def _register_recall(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig)
                    fact_type=list(VALID_RECALL_FACT_TYPES),
                    budget=Budget.HIGH,
                    max_tokens=max_tokens,
-                    request_context=RequestContext(),
+                    request_context=_get_request_context(config),
                )

                return recall_result.model_dump()
@@ -370,7 +396,7 @@ def _register_reflect(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig
                    query=query,
                    budget=budget_enum,
                    context=context,
-                    request_context=RequestContext(),
+                    request_context=_get_request_context(config),
                )

                return reflect_result.model_dump_json(indent=2)
@@ -423,7 +449,7 @@ def _register_reflect(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig
                    query=query,
                    budget=budget_enum,
                    context=context,
-                    request_context=RequestContext(),
+                    request_context=_get_request_context(config),
                )

                return reflect_result.model_dump()
@@ -447,7 +473,7 @@ def _register_list_banks(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsCon
            JSON list of banks with their IDs, names, dispositions, and missions.
        """
        try:
-            banks = await memory.list_banks(request_context=RequestContext())
+            banks = await memory.list_banks(request_context=_get_request_context(config))
            return json.dumps({"banks": banks}, indent=2)
        except Exception as e:
            logger.error(f"Error listing banks: {e}", exc_info=True)
@@ -471,8 +497,9 @@ def _register_create_bank(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsCo
            mission: Optional mission describing who the agent is and what they're trying to accomplish
        """
        try:
+            request_context = _get_request_context(config)
            # get_bank_profile auto-creates bank if it doesn't exist
-            profile = await memory.get_bank_profile(bank_id, request_context=RequestContext())
+            profile = await memory.get_bank_profile(bank_id, request_context=request_context)

            # Update name/mission if provided
            if name is not None or mission is not None:
@@ -480,10 +507,10 @@ def _register_create_bank(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsCo
                    bank_id,
                    name=name,
                    mission=mission,
-                    request_context=RequestContext(),
+                    request_context=request_context,
                )
                # Fetch updated profile
-                profile = await memory.get_bank_profile(bank_id, request_context=RequestContext())
+                profile = await memory.get_bank_profile(bank_id, request_context=request_context)

            # Serialize disposition if it's a Pydantic model
            if "disposition" in profile and hasattr(profile["disposition"], "model_dump"):
@@ -189,7 +189,7 @@ class MetricsCollectorBase:
        Args:
            provider: LLM provider name (openai, anthropic, gemini, groq, ollama, lmstudio)
            model: Model name
-            scope: Scope identifier (e.g., "memory", "reflect", "entity_observation")
+            scope: Scope identifier (e.g., "memory", "reflect", "consolidation")
            duration: Call duration in seconds
            input_tokens: Number of input/prompt tokens
            output_tokens: Number of output/completion tokens
@@ -321,7 +321,7 @@ class MetricsCollector(MetricsCollectorBase):
                pass

        Args:
-            operation: Operation name (retain, recall, reflect, entity_observation)
+            operation: Operation name (retain, recall, reflect, consolidation)
            bank_id: Memory bank ID
            source: Source of the operation (api, reflect, internal)
            budget: Optional budget level (low, mid, high)
@@ -371,7 +371,7 @@ class MetricsCollector(MetricsCollectorBase):
        Args:
            provider: LLM provider name (openai, anthropic, gemini, groq, ollama, lmstudio)
            model: Model name
-            scope: Scope identifier (e.g., "memory", "reflect", "entity_observation")
+            scope: Scope identifier (e.g., "memory", "reflect", "consolidation")
            duration: Call duration in seconds
            input_tokens: Number of input/prompt tokens
            output_tokens: Number of output/completion tokens
@@ -25,6 +25,8 @@ from alembic.config import Config
 from alembic.script.revision import ResolutionError
 from sqlalchemy import create_engine, text

+from .utils import mask_network_location
+
 logger = logging.getLogger(__name__)

 # Advisory lock ID for migrations (arbitrary unique number)
@@ -54,7 +56,7 @@ def _run_migrations_internal(database_url: str, script_location: str, schema: st
    """
    schema_name = schema or "public"
    logger.info(f"Running database migrations to head for schema '{schema_name}'...")
-    logger.info(f"Database URL: {database_url}")
+    logger.info(f"Database URL: {mask_network_location(database_url)}")
    logger.info(f"Script location: {script_location}")

    # Create Alembic configuration programmatically (no alembic.ini needed)
@@ -165,6 +167,81 @@ def run_migrations(
            logger.debug("Migration advisory lock acquired")

            try:
+                # Ensure pgvector extension is installed globally BEFORE schema migrations
+                # This is critical: the extension must exist database-wide before any schema
+                # migrations run, otherwise custom schemas won't have access to vector types
+                logger.debug("Checking pgvector extension availability...")
+
+                # First, check if extension already exists
+                ext_check = conn.execute(
+                    text(
+                        "SELECT extname, nspname FROM pg_extension e "
+                        "JOIN pg_namespace n ON e.extnamespace = n.oid "
+                        "WHERE extname = 'vector'"
+                    )
+                ).fetchone()
+
+                if ext_check:
+                    # Extension exists - check if in correct schema
+                    ext_schema = ext_check[1]
+                    if ext_schema == "public":
+                        logger.info("pgvector extension found in public schema - ready to use")
+                    else:
+                        # Extension in wrong schema - try to fix if we have permissions
+                        logger.warning(
+                            f"pgvector extension found in schema '{ext_schema}' instead of 'public'. "
+                            f"Attempting to relocate..."
+                        )
+                        try:
+                            conn.execute(text("DROP EXTENSION vector CASCADE"))
+                            conn.execute(text("SET search_path TO public"))
+                            conn.execute(text("CREATE EXTENSION vector"))
+                            conn.commit()
+                            logger.info("pgvector extension relocated to public schema")
+                        except Exception as e:
+                            # Failed to relocate - log but don't fail if extension exists somewhere
+                            logger.warning(
+                                f"Could not relocate pgvector extension to public schema: {e}. "
+                                f"Continuing with extension in '{ext_schema}' schema."
+                            )
+                            conn.rollback()
+                else:
+                    # Extension doesn't exist - try to install
+                    logger.info("pgvector extension not found, attempting to install...")
+                    try:
+                        conn.execute(text("SET search_path TO public"))
+                        conn.execute(text("CREATE EXTENSION vector"))
+                        conn.commit()
+                        logger.info("pgvector extension installed in public schema")
+                    except Exception as e:
+                        # Installation failed - this is only fatal if extension truly doesn't exist
+                        # Check one more time in case another process installed it
+                        conn.rollback()
+                        ext_recheck = conn.execute(
+                            text(
+                                "SELECT nspname FROM pg_extension e "
+                                "JOIN pg_namespace n ON e.extnamespace = n.oid "
+                                "WHERE extname = 'vector'"
+                            )
+                        ).fetchone()
+
+                        if ext_recheck:
+                            logger.warning(
+                                f"Could not install pgvector extension (permission denied?), "
+                                f"but extension exists in '{ext_recheck[0]}' schema. Continuing..."
+                            )
+                        else:
+                            # Extension truly doesn't exist and we can't install it
+                            logger.error(
+                                f"pgvector extension is not installed and cannot be installed: {e}. "
+                                f"Please ensure pgvector is installed by a database administrator. "
+                                f"See: https://github.com/pgvector/pgvector#installation"
+                            )
+                            raise RuntimeError(
+                                "pgvector extension is required but not installed. "
+                                "Please install it with: CREATE EXTENSION vector;"
+                            ) from e
+
                # Run migrations while holding the lock
                _run_migrations_internal(database_url, script_location, schema=schema)
            finally:
@@ -40,7 +40,7 @@ class EmbeddedPostgres:
            # Only set port if explicitly specified
            if self.port is not None:
                kwargs["port"] = self.port
-            self._pg0 = Pg0(**kwargs)  # type: ignore[invalid-argument-type] - dict kwargs
+            self._pg0 = Pg0(**kwargs)
        return self._pg0

    async def start(self, max_retries: int = 5, retry_delay: float = 4.0) -> str:
@@ -0,0 +1,13 @@
+from urllib.parse import urlparse, urlunparse
+
+
+def mask_network_location(url):
+    if not url:
+        return url
+    parsed_url = urlparse(url)
+    masked_network_location = parsed_url.hostname or ""
+    if parsed_url.port:
+        masked_network_location += f":{parsed_url.port}"
+    if parsed_url.username or parsed_url.password:
+        masked_network_location = f"***:***@{masked_network_location}"
+    return urlunparse(parsed_url._replace(netloc=masked_network_location))
@@ -124,12 +124,6 @@ def main():
        default=config.worker_poll_interval_ms,
        help=f"Poll interval in milliseconds (default: {config.worker_poll_interval_ms}, env: HINDSIGHT_API_WORKER_POLL_INTERVAL_MS)",
    )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=config.worker_batch_size,
-        help=f"Tasks to claim per poll (default: {config.worker_batch_size}, env: HINDSIGHT_API_WORKER_BATCH_SIZE)",
-    )
    parser.add_argument(
        "--max-retries",
        type=int,
@@ -168,8 +162,9 @@ def main():

    print(f"Starting Hindsight Worker: {args.worker_id}")
    print(f"  Poll interval: {args.poll_interval}ms")
-    print(f"  Batch size: {args.batch_size}")
    print(f"  Max retries: {args.max_retries}")
+    print(f"  Max slots: {config.worker_max_slots}")
+    print(f"  Consolidation max slots: {config.worker_consolidation_max_slots}")
    print(f"  HTTP server: {args.http_host}:{args.http_port}")
    print()

@@ -181,7 +176,19 @@ def main():
        nonlocal memory, poller
        import uvicorn

-        from ..extensions import TenantExtension, load_extension
+        from ..extensions import OperationValidatorExtension, TenantExtension, load_extension
+
+        # Load tenant extension BEFORE creating MemoryEngine so it can
+        # set correct schema context during task execution. Without this,
+        # _authenticate_tenant sees no extension and resets schema to "public",
+        # causing worker writes to land in the wrong schema.
+        tenant_extension = load_extension("TENANT", TenantExtension)
+
+        # Load operation validator so workers can record usage metering
+        # for async operations (e.g. refresh_mental_model after consolidation)
+        operation_validator = load_extension("OPERATION_VALIDATOR", OperationValidatorExtension)
+        if operation_validator:
+            logger.info(f"Loaded operation validator: {operation_validator.__class__.__name__}")

        # Initialize MemoryEngine
        # Workers use SyncTaskBackend because they execute tasks directly,
@@ -189,43 +196,63 @@ def main():
        memory = MemoryEngine(
            run_migrations=False,  # Workers don't run migrations
            task_backend=SyncTaskBackend(),
+            tenant_extension=tenant_extension,
+            operation_validator=operation_validator,
        )

        await memory.initialize()

        print(f"Database connected: {config.database_url}")

-        # Load tenant extension for dynamic schema discovery
-        tenant_extension = load_extension("TENANT", TenantExtension)
-
        if tenant_extension:
            print("Tenant extension loaded - schemas will be discovered dynamically on each poll")
        else:
-            print("No tenant extension configured, using public schema only")
+            print(f"No tenant extension configured, using schema: {config.database_schema}")

        # Create a single poller that handles all schemas dynamically
+        # Convert default schema to None for SQL compatibility (no schema prefix)
+        from hindsight_api.config import DEFAULT_DATABASE_SCHEMA
+
+        schema = None if config.database_schema == DEFAULT_DATABASE_SCHEMA else config.database_schema
        poller = WorkerPoller(
            pool=memory._pool,
            worker_id=args.worker_id,
            executor=memory.execute_task,
            poll_interval_ms=args.poll_interval,
-            batch_size=args.batch_size,
            max_retries=args.max_retries,
+            schema=schema,
            tenant_extension=tenant_extension,
+            max_slots=config.worker_max_slots,
+            consolidation_max_slots=config.worker_consolidation_max_slots,
        )

        # Create the HTTP app for metrics/health
        app = create_worker_app(poller, memory)

-        # Setup signal handlers for graceful shutdown
+        # Setup signal handlers for graceful shutdown using asyncio
        shutdown_requested = asyncio.Event()
+        force_exit = False

-        def signal_handler(signum, frame):
-            print(f"\nReceived signal {signum}, initiating graceful shutdown...")
-            shutdown_requested.set()
+        loop = asyncio.get_event_loop()

-        signal.signal(signal.SIGINT, signal_handler)
-        signal.signal(signal.SIGTERM, signal_handler)
+        def signal_handler():
+            nonlocal force_exit
+            if shutdown_requested.is_set():
+                # Second signal = force exit
+                print("\nReceived second signal, forcing immediate exit...")
+                force_exit = True
+                # Restore default handler so third signal kills process
+                loop.remove_signal_handler(signal.SIGINT)
+                loop.remove_signal_handler(signal.SIGTERM)
+                sys.exit(1)
+            else:
+                print("\nReceived shutdown signal, initiating graceful shutdown...")
+                print("(Press Ctrl+C again to force immediate exit)")
+                shutdown_requested.set()
+
+        # Use asyncio's signal handlers which work properly with the event loop
+        loop.add_signal_handler(signal.SIGINT, signal_handler)
+        loop.add_signal_handler(signal.SIGTERM, signal_handler)

        # Create uvicorn config and server
        uvicorn_config = uvicorn.Config(
@@ -244,7 +271,10 @@ def main():
        print(f"Worker started. Metrics available at http://{args.http_host}:{args.http_port}/metrics")

        # Wait for shutdown signal
-        await shutdown_requested.wait()
+        try:
+            await shutdown_requested.wait()
+        except KeyboardInterrupt:
+            print("\nReceived interrupt, initiating graceful shutdown...")

        # Graceful shutdown
        print("Shutting down HTTP server...")
@@ -57,10 +57,11 @@ class WorkerPoller:
        worker_id: str,
        executor: Callable[[dict[str, Any]], Awaitable[None]],
        poll_interval_ms: int = 500,
-        batch_size: int = 10,
        max_retries: int = 3,
        schema: str | None = None,
        tenant_extension: "TenantExtension | None" = None,
+        max_slots: int = 10,
+        consolidation_max_slots: int = 2,
    ):
        """
        Initialize the worker poller.
@@ -70,91 +71,158 @@ class WorkerPoller:
            worker_id: Unique identifier for this worker
            executor: Async function to execute tasks (typically MemoryEngine.execute_task)
            poll_interval_ms: Interval between polls when no tasks found (milliseconds)
-            batch_size: Maximum number of tasks to claim per poll cycle
            max_retries: Maximum retry attempts before marking task as failed
-            schema: Database schema for single-tenant support (ignored if tenant_extension is set)
-            tenant_extension: Extension for dynamic multi-tenant discovery. If set, list_tenants()
-                            is called on each poll cycle to discover schemas dynamically.
+            schema: Database schema for single-tenant support (deprecated, use tenant_extension)
+            tenant_extension: Extension for dynamic multi-tenant discovery. If None, creates a
+                            DefaultTenantExtension with the configured schema.
+            max_slots: Maximum concurrent tasks per worker
+            consolidation_max_slots: Maximum concurrent consolidation tasks per worker
        """
        self._pool = pool
        self._worker_id = worker_id
        self._executor = executor
        self._poll_interval_ms = poll_interval_ms
-        self._batch_size = batch_size
        self._max_retries = max_retries
        self._schema = schema
+        # Always set tenant extension (use DefaultTenantExtension if none provided)
+        if tenant_extension is None:
+            from ..extensions.builtin.tenant import DefaultTenantExtension
+
+            # Pass schema parameter to DefaultTenantExtension if explicitly provided
+            config = {"schema": schema} if schema else {}
+            tenant_extension = DefaultTenantExtension(config=config)
        self._tenant_extension = tenant_extension
+        self._max_slots = max_slots
+        self._consolidation_max_slots = consolidation_max_slots
        self._shutdown = asyncio.Event()
        self._current_tasks: set[asyncio.Task] = set()
        self._in_flight_count = 0
        self._in_flight_lock = asyncio.Lock()
        self._last_progress_log = 0.0
        self._tasks_completed_since_log = 0
-        # Track active tasks locally: operation_id -> (op_type, bank_id, schema)
-        self._active_tasks: dict[str, tuple[str, str, str | None]] = {}
+        # Track active tasks locally: operation_id -> (op_type, bank_id, schema, asyncio.Task)
+        self._active_tasks: dict[str, tuple[str, str, str | None, asyncio.Task]] = {}
+        # Track in-flight tasks by operation type
+        self._in_flight_by_type: dict[str, int] = {}

    async def _get_schemas(self) -> list[str | None]:
-        """Get list of schemas to poll. Returns [None] for public schema."""
-        if self._tenant_extension is not None:
-            tenants = await self._tenant_extension.list_tenants()
-            # Convert "public" to None for SQL compatibility, keep others as-is
-            return [t.schema if t.schema != "public" else None for t in tenants]
-        # Single schema mode
-        return [self._schema]
+        """Get list of schemas to poll. Returns [None] for default schema (no prefix)."""
+        from ..config import DEFAULT_DATABASE_SCHEMA
+
+        tenants = await self._tenant_extension.list_tenants()
+        # Convert default schema to None for SQL compatibility (no prefix), keep others as-is
+        return [t.schema if t.schema != DEFAULT_DATABASE_SCHEMA else None for t in tenants]
+
+    async def _get_available_slots(self) -> tuple[int, int]:
+        """
+        Calculate available slots for claiming tasks.
+
+        Returns:
+            (total_available, consolidation_available) tuple
+        """
+        async with self._in_flight_lock:
+            total_in_flight = self._in_flight_count
+            consolidation_in_flight = self._in_flight_by_type.get("consolidation", 0)
+
+        total_available = max(0, self._max_slots - total_in_flight)
+        consolidation_available = max(0, self._consolidation_max_slots - consolidation_in_flight)
+
+        return total_available, consolidation_available
+
+    async def wait_for_active_tasks(self, timeout: float = 10.0) -> bool:
+        """
+        Wait for all active background tasks to complete (test helper).
+
+        This is a test-only utility that allows tests to synchronize with
+        fire-and-forget background tasks without using sleep().
+
+        Args:
+            timeout: Maximum time to wait in seconds
+
+        Returns:
+            True if all tasks completed, False if timeout was reached
+        """
+        start_time = asyncio.get_event_loop().time()
+        while True:
+            async with self._in_flight_lock:
+                if self._in_flight_count == 0:
+                    return True
+
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed >= timeout:
+                return False
+
+            # Short sleep to avoid busy-waiting
+            await asyncio.sleep(0.01)

    async def claim_batch(self) -> list[ClaimedTask]:
        """
-        Claim up to batch_size pending tasks atomically across all tenant schemas.
+        Claim pending tasks atomically across all tenant schemas,
+        respecting slot limits (total and consolidation).

        Uses FOR UPDATE SKIP LOCKED to ensure no conflicts with other workers.

-        For consolidation tasks specifically, skips pending tasks if there's already
-        a processing consolidation for the same bank (to avoid duplicate work).
-
-        If tenant_extension is configured, dynamically discovers schemas on each call.
-
        Returns:
            List of ClaimedTask objects containing operation_id, task_dict, and schema
        """
+        # Calculate available slots
+        total_available, consolidation_available = await self._get_available_slots()
+
+        if total_available <= 0:
+            return []
+
        schemas = await self._get_schemas()
        all_tasks: list[ClaimedTask] = []
-        remaining_batch = self._batch_size
+        remaining_total = total_available
+        remaining_consolidation = consolidation_available

        for schema in schemas:
-            if remaining_batch <= 0:
+            if remaining_total <= 0:
                break

-            tasks = await self._claim_batch_for_schema(schema, remaining_batch)
+            tasks = await self._claim_batch_for_schema(schema, remaining_total, remaining_consolidation)
+
+            # Update remaining slots based on what was claimed
+            for task in tasks:
+                op_type = task.task_dict.get("operation_type", "unknown")
+                if op_type == "consolidation":
+                    remaining_consolidation -= 1
+
            all_tasks.extend(tasks)
-            remaining_batch -= len(tasks)
+            remaining_total -= len(tasks)

        return all_tasks

-    async def _claim_batch_for_schema(self, schema: str | None, limit: int) -> list[ClaimedTask]:
-        """Claim tasks from a specific schema."""
+    async def _claim_batch_for_schema(
+        self, schema: str | None, limit: int, consolidation_limit: int
+    ) -> list[ClaimedTask]:
+        """Claim tasks from a specific schema respecting slot limits."""
+        try:
+            return await self._claim_batch_for_schema_inner(schema, limit, consolidation_limit)
+        except Exception as e:
+            # Format schema for logging: custom schemas in quotes, None as-is
+            schema_display = f'"{schema}"' if schema else str(schema)
+            logger.warning(f"Worker {self._worker_id} failed to claim tasks for schema {schema_display}: {e}")
+            return []
+
+    async def _claim_batch_for_schema_inner(
+        self, schema: str | None, limit: int, consolidation_limit: int
+    ) -> list[ClaimedTask]:
+        """Inner implementation for claiming tasks from a specific schema with slot limits."""
        table = fq_table("async_operations", schema)

        async with self._pool.acquire() as conn:
            async with conn.transaction():
-                # Select and lock pending tasks
-                # For consolidation: skip if same bank already has one processing
-                rows = await conn.fetch(
+                # Strategy: Claim non-consolidation tasks first, then consolidation up to limit
+
+                # 1. Claim non-consolidation tasks (up to limit)
+                non_consolidation_rows = await conn.fetch(
                    f"""
                    SELECT operation_id, task_payload
-                    FROM {table} AS pending
-                    WHERE status = 'pending' AND task_payload IS NOT NULL
-                    AND (
-                        -- Non-consolidation tasks: always claimable
-                        operation_type != 'consolidation'
-                        OR
-                        -- Consolidation: only if no other consolidation processing for same bank
-                        NOT EXISTS (
-                            SELECT 1 FROM {table} AS processing
-                            WHERE processing.bank_id = pending.bank_id
-                            AND processing.operation_type = 'consolidation'
-                            AND processing.status = 'processing'
-                        )
-                    )
+                    FROM {table}
+                    WHERE status = 'pending'
+                      AND task_payload IS NOT NULL
+                      AND operation_type != 'consolidation'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED
@@ -162,11 +230,39 @@ class WorkerPoller:
                    limit,
                )

-                if not rows:
+                claimed_count = len(non_consolidation_rows)
+                remaining_limit = limit - claimed_count
+
+                # 2. Claim consolidation tasks (up to consolidation_limit and remaining_limit)
+                consolidation_rows = []
+                if consolidation_limit > 0 and remaining_limit > 0:
+                    consolidation_rows = await conn.fetch(
+                        f"""
+                        SELECT operation_id, task_payload
+                        FROM {table} AS pending
+                        WHERE status = 'pending'
+                          AND task_payload IS NOT NULL
+                          AND operation_type = 'consolidation'
+                          AND NOT EXISTS (
+                              SELECT 1 FROM {table} AS processing
+                              WHERE processing.bank_id = pending.bank_id
+                                AND processing.operation_type = 'consolidation'
+                                AND processing.status = 'processing'
+                          )
+                        ORDER BY created_at
+                        LIMIT $1
+                        FOR UPDATE SKIP LOCKED
+                        """,
+                        min(consolidation_limit, remaining_limit),
+                    )
+
+                all_rows = non_consolidation_rows + consolidation_rows
+
+                if not all_rows:
                    return []

                # Claim the tasks by updating status and worker_id
-                operation_ids = [row["operation_id"] for row in rows]
+                operation_ids = [row["operation_id"] for row in all_rows]
                await conn.execute(
                    f"""
                    UPDATE {table}
@@ -184,7 +280,7 @@ class WorkerPoller:
                        task_dict=json.loads(row["task_payload"]),
                        schema=schema,
                    )
-                    for row in rows
+                    for row in all_rows
                ]

    async def _mark_completed(self, operation_id: str, schema: str | None):
@@ -250,18 +346,43 @@ class WorkerPoller:
            logger.warning(f"Task {operation_id} failed, will retry (attempt {retry_count + 1}/{self._max_retries})")

    async def execute_task(self, task: ClaimedTask):
-        """Execute a single task and update its status."""
+        """Execute a single task as a background job (fire-and-forget)."""
        task_type = task.task_dict.get("type", "unknown")
+        operation_type = task.task_dict.get("operation_type", "unknown")
        bank_id = task.task_dict.get("bank_id", "unknown")

+        # Create background task
+        bg_task = asyncio.create_task(self._execute_task_inner(task))
+
        # Track this task as active
        async with self._in_flight_lock:
-            self._active_tasks[task.operation_id] = (task_type, bank_id, task.schema)
+            self._active_tasks[task.operation_id] = (task_type, bank_id, task.schema, bg_task)
+            self._in_flight_count += 1
+            self._in_flight_by_type[operation_type] = self._in_flight_by_type.get(operation_type, 0) + 1
+
+        # Add cleanup callback
+        bg_task.add_done_callback(lambda _: asyncio.create_task(self._cleanup_task(task.operation_id, operation_type)))
+
+    async def _cleanup_task(self, operation_id: str, operation_type: str):
+        """Remove task from tracking after completion."""
+        async with self._in_flight_lock:
+            if operation_id in self._active_tasks:
+                self._active_tasks.pop(operation_id, None)
+                self._in_flight_count -= 1
+                count = self._in_flight_by_type.get(operation_type, 0)
+                if count > 0:
+                    self._in_flight_by_type[operation_type] = count - 1
+                    if self._in_flight_by_type[operation_type] == 0:
+                        del self._in_flight_by_type[operation_type]
+
+    async def _execute_task_inner(self, task: ClaimedTask):
+        """Inner task execution with error handling."""
+        task_type = task.task_dict.get("type", "unknown")
+        bank_id = task.task_dict.get("bank_id", "unknown")

        try:
            schema_info = f", schema={task.schema}" if task.schema else ""
            logger.debug(f"Executing task {task.operation_id} (type={task_type}, bank={bank_id}{schema_info})")
-            # Pass schema to executor so it can set the correct context
            if task.schema:
                task.task_dict["_schema"] = task.schema
            await self._executor(task.task_dict)
@@ -271,10 +392,6 @@ class WorkerPoller:
            error_msg = f"{type(e).__name__}: {e}\n{traceback.format_exc()}"
            logger.error(f"Task {task.operation_id} failed: {e}")
            await self._retry_or_fail(task.operation_id, error_msg, task.schema)
-        finally:
-            # Remove from active tasks
-            async with self._in_flight_lock:
-                self._active_tasks.pop(task.operation_id, None)

    async def recover_own_tasks(self) -> int:
        """
@@ -293,20 +410,25 @@ class WorkerPoller:
        total_count = 0

        for schema in schemas:
-            table = fq_table("async_operations", schema)
+            try:
+                table = fq_table("async_operations", schema)

-            result = await self._pool.execute(
-                f"""
-                UPDATE {table}
-                SET status = 'pending', worker_id = NULL, claimed_at = NULL, updated_at = now()
-                WHERE status = 'processing' AND worker_id = $1
-                """,
-                self._worker_id,
-            )
+                result = await self._pool.execute(
+                    f"""
+                    UPDATE {table}
+                    SET status = 'pending', worker_id = NULL, claimed_at = NULL, updated_at = now()
+                    WHERE status = 'processing' AND worker_id = $1
+                    """,
+                    self._worker_id,
+                )

-            # Parse "UPDATE N" to get count
-            count = int(result.split()[-1]) if result else 0
-            total_count += count
+                # Parse "UPDATE N" to get count
+                count = int(result.split()[-1]) if result else 0
+                total_count += count
+            except Exception as e:
+                # Format schema for logging: custom schemas in quotes, None as-is
+                schema_display = f'"{schema}"' if schema else str(schema)
+                logger.warning(f"Worker {self._worker_id} failed to recover tasks for schema {schema_display}: {e}")

        if total_count > 0:
            logger.info(f"Worker {self._worker_id} recovered {total_count} stale tasks from previous run")
@@ -314,59 +436,60 @@ class WorkerPoller:

    async def run(self):
        """
-        Main polling loop.
+        Main polling loop with fire-and-forget task execution.

-        Continuously polls for pending tasks, claims them, and executes them
-        until shutdown is signaled.
-
-        If tenant_extension is configured, dynamically discovers schemas on each poll.
+        Continuously polls for pending tasks, spawns them as background tasks,
+        and immediately continues polling (up to slot limits).
        """
-        # Recover any tasks from a previous crash before starting
        await self.recover_own_tasks()

-        logger.info(f"Worker {self._worker_id} starting polling loop")
+        logger.info(
+            f"Worker {self._worker_id} starting polling loop "
+            f"(max_slots={self._max_slots}, consolidation_max_slots={self._consolidation_max_slots})"
+        )

        while not self._shutdown.is_set():
            try:
-                # Claim a batch of tasks (across all tenant schemas if configured)
+                # Claim a batch of tasks (respecting slot limits)
                tasks = await self.claim_batch()

                if tasks:
                    # Log batch info
                    task_types: dict[str, int] = {}
                    schemas_seen: set[str | None] = set()
+                    consolidation_count = 0
                    for task in tasks:
                        t = task.task_dict.get("type", "unknown")
+                        op_type = task.task_dict.get("operation_type", "unknown")
                        task_types[t] = task_types.get(t, 0) + 1
                        schemas_seen.add(task.schema)
+                        if op_type == "consolidation":
+                            consolidation_count += 1
+
                    types_str = ", ".join(f"{k}:{v}" for k, v in task_types.items())
-                    schemas_str = ", ".join(s or "public" for s in schemas_seen)
+                    # Display None as "default" in logs
+                    schemas_str = ", ".join(s if s else "default" for s in schemas_seen)
                    logger.info(
-                        f"Worker {self._worker_id} claimed {len(tasks)} tasks: {types_str} (schemas: {schemas_str})"
+                        f"Worker {self._worker_id} claimed {len(tasks)} tasks "
+                        f"({consolidation_count} consolidation): {types_str} (schemas: {schemas_str})"
                    )

-                    # Track in-flight tasks
-                    async with self._in_flight_lock:
-                        self._in_flight_count += len(tasks)
+                    # Spawn tasks as background jobs (fire-and-forget)
+                    for task in tasks:
+                        await self.execute_task(task)

-                    # Execute tasks concurrently
-                    try:
-                        await asyncio.gather(
-                            *[self.execute_task(task) for task in tasks],
-                            return_exceptions=True,
-                        )
-                    finally:
-                        async with self._in_flight_lock:
-                            self._in_flight_count -= len(tasks)
-                else:
-                    # No tasks found, wait before polling again
-                    try:
-                        await asyncio.wait_for(
-                            self._shutdown.wait(),
-                            timeout=self._poll_interval_ms / 1000,
-                        )
-                    except asyncio.TimeoutError:
-                        pass  # Normal timeout, continue polling
+                    # Continue immediately to claim more tasks (if slots available)
+                    continue
+
+                # No tasks claimed (either no pending tasks or slots full)
+                # Wait before polling again
+                try:
+                    await asyncio.wait_for(
+                        self._shutdown.wait(),
+                        timeout=self._poll_interval_ms / 1000,
+                    )
+                except asyncio.TimeoutError:
+                    pass  # Normal timeout, continue polling

                # Log progress stats periodically
                await self._log_progress_if_due()
@@ -397,15 +520,27 @@ class WorkerPoller:
        while asyncio.get_event_loop().time() - start_time < timeout:
            async with self._in_flight_lock:
                in_flight = self._in_flight_count
+                active_task_objects = [task_info[3] for task_info in self._active_tasks.values()]

            if in_flight == 0:
                logger.info(f"Worker {self._worker_id} graceful shutdown complete")
                return

            logger.info(f"Worker {self._worker_id} waiting for {in_flight} in-flight tasks")
-            await asyncio.sleep(0.5)

-        logger.warning(f"Worker {self._worker_id} shutdown timeout after {timeout}s")
+            # Wait for at least one task to complete
+            if active_task_objects:
+                done, _ = await asyncio.wait(active_task_objects, timeout=0.5, return_when=asyncio.FIRST_COMPLETED)
+            else:
+                await asyncio.sleep(0.5)
+
+        logger.warning(f"Worker {self._worker_id} shutdown timeout after {timeout}s, cancelling remaining tasks")
+
+        # Cancel remaining tasks
+        async with self._in_flight_lock:
+            for operation_id, (_, _, _, bg_task) in list(self._active_tasks.items()):
+                if not bg_task.done():
+                    bg_task.cancel()

    async def _log_progress_if_due(self):
        """Log progress stats every PROGRESS_LOG_INTERVAL seconds."""
@@ -416,14 +551,19 @@ class WorkerPoller:
        self._last_progress_log = now

        try:
-            # Get local active tasks (this worker only)
+            # Get local active tasks
            async with self._in_flight_lock:
                in_flight = self._in_flight_count
-                active_tasks = dict(self._active_tasks)  # Copy to avoid holding lock
+                in_flight_by_type = dict(self._in_flight_by_type)
+                active_tasks = dict(self._active_tasks)

-            # Build local processing breakdown grouped by (op_type, bank_id)
+            consolidation_count = in_flight_by_type.get("consolidation", 0)
+            available_slots = self._max_slots - in_flight
+            available_consolidation_slots = self._consolidation_max_slots - consolidation_count
+
+            # Build local processing breakdown
            task_groups: dict[tuple[str, str], int] = {}
-            for op_type, bank_id, _ in active_tasks.values():
+            for op_type, bank_id, _, _ in active_tasks.values():
                key = (op_type, bank_id)
                task_groups[key] = task_groups.get(key, 0) + 1

@@ -432,7 +572,7 @@ class WorkerPoller:
            if len(processing_info) > 10:
                processing_str += f" +{len(processing_info) - 10} more"

-            # Get global stats from DB across all schemas
+            # Get global stats from DB
            schemas = await self._get_schemas()
            global_pending = 0
            all_worker_counts: dict[str, int] = {}
@@ -444,7 +584,6 @@ class WorkerPoller:
                    row = await conn.fetchrow(f"SELECT COUNT(*) as count FROM {table} WHERE status = 'pending'")
                    global_pending += row["count"] if row else 0

-                    # Get processing breakdown by worker
                    worker_rows = await conn.fetch(
                        f"""
                        SELECT worker_id, COUNT(*) as count
@@ -457,16 +596,18 @@ class WorkerPoller:
                        wid = wr["worker_id"] or "unknown"
                        all_worker_counts[wid] = all_worker_counts.get(wid, 0) + wr["count"]

-            # Format other workers' processing counts
            other_workers = []
            for wid, cnt in all_worker_counts.items():
                if wid != self._worker_id:
                    other_workers.append(f"{wid}:{cnt}")
            others_str = ", ".join(other_workers) if other_workers else "none"

-            schemas_str = ", ".join(s or "public" for s in schemas)
+            # Display None as "default" in logs
+            schemas_str = ", ".join(s if s else "default" for s in schemas)
            logger.info(
-                f"[WORKER_STATS] worker={self._worker_id} in_flight={in_flight} | "
+                f"[WORKER_STATS] worker={self._worker_id} "
+                f"slots={in_flight}/{self._max_slots} (consolidation={consolidation_count}/{self._consolidation_max_slots}) | "
+                f"available={available_slots} (consolidation={available_consolidation_slots}) | "
                f"global: pending={global_pending} (schemas: {schemas_str}) | "
                f"others: {others_str} | "
                f"my_active: {processing_str}"
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "hindsight-api"
-version = "0.4.0"
+version = "0.4.10"
 description = "Hindsight: Agent Memory That Works Like Human Memory"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,7 +25,8 @@ dependencies = [
    "psycopg2-binary>=2.9.11",
    "tiktoken>=0.12.0",
    "httpx>=0.27.0",
-    "fastmcp>=2.14.0",  # CVE-2025-66416
+    "PyJWT[crypto]>=2.8.0",
+    "fastmcp>=2.14.0", # CVE-2025-66416
    "pg0-embedded>=0.11.0",
    "python-dateutil>=2.8.0",
    "opentelemetry-api>=1.20.0",
@@ -34,22 +35,24 @@ dependencies = [
    "opentelemetry-exporter-prometheus>=0.41b0",
    "dateparser>=1.2.2",
    "google-genai>=1.0.0",
+    "google-auth>=2.0.0",
    "anthropic>=0.40.0",
    "typer>=0.9.0",
    "cohere>=5.0.0",
    "flashrank>=0.2.0",
    # Local ML models for embeddings/reranking - can be excluded in Docker with INCLUDE_LOCAL_MODELS=false
    "sentence-transformers>=3.3.0",
-    "transformers>=4.53.0",  # Security fixes for ReDoS vulnerabilities
-    "torch>=2.6.0",  # CVE fix for remote code execution
+    "transformers>=4.53.0", # Security fixes for ReDoS vulnerabilities
+    "torch>=2.6.0", # CVE fix for remote code execution
    "uvloop>=0.22.1",
    # Transitive dependency security fixes
-    "pyasn1>=0.6.2",  # DoS vulnerability fix
-    "urllib3>=2.6.3",  # Decompression-bomb safeguards bypass fix
-    "langchain-core>=1.2.5",  # Serialization injection vulnerability fix
-    "filelock>=3.20.1",  # TOCTOU race condition fix
-    "authlib>=1.6.6",  # Account takeover vulnerability fix
-    "aiohttp>=3.13.3",  # Multiple DoS vulnerabilities
+    "pyasn1>=0.6.2", # DoS vulnerability fix
+    "urllib3>=2.6.3", # Decompression-bomb safeguards bypass fix
+    "langchain-core>=1.2.5", # Serialization injection vulnerability fix
+    "filelock>=3.20.1", # TOCTOU race condition fix
+    "authlib>=1.6.6", # Account takeover vulnerability fix
+    "aiohttp>=3.13.3", # Multiple DoS vulnerabilities
+    "claude-agent-sdk>=0.1.27",
 ]

 [project.optional-dependencies]
@@ -141,6 +144,11 @@ known-third-party = ["alembic"]
 quote-style = "double"
 indent-style = "space"

+[tool.uv]
+# Allow uv to search all configured indexes for packages, not just the first one
+# This prevents dependency resolution failures when using pytorch index + PyPI
+index-strategy = "unsafe-best-match"
+
 [tool.ty]
 # Type checking configuration
 # ty is an extremely fast Python type checker from Astral (same team as ruff/uv)
@@ -220,3 +220,34 @@ async def memory(pg0_db_url, embeddings, cross_encoder, query_analyzer):
            await mem.close()
    except Exception:
        pass
+
+
+@pytest_asyncio.fixture(scope="function")
+async def memory_no_llm_verify(pg0_db_url, embeddings, cross_encoder, query_analyzer):
+    """
+    Provide a MemoryEngine instance that skips LLM connection verification.
+
+    This fixture is useful for tests that override the LLM configuration
+    after initialization (e.g., to test specific providers).
+    """
+    mem = MemoryEngine(
+        db_url=pg0_db_url,
+        memory_llm_provider="mock",  # Use mock provider as placeholder
+        memory_llm_api_key="",
+        memory_llm_model="mock",
+        embeddings=embeddings,
+        cross_encoder=cross_encoder,
+        query_analyzer=query_analyzer,
+        pool_min_size=1,
+        pool_max_size=5,
+        run_migrations=False,
+        task_backend=SyncTaskBackend(),
+        skip_llm_verification=True,  # Skip verification - will be overridden by test
+    )
+    await mem.initialize()
+    yield mem
+    try:
+        if mem._pool and not mem._pool._closing:
+            await mem.close()
+    except Exception:
+        pass
@@ -0,0 +1,109 @@
+"""
+Tests for configuration validation.
+
+Verifies that config validation catches invalid parameter combinations.
+"""
+
+import os
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def setup_test_env():
+    """Set up environment for each test, restoring original values after."""
+    from hindsight_api.config import clear_config_cache
+
+    # Save original environment values
+    env_vars_to_save = [
+        "HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS",
+        "HINDSIGHT_API_RETAIN_CHUNK_SIZE",
+        "HINDSIGHT_API_LLM_PROVIDER",
+        "HINDSIGHT_API_LLM_MODEL",
+    ]
+
+    # Save original values
+    original_values = {}
+    for key in env_vars_to_save:
+        original_values[key] = os.environ.get(key)
+
+    clear_config_cache()
+
+    yield
+
+    # Restore original environment
+    for key, original_value in original_values.items():
+        if original_value is None:
+            os.environ.pop(key, None)
+        else:
+            os.environ[key] = original_value
+
+    clear_config_cache()
+
+
+def test_retain_max_completion_tokens_must_be_greater_than_chunk_size():
+    """Test that RETAIN_MAX_COMPLETION_TOKENS > RETAIN_CHUNK_SIZE validation works."""
+    from hindsight_api.config import HindsightConfig
+
+    # Set invalid config: max_completion_tokens <= chunk_size
+    os.environ["HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS"] = "1000"
+    os.environ["HINDSIGHT_API_RETAIN_CHUNK_SIZE"] = "2000"
+    os.environ["HINDSIGHT_API_LLM_PROVIDER"] = "mock"
+
+    # Should raise ValueError with helpful message
+    with pytest.raises(ValueError) as exc_info:
+        HindsightConfig.from_env()
+
+    error_message = str(exc_info.value)
+
+    # Verify error message contains helpful information
+    assert "HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS" in error_message
+    assert "1000" in error_message
+    assert "HINDSIGHT_API_RETAIN_CHUNK_SIZE" in error_message
+    assert "2000" in error_message
+    assert "must be greater than" in error_message
+    assert "You have two options to fix this:" in error_message
+    assert "Increase HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS" in error_message
+    assert "Use a model that supports" in error_message
+
+
+def test_retain_max_completion_tokens_equal_to_chunk_size_fails():
+    """Test that RETAIN_MAX_COMPLETION_TOKENS == RETAIN_CHUNK_SIZE also fails."""
+    from hindsight_api.config import HindsightConfig
+
+    # Set invalid config: max_completion_tokens == chunk_size
+    os.environ["HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS"] = "3000"
+    os.environ["HINDSIGHT_API_RETAIN_CHUNK_SIZE"] = "3000"
+    os.environ["HINDSIGHT_API_LLM_PROVIDER"] = "mock"
+
+    # Should raise ValueError
+    with pytest.raises(ValueError) as exc_info:
+        HindsightConfig.from_env()
+
+    error_message = str(exc_info.value)
+    assert "must be greater than" in error_message
+
+
+def test_valid_retain_config_succeeds():
+    """Test that valid config with max_completion_tokens > chunk_size works."""
+    from hindsight_api.config import HindsightConfig
+
+    # Set valid config: max_completion_tokens > chunk_size
+    os.environ["HINDSIGHT_API_RETAIN_MAX_COMPLETION_TOKENS"] = "64000"
+    os.environ["HINDSIGHT_API_RETAIN_CHUNK_SIZE"] = "3000"
+    os.environ["HINDSIGHT_API_LLM_PROVIDER"] = "mock"
+
+    # Should not raise
+    config = HindsightConfig.from_env()
+    assert config.retain_max_completion_tokens == 64000
+    assert config.retain_chunk_size == 3000
+
+
+# Note: The BadRequestError wrapping is implemented in fact_extraction.py
+# but requires a complex integration test setup. The functionality is
+# straightforward: when a BadRequestError containing keywords like
+# "max_tokens", "max_completion_tokens", or "maximum context" is caught,
+# it's wrapped in a ValueError with helpful guidance.
+#
+# The config validation tests above ensure users get early feedback
+# about invalid configurations before runtime errors occur.
@@ -346,11 +346,11 @@ class TestConsolidationIntegration:
        or when one directly updates another (e.g., location change).

        Given:
-        - "Nicolò lives in Italy"
-        - "Nicolò moved to the US recently" (updates the living location)
+        - "Alex lives in Italy"
+        - "Alex moved to the US recently" (updates the living location)

        The second fact should UPDATE the first, not create a separate observation.
-        But unrelated facts like "Nicolò works at Vectorize" should stay separate.
+        But unrelated facts like "Alex works at Vectorize" should stay separate.
        """
        bank_id = f"test-consolidation-merge-{uuid.uuid4().hex[:8]}"

@@ -360,14 +360,14 @@ class TestConsolidationIntegration:
        # Retain a memory about living location
        await memory.retain_async(
            bank_id=bank_id,
-            content="Nicolò lives in Italy.",
+            content="Alex lives in Italy.",
            request_context=request_context,
        )

        # Retain an unrelated memory (different topic - should NOT merge)
        await memory.retain_async(
            bank_id=bank_id,
-            content="Nicolò works at Vectorize as an engineer.",
+            content="Alex works at Vectorize as an engineer.",
            request_context=request_context,
        )

@@ -384,7 +384,7 @@ class TestConsolidationIntegration:
        # Add a memory that UPDATES the living location (should merge with first)
        await memory.retain_async(
            bank_id=bank_id,
-            content="Nicolò recently moved to the United States.",
+            content="Alex recently moved to the United States.",
            request_context=request_context,
        )

@@ -485,9 +485,9 @@ class TestConsolidationIntegration:
        they should be merged into ONE observation that captures the change.

        Example:
-        - "Nicolò loves pizza"
-        - "Nicolò hates pizza"
-        → Should become: "Nicolò used to love pizza but now hates it" (or similar)
+        - "Alex loves pizza"
+        - "Alex hates pizza"
+        → Should become: "Alex used to love pizza but now hates it" (or similar)
        """
        bank_id = f"test-consolidation-contradict-{uuid.uuid4().hex[:8]}"

@@ -497,7 +497,7 @@ class TestConsolidationIntegration:
        # Add initial fact
        await memory.retain_async(
            bank_id=bank_id,
-            content="Nicolò loves pizza.",
+            content="Alex loves pizza.",
            request_context=request_context,
        )

@@ -515,7 +515,7 @@ class TestConsolidationIntegration:
        # Add contradicting fact (same person, same topic, opposite sentiment)
        await memory.retain_async(
            bank_id=bank_id,
-            content="Nicolò hates pizza.",
+            content="Alex hates pizza.",
            request_context=request_context,
        )

@@ -1,148 +0,0 @@
-"""
-Tests for XPC error recovery in LocalSTCrossEncoder.
-
-This tests the automatic reinitialization of the cross-encoder model when
-XPC connection errors occur on macOS (common in long-running daemon processes).
-"""
-
-import asyncio
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from hindsight_api.engine.cross_encoder import LocalSTCrossEncoder
-
-
-class TestCrossEncoderXPCErrorRecovery:
-    """Tests for XPC error detection and recovery in LocalSTCrossEncoder."""
-
-    @pytest.fixture
-    def cross_encoder(self):
-        """Create a LocalSTCrossEncoder instance."""
-        return LocalSTCrossEncoder(model_name="cross-encoder/ms-marco-TinyBERT-L-2-v2")
-
-    def test_is_xpc_error_detection(self, cross_encoder):
-        """Test that XPC errors are correctly detected."""
-        # Test various XPC error message formats
-        xpc_error = Exception("Compiler encountered XPC_ERROR_CONNECTION_INVALID (is the OS shutting down?)")
-        assert cross_encoder._is_xpc_error(xpc_error)
-
-        xpc_error2 = Exception("XPC error occurred")
-        assert cross_encoder._is_xpc_error(xpc_error2)
-
-        # Test that non-XPC errors are not detected
-        normal_error = Exception("Some other error")
-        assert not cross_encoder._is_xpc_error(normal_error)
-
-    @pytest.mark.asyncio
-    async def test_predict_with_xpc_recovery(self, cross_encoder):
-        """Test that predict() recovers from XPC errors by reinitializing."""
-        # Initialize the cross-encoder
-        await cross_encoder.initialize()
-
-        # Track calls to reinitialize
-        reinit_called = False
-        original_reinit = cross_encoder._reinitialize_model_sync
-
-        def track_reinit():
-            nonlocal reinit_called
-            reinit_called = True
-            original_reinit()
-
-        # Track predict attempts
-        predict_attempts = []
-        original_predict = cross_encoder._model.predict
-
-        def mock_predict(*args, **kwargs):
-            predict_attempts.append(1)
-            # Only fail on first attempt
-            if len(predict_attempts) == 1:
-                raise RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID (is the OS shutting down?)")
-            else:
-                # After reinit: succeed
-                return original_predict(*args, **kwargs)
-
-        # Mock the initial predict to fail, reinit happens, then new model succeeds
-        with patch.object(cross_encoder, "_reinitialize_model_sync", side_effect=track_reinit):
-            with patch.object(cross_encoder._model, "predict", side_effect=mock_predict):
-                # This should trigger XPC error on first attempt, then recover and succeed
-                result = await cross_encoder.predict([("query", "document")])
-
-                # Verify we got a result
-                assert result is not None
-                assert len(result) == 1
-                assert isinstance(result[0], float)
-                assert reinit_called  # Should have reinitialized
-                assert len(predict_attempts) >= 1  # At least one attempt was made
-
-    @pytest.mark.asyncio
-    async def test_predict_fails_on_non_xpc_error(self, cross_encoder):
-        """Test that predict() does not retry for non-XPC errors."""
-        # Initialize the cross-encoder
-        await cross_encoder.initialize()
-
-        # Create a mock that raises a non-XPC error
-        def mock_predict(*args, **kwargs):
-            raise RuntimeError("Some other error")
-
-        # Patch the model's predict method
-        with patch.object(cross_encoder._model, "predict", side_effect=mock_predict):
-            # This should fail without retry
-            with pytest.raises(RuntimeError) as exc_info:
-                await cross_encoder.predict([("query", "document")])
-
-            assert "Some other error" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_reinitialize_clears_model(self, cross_encoder):
-        """Test that _reinitialize_model_sync properly clears and reinits the model."""
-        # Initialize the cross-encoder
-        await cross_encoder.initialize()
-
-        original_model = cross_encoder._model
-        assert original_model is not None
-
-        # Reinitialize
-        cross_encoder._reinitialize_model_sync()
-
-        # Model should be reinitialized (new instance)
-        assert cross_encoder._model is not None
-        assert cross_encoder._model is not original_model
-
-        # Should still work
-        result = await cross_encoder.predict([("test query", "test document")])
-        assert len(result) == 1
-        assert isinstance(result[0], float)
-
-    @pytest.mark.asyncio
-    async def test_xpc_recovery_exhausts_retries(self, cross_encoder):
-        """Test that XPC recovery gives up after max retries."""
-        # Initialize the cross-encoder
-        await cross_encoder.initialize()
-
-        # Track reinit calls
-        reinit_count = 0
-        original_reinit = cross_encoder._reinitialize_model_sync
-
-        def track_and_fail_reinit():
-            nonlocal reinit_count
-            reinit_count += 1
-            # Call original reinit, but the new model will also be mocked to fail
-            original_reinit()
-            # After reinit, patch the new model too
-            cross_encoder._model.predict = MagicMock(
-                side_effect=RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID")
-            )
-
-        # Mock that always raises XPC error
-        cross_encoder._model.predict = MagicMock(
-            side_effect=RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID")
-        )
-
-        with patch.object(cross_encoder, "_reinitialize_model_sync", side_effect=track_and_fail_reinit):
-            # Should try once, reinitialize, try again, and fail
-            with pytest.raises(Exception) as exc_info:
-                await cross_encoder.predict([("query", "document")])
-
-            assert "XPC_ERROR_CONNECTION_INVALID" in str(exc_info.value) or "Failed to recover" in str(exc_info.value)
-            assert reinit_count == 1  # Should have tried to reinitialize once
@@ -1,148 +0,0 @@
-"""
-Tests for XPC error recovery in LocalSTEmbeddings.
-
-This tests the automatic reinitialization of the embedding model when
-XPC connection errors occur on macOS (common in long-running daemon processes).
-"""
-
-import asyncio
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from hindsight_api.engine.embeddings import LocalSTEmbeddings
-
-
-class TestXPCErrorRecovery:
-    """Tests for XPC error detection and recovery in LocalSTEmbeddings."""
-
-    @pytest.fixture
-    def embeddings(self):
-        """Create a LocalSTEmbeddings instance."""
-        return LocalSTEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-
-    def test_is_xpc_error_detection(self, embeddings):
-        """Test that XPC errors are correctly detected."""
-        # Test various XPC error message formats
-        xpc_error = Exception("Compiler encountered XPC_ERROR_CONNECTION_INVALID (is the OS shutting down?)")
-        assert embeddings._is_xpc_error(xpc_error)
-
-        xpc_error2 = Exception("XPC error occurred")
-        assert embeddings._is_xpc_error(xpc_error2)
-
-        # Test that non-XPC errors are not detected
-        normal_error = Exception("Some other error")
-        assert not embeddings._is_xpc_error(normal_error)
-
-    @pytest.mark.asyncio
-    async def test_encode_with_xpc_recovery(self, embeddings):
-        """Test that encode() recovers from XPC errors by reinitializing."""
-        # Initialize the embeddings
-        await embeddings.initialize()
-
-        # Track calls to reinitialize
-        reinit_called = False
-        original_reinit = embeddings._reinitialize_model_sync
-
-        def track_reinit():
-            nonlocal reinit_called
-            reinit_called = True
-            original_reinit()
-
-        # Track encode attempts
-        encode_attempts = []
-        original_encode = embeddings._model.encode
-
-        def mock_encode(*args, **kwargs):
-            encode_attempts.append(1)
-            # Only fail on first attempt
-            if len(encode_attempts) == 1:
-                raise RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID (is the OS shutting down?)")
-            else:
-                # After reinit: succeed
-                return original_encode(*args, **kwargs)
-
-        # Mock the initial encode to fail, reinit happens, then new model succeeds
-        with patch.object(embeddings, "_reinitialize_model_sync", side_effect=track_reinit):
-            with patch.object(embeddings._model, "encode", side_effect=mock_encode):
-                # This should trigger XPC error on first attempt, then recover and succeed
-                result = embeddings.encode(["test text"])
-
-                # Verify we got a result
-                assert result is not None
-                assert len(result) == 1
-                assert len(result[0]) > 0  # Should have embedding vector
-                assert reinit_called  # Should have reinitialized
-                assert len(encode_attempts) >= 1  # At least one attempt was made
-
-    @pytest.mark.asyncio
-    async def test_encode_fails_on_non_xpc_error(self, embeddings):
-        """Test that encode() does not retry for non-XPC errors."""
-        # Initialize the embeddings
-        await embeddings.initialize()
-
-        # Create a mock that raises a non-XPC error
-        def mock_encode(*args, **kwargs):
-            raise RuntimeError("Some other error")
-
-        # Patch the model's encode method
-        with patch.object(embeddings._model, "encode", side_effect=mock_encode):
-            # This should fail without retry
-            with pytest.raises(RuntimeError) as exc_info:
-                embeddings.encode(["test text"])
-
-            assert "Some other error" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_reinitialize_clears_model(self, embeddings):
-        """Test that _reinitialize_model_sync properly clears and reinits the model."""
-        # Initialize the embeddings
-        await embeddings.initialize()
-
-        original_model = embeddings._model
-        assert original_model is not None
-
-        # Reinitialize
-        embeddings._reinitialize_model_sync()
-
-        # Model should be reinitialized (new instance)
-        assert embeddings._model is not None
-        assert embeddings._model is not original_model
-
-        # Should still work
-        result = embeddings.encode(["test"])
-        assert len(result) == 1
-        assert len(result[0]) > 0
-
-    @pytest.mark.asyncio
-    async def test_xpc_recovery_exhausts_retries(self, embeddings):
-        """Test that XPC recovery gives up after max retries."""
-        # Initialize the embeddings
-        await embeddings.initialize()
-
-        # Track reinit calls
-        reinit_count = 0
-        original_reinit = embeddings._reinitialize_model_sync
-
-        def track_and_fail_reinit():
-            nonlocal reinit_count
-            reinit_count += 1
-            # Call original reinit, but the new model will also be mocked to fail
-            original_reinit()
-            # After reinit, patch the new model too
-            embeddings._model.encode = MagicMock(
-                side_effect=RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID")
-            )
-
-        # Mock that always raises XPC error
-        embeddings._model.encode = MagicMock(
-            side_effect=RuntimeError("Compiler encountered XPC_ERROR_CONNECTION_INVALID")
-        )
-
-        with patch.object(embeddings, "_reinitialize_model_sync", side_effect=track_and_fail_reinit):
-            # Should try once, reinitialize, try again, and fail
-            with pytest.raises(RuntimeError) as exc_info:
-                embeddings.encode(["test"])
-
-            assert "XPC_ERROR_CONNECTION_INVALID" in str(exc_info.value)
-            assert reinit_count == 1  # Should have tried to reinitialize once
@@ -58,7 +58,6 @@ async def test_fact_extraction_basic_analysis(llm_config):
        llm_config=llm_config,
        agent_name="test-agent",
        context="Friday Standup meeting",
-        extract_opinions=False,
    )

    duration = time.time() - start_time
@@ -1063,3 +1063,169 @@ async def test_retain_async_no_usage(api_client):

    # Usage should be None for async operations
    assert result.get("usage") is None, "Async retain should not include usage"
+
+
+@pytest.mark.asyncio
+async def test_version_endpoint_returns_correct_version(api_client):
+    """Test that the /version endpoint returns the correct API version.
+
+    The version should match the __version__ defined in hindsight_api.__init__.py
+    and should not be a hardcoded string.
+    """
+    from hindsight_api import __version__
+
+    # Call the /version endpoint
+    response = await api_client.get("/version")
+    assert response.status_code == 200
+    result = response.json()
+
+    # Verify response structure
+    assert "api_version" in result, "Response should include 'api_version' field"
+    assert "features" in result, "Response should include 'features' field"
+
+    # Verify the version matches the package version
+    assert result["api_version"] == __version__, (
+        f"API version should be {__version__}, got {result['api_version']}"
+    )
+
+    # Verify features field structure
+    features = result["features"]
+    assert "observations" in features
+    assert "mcp" in features
+    assert "worker" in features
+    assert isinstance(features["observations"], bool)
+    assert isinstance(features["mcp"], bool)
+    assert isinstance(features["worker"], bool)
+
+    print(f"Version endpoint returned: api_version={result['api_version']}, features={features}")
+
+
+@pytest.mark.asyncio
+async def test_retain_with_timestamp_async(api_client, test_bank_id):
+    """Test that async retain accepts timestamp field and serializes correctly."""
+    response = await api_client.post(
+        f"/v1/default/banks/{test_bank_id}/memories",
+        json={
+            "items": [
+                {
+                    "content": "Test memory with timestamp",
+                    "context": "test",
+                    "timestamp": "2026-01-30T11:45:00Z"
+                }
+            ],
+            "async": True
+        }
+    )
+    
+    assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.text}"
+    data = response.json()
+    assert data["success"] is True
+    assert data["async"] is True
+    assert "operation_id" in data
+    
+
+@pytest.mark.asyncio
+async def test_retain_with_timestamp_sync(api_client, test_bank_id):
+    """Test that sync retain accepts timestamp field."""
+    response = await api_client.post(
+        f"/v1/default/banks/{test_bank_id}/memories",
+        json={
+            "items": [
+                {
+                    "content": "Test memory with timestamp sync",
+                    "context": "test", 
+                    "timestamp": "2026-01-30T11:45:00Z"
+                }
+            ],
+            "async": False
+        }
+    )
+    
+    assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.text}"
+    data = response.json()
+    assert data["success"] is True
+    assert data["async"] is False
+    
+
+@pytest.mark.asyncio
+async def test_retain_with_multiple_timestamps(api_client, test_bank_id):
+    """Test that multiple items with different timestamp formats work."""
+    response = await api_client.post(
+        f"/v1/default/banks/{test_bank_id}/memories",
+        json={
+            "items": [
+                {
+                    "content": "Event 1",
+                    "timestamp": "2026-01-30T11:45:00Z"  # With Z
+                },
+                {
+                    "content": "Event 2", 
+                    "timestamp": "2026-01-30T12:00:00+00:00"  # With timezone
+                },
+                {
+                    "content": "Event 3"  # No timestamp
+                }
+            ],
+            "async": True
+        }
+    )
+    
+    assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.text}"
+    data = response.json()
+    assert data["success"] is True
+    assert data["items_count"] == 3
+
+
+@pytest.mark.asyncio
+async def test_retain_with_timestamp_async_complete_processing(api_client, test_bank_id):
+    """Test that async retain with timestamp completes full processing including fact extraction."""
+    # Submit async retain with timestamp
+    response = await api_client.post(
+        f"/v1/default/banks/{test_bank_id}/memories",
+        json={
+            "items": [
+                {
+                    "content": "The quarterly meeting was held on January 30th 2026",
+                    "context": "meetings",
+                    "timestamp": "2026-01-30T11:45:00Z"
+                }
+            ],
+            "async": True
+        }
+    )
+    
+    assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.text}"
+    data = response.json()
+    assert data["success"] is True
+    assert data["async"] is True
+    operation_id = data["operation_id"]
+    
+    # Wait for async processing to complete (poll operation status)
+    max_wait_seconds = 30
+    poll_interval = 0.5
+    elapsed = 0
+    operation_completed = False
+    
+    while elapsed < max_wait_seconds:
+        response = await api_client.get(f"/v1/default/banks/{test_bank_id}/operations/{operation_id}")
+        if response.status_code == 200:
+            op_status = response.json()
+            if op_status.get("status") == "completed":
+                operation_completed = True
+                break
+            elif op_status.get("status") == "failed":
+                raise AssertionError(f"Operation failed: {op_status.get('error_message')}")
+        
+        await asyncio.sleep(poll_interval)
+        elapsed += poll_interval
+    
+    assert operation_completed, f"Async operation did not complete within {max_wait_seconds} seconds"
+    
+    # Verify memories were actually stored
+    response = await api_client.get(
+        f"/v1/default/banks/{test_bank_id}/memories/list",
+        params={"limit": 10}
+    )
+    assert response.status_code == 200
+    items = response.json()["items"]
+    assert len(items) > 0, "Should have stored memories after async processing"
@@ -1,5 +1,10 @@
 """
-Test LLM provider with different models using actual memory operations.
+Test LLM provider with different models using actual Hindsight memory operations.
+
+Tests validate that providers work correctly with:
+1. Retain (memory ingestion with fact extraction)
+2. Reflect (memory retrieval with tool calling)
+3. Mental models (consolidated knowledge generation)
 """
 import os
 from datetime import datetime
@@ -19,6 +24,10 @@ MODEL_MATRIX = [
    ("openai", "gpt-5-nano"),
    ("openai", "gpt-5"),
    ("openai", "gpt-5.2"),
+    # Anthropic models
+    ("anthropic", "claude-sonnet-4-20250514"),
+    ("anthropic", "claude-opus-4-5-20251101"),
+    ("anthropic", "claude-haiku-4-20250514"),
    # Groq models
    ("groq", "openai/gpt-oss-120b"),
    ("groq", "openai/gpt-oss-20b"),
@@ -29,6 +38,12 @@ MODEL_MATRIX = [
    # Ollama models (local)
    ("ollama", "gemma3:12b"),
    ("ollama", "gemma3:1b"),
+    # Claude Code (uses Claude Agent SDK with Claude models)
+    ("claude-code", "claude-sonnet-4-20250514"),
+    # OpenAI Codex (uses MCP with Codex-specific models)
+    ("openai-codex", "gpt-5.2-codex"),
+    # Mock provider (for testing)
+    ("mock", "mock"),
 ]


@@ -36,6 +51,7 @@ def get_api_key_for_provider(provider: str) -> str | None:
    """Get API key for provider from environment variables."""
    provider_key_map = {
        "openai": "OPENAI_API_KEY",
+        "anthropic": "ANTHROPIC_API_KEY",
        "groq": "GROQ_API_KEY",
        "gemini": "GEMINI_API_KEY",
    }
@@ -43,6 +59,171 @@ def get_api_key_for_provider(provider: str) -> str | None:
    return os.getenv(env_var) if env_var else None


+def should_skip_provider(provider: str, model: str = "") -> tuple[bool, str]:
+    """Check if provider should be skipped and return reason."""
+    # Never skip mock provider
+    if provider == "mock":
+        return False, ""
+
+    # Skip claude-code and openai-codex in CI (require local auth)
+    if os.getenv("CI") and provider in ("claude-code", "openai-codex"):
+        return True, f"{provider} not available in CI (requires local authentication)"
+
+    # Skip Ollama in CI (no models available)
+    if provider == "ollama" and os.getenv("CI"):
+        return True, "Ollama not available in CI"
+
+    # Skip Ollama gemma models (don't support tool calling)
+    if provider == "ollama" and "gemma" in model.lower():
+        return True, f"Ollama {model} does not support tool calling"
+
+    # Other providers need an API key
+    if provider not in ("ollama", "claude-code", "openai-codex", "mock"):
+        api_key = get_api_key_for_provider(provider)
+        if not api_key:
+            return True, f"No API key available (set {provider.upper()}_API_KEY)"
+
+    return False, ""
+
+
+@pytest.mark.parametrize("provider,model", MODEL_MATRIX)
+@pytest.mark.asyncio
+@pytest.mark.timeout(300)  # Increase timeout for slow models like groq gpt-oss-120b
+async def test_llm_provider_api_methods(provider: str, model: str):
+    """
+    Test all LLM API methods used by Hindsight at runtime.
+    This validates that the provider correctly implements the LLMInterface.
+
+    Tests:
+    1. verify_connection() - Connection verification
+    2. call() with plain text - Basic LLM call
+    3. call() with response_format - Structured output (used in fact extraction)
+    4. call_with_tools() - Tool calling (used in reflect agent)
+    """
+    # Skip mock provider - it's a test stub, not a real LLM implementation
+    if provider == "mock":
+        pytest.skip("Mock provider is a test stub, not a real LLM")
+
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
+    api_key = get_api_key_for_provider(provider)
+
+    llm = LLMProvider(
+        provider=provider,
+        api_key=api_key or "",
+        base_url="",
+        model=model,
+    )
+
+    print(f"\n{provider}/{model} - API methods test:")
+
+    # Test 1: verify_connection()
+    try:
+        await llm.verify_connection()
+        print("  ✓ verify_connection()")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} verify_connection() failed: {e}")
+
+    # Test 2: call() with plain text
+    try:
+        response = await llm.call(
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "What is 2+2? Answer in one word."},
+            ],
+            max_completion_tokens=50,
+        )
+        assert response is not None, "call() returned None"
+        assert len(response) > 0, "call() returned empty string"
+        print(f"  ✓ call() plain text: {response[:50]}")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} call() plain text failed: {e}")
+
+    # Test 3: call() with response_format (structured output)
+    # Skip for models that don't support structured output
+    skip_structured_output = (provider == "groq" and "gpt-oss-120b" in model.lower())
+    if skip_structured_output:
+        print(f"  ⊘ call() structured output: skipped (model doesn't support response_format)")
+    else:
+        try:
+            from pydantic import BaseModel
+
+            class TestResponse(BaseModel):
+                answer: str
+                confidence: str
+
+            response = await llm.call(
+                messages=[
+                    {"role": "system", "content": "You are a math assistant."},
+                    {"role": "user", "content": "What is the capital of France?"},
+                ],
+                response_format=TestResponse,
+                max_completion_tokens=100,
+            )
+            assert isinstance(response, TestResponse), f"Expected TestResponse, got {type(response)}"
+            assert hasattr(response, "answer"), "Structured output missing 'answer' field"
+            assert hasattr(response, "confidence"), "Structured output missing 'confidence' field"
+            print(f"  ✓ call() structured output: answer={response.answer}, confidence={response.confidence}")
+        except Exception as e:
+            pytest.fail(f"{provider}/{model} call() structured output failed: {e}")
+
+    # Test 4: call_with_tools() (tool calling)
+    try:
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get the weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"},
+                            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }
+        ]
+
+        result = await llm.call_with_tools(
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant with access to tools."},
+                {"role": "user", "content": "What's the weather like in Paris?"},
+            ],
+            tools=tools,
+            max_completion_tokens=500,  # Increased from 200 to give models enough space for tool calls
+        )
+
+        assert result is not None, "call_with_tools() returned None"
+        assert hasattr(result, "tool_calls"), "Result missing 'tool_calls' attribute"
+
+        # Nano models may hit token limits before making tool calls - that's acceptable
+        is_nano_model = "nano" in model.lower()
+        if is_nano_model and len(result.tool_calls) == 0:
+            # Check if it hit length limit (expected for nano models)
+            if hasattr(result, "finish_reason") and result.finish_reason == "length":
+                print(f"  ✓ call_with_tools(): nano model hit token limit (expected)")
+            else:
+                pytest.fail(f"Nano model made 0 tool calls but didn't hit length limit (finish_reason={getattr(result, 'finish_reason', 'unknown')})")
+        else:
+            assert len(result.tool_calls) > 0, f"Expected at least 1 tool call, got {len(result.tool_calls)}"
+
+            # Verify tool call structure
+            tool_call = result.tool_calls[0]
+            assert hasattr(tool_call, "name"), "Tool call missing 'name'"
+            assert hasattr(tool_call, "arguments"), "Tool call missing 'arguments'"
+            assert tool_call.name == "get_weather", f"Expected 'get_weather', got '{tool_call.name}'"
+            assert "location" in tool_call.arguments, "Tool call arguments missing 'location'"
+
+            print(f"  ✓ call_with_tools(): {tool_call.name}({tool_call.arguments})")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} call_with_tools() failed: {e}")
+
+
@pytest.mark.parametrize("provider,model", MODEL_MATRIX)
@pytest.mark.asyncio
 async def test_llm_provider_memory_operations(provider: str, model: str):
@@ -50,16 +231,16 @@ async def test_llm_provider_memory_operations(provider: str, model: str):
    Test LLM provider with actual memory operations: fact extraction and reflect.
    All models must pass this test.
    """
+    # Skip mock provider - it's a test stub, not designed for real operations
+    if provider == "mock":
+        pytest.skip("Mock provider is a test stub, not designed for real operations")
+
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
    api_key = get_api_key_for_provider(provider)

-    # Skip Ollama tests in CI (no models available)
-    if provider == "ollama" and os.getenv("CI"):
-        pytest.skip(f"Skipping {provider}/{model}: Ollama not available in CI")
-
-    # Other providers need an API key
-    if provider != "ollama" and not api_key:
-        pytest.skip(f"Skipping {provider}/{model}: no API key available")
-
    llm = LLMProvider(
        provider=provider,
        api_key=api_key or "",
@@ -117,3 +298,115 @@ async def test_llm_provider_memory_operations(provider: str, model: str):

    assert response is not None, f"{provider}/{model} reflect returned None"
    assert len(response) > 10, f"{provider}/{model} reflect response too short"
+
+
+@pytest.mark.parametrize("provider,model", [
+    ("claude-code", "claude-sonnet-4-20250514"),
+    ("openai-codex", "gpt-5.2-codex"),
+])
+@pytest.mark.asyncio
+async def test_llm_provider_consolidation(memory_no_llm_verify, request_context, provider: str, model: str):
+    """
+    Test LLM provider with consolidation (automatic mental model generation from observations).
+    This validates that the provider can generate synthesized knowledge from raw memories.
+
+    This test is limited to claude-code and codex since they're the critical providers
+    that needed tool calling fixes for reflect and consolidation operations.
+    """
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
+    # Use provider-specific LLM for this test
+    api_key = get_api_key_for_provider(provider)
+    memory_no_llm_verify._consolidation_llm = LLMProvider(
+        provider=provider,
+        api_key=api_key or "",
+        base_url="",
+        model=model,
+    )
+    # Also need retain LLM for ingesting data
+    memory_no_llm_verify._retain_llm = memory_no_llm_verify._consolidation_llm
+
+    test_bank_id = f"llm_test_consolidation_{provider}_{model}_{datetime.now().timestamp()}"
+
+    # Enable observations for this bank
+    from hindsight_api.config import get_config
+    config = get_config()
+    original_value = config.enable_observations
+    config.enable_observations = True
+
+    try:
+        # Retain memories to consolidate
+        test_content = """
+        Bob prefers functional programming with Rust and Haskell.
+        He emphasizes immutability and pure functions in code reviews.
+        Bob advocates for type safety and compile-time guarantees.
+        He avoids mutable state and prefers declarative code patterns.
+        """
+
+        await memory_no_llm_verify.retain_async(
+            bank_id=test_bank_id,
+            content=test_content,
+            context="Team coding preferences",
+            event_date=datetime(2024, 12, 1),
+            request_context=request_context,
+        )
+
+        print(f"\n{provider}/{model} - Consolidation test:")
+
+        # Run consolidation to generate observations (mental models)
+        from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
+
+        result = await run_consolidation_job(
+            memory_engine=memory_no_llm_verify,
+            bank_id=test_bank_id,
+            request_context=request_context,
+        )
+
+        print(f"  Processed: {result.get('memories_processed', 0)} memories")
+        print(f"  Created: {result.get('observations_created', 0)} observations")
+        print(f"  Updated: {result.get('observations_updated', 0)} observations")
+
+        # Verify consolidation ran successfully
+        assert result["status"] in ["success", "no_new_memories"], f"{provider}/{model} consolidation failed"
+
+        # If observations were created, verify they contain relevant content
+        if result.get("observations_created", 0) > 0:
+            observations = await memory_no_llm_verify.list_mental_models_consolidated(
+                bank_id=test_bank_id,
+                request_context=request_context,
+            )
+
+            assert len(observations) > 0, f"{provider}/{model} consolidation created 0 observations"
+
+            # Check first observation contains relevant information
+            obs_content = observations[0].get("content", "").lower()
+            relevant_terms = ["bob", "functional", "rust", "immutab", "type"]
+            matches = [term for term in relevant_terms if term in obs_content]
+
+            print(f"  Observation preview: {observations[0].get('content', '')[:200]}...")
+            print(f"  Found {len(matches)} relevant terms: {matches}")
+
+            assert len(matches) >= 2, (
+                f"{provider}/{model} consolidated observation doesn't contain relevant info. "
+                f"Expected at least 2 of {relevant_terms}, found {len(matches)}: {matches}"
+            )
+
+    finally:
+        # Restore original config
+        config.enable_observations = original_value
+
+
+# NOTE: The tests above validate the critical Hindsight operations:
+#
+# test_llm_provider_memory_operations (ALL providers):
+#   - Fact extraction (retain): tests structured output generation
+#   - Reflect: tests memory retrieval and reasoning (uses tool calling for claude-code/codex)
+#
+# test_llm_provider_consolidation (claude-code and codex only):
+#   - Consolidation: tests automatic mental model generation from observations
+#   - Requires MemoryEngine fixture with working LLM (from .env or env vars)
+#   - Run your local LLM server OR set HINDSIGHT_API_LLM_PROVIDER/API_KEY/MODEL env vars
+#
+# For full end-to-end integration tests using the HTTP API, see tests/test_http_api_integration.py
@@ -30,7 +30,8 @@ async def test_llm_metrics_recorded_for_groq():
    # Create a mock metrics collector to track record_llm_call calls
    mock_collector = MagicMock(spec=MetricsCollector)

-    with patch("hindsight_api.engine.llm_wrapper.get_metrics_collector", return_value=mock_collector):
+    # Patch the provider module where get_metrics_collector is actually called
+    with patch("hindsight_api.engine.providers.openai_compatible_llm.get_metrics_collector", return_value=mock_collector):
        llm = LLMProvider(
            provider="groq",
            api_key=api_key,
@@ -90,7 +91,8 @@ async def test_llm_metrics_recorded_for_structured_output():

    mock_collector = MagicMock(spec=MetricsCollector)

-    with patch("hindsight_api.engine.llm_wrapper.get_metrics_collector", return_value=mock_collector):
+    # Patch the provider module where get_metrics_collector is actually called
+    with patch("hindsight_api.engine.providers.openai_compatible_llm.get_metrics_collector", return_value=mock_collector):
        llm = LLMProvider(
            provider="groq",
            api_key=api_key,
@@ -0,0 +1,78 @@
+"""Integration test for MCP endpoint routing.
+
+This test verifies that /mcp/ and /mcp/{bank_id}/ expose different tool sets.
+"""
+
+import httpx
+import pytest
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+
+
+@pytest.mark.asyncio
+async def test_mcp_endpoint_routing_integration(memory):
+    """Test that multi-bank and single-bank endpoints expose different tools using StreamableHTTP.
+
+    This is a regression test for issue #317 where /mcp/{bank_id}/ was incorrectly
+    exposing all tools (including list_banks) and bank_id parameters.
+    """
+    from hindsight_api.api import create_app
+
+    # Create app with MCP enabled
+    app = create_app(memory, mcp_api_enabled=True, initialize_memory=False)
+
+    # Use the app's lifespan context to properly initialize MCP servers
+    async with app.router.lifespan_context(app):
+        # Create an HTTPX client that routes to our ASGI app
+        from httpx import ASGITransport
+
+        async with httpx.AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as http_client:
+            # Test 1: Multi-bank endpoint /mcp/
+            async with streamable_http_client("http://test/mcp/", http_client=http_client) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    multi_result = await session.list_tools()
+
+                    multi_tools = {t.name for t in multi_result.tools}
+
+                    # Multi-bank should have all tools including bank management
+                    assert "retain" in multi_tools
+                    assert "recall" in multi_tools
+                    assert "reflect" in multi_tools
+                    assert "list_banks" in multi_tools, "Multi-bank should expose list_banks"
+                    assert "create_bank" in multi_tools, "Multi-bank should expose create_bank"
+
+                    # Multi-bank retain should have bank_id parameter
+                    retain_tool = next((t for t in multi_result.tools if t.name == "retain"), None)
+                    assert retain_tool is not None
+                    multi_params = set(retain_tool.inputSchema.get("properties", {}).keys())
+                    assert "bank_id" in multi_params, "Multi-bank retain should have bank_id parameter"
+
+            # Test 2: Single-bank endpoint /mcp/test-bank/
+            async with streamable_http_client("http://test/mcp/test-bank/", http_client=http_client) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    single_result = await session.list_tools()
+
+                    single_tools = {t.name for t in single_result.tools}
+
+                    # Single-bank should only have scoped tools (no bank management)
+                    assert "retain" in single_tools
+                    assert "recall" in single_tools
+                    assert "reflect" in single_tools
+                    assert "list_banks" not in single_tools, "Single-bank should NOT expose list_banks"
+                    assert "create_bank" not in single_tools, "Single-bank should NOT expose create_bank"
+
+                    # Single-bank retain should NOT have bank_id parameter
+                    retain_tool = next((t for t in single_result.tools if t.name == "retain"), None)
+                    assert retain_tool is not None
+                    single_params = set(retain_tool.inputSchema.get("properties", {}).keys())
+                    assert "bank_id" not in single_params, "Single-bank retain should NOT have bank_id parameter"
@@ -0,0 +1,169 @@
+"""Tests for MCPExtension loading and tool registration."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastmcp import FastMCP
+
+from hindsight_api import MemoryEngine
+from hindsight_api.extensions.mcp import MCPExtension
+
+
+class MockMCPExtension(MCPExtension):
+    """Test extension that registers a custom tool."""
+
+    def __init__(self, config=None):
+        super().__init__(config)
+        self.register_tools_called = False
+        self.registered_mcp = None
+        self.registered_memory = None
+
+    def register_tools(self, mcp: FastMCP, memory: MemoryEngine) -> None:
+        """Register a test tool to verify extension was called."""
+        self.register_tools_called = True
+        self.registered_mcp = mcp
+        self.registered_memory = memory
+
+        @mcp.tool()
+        async def test_extension_tool(query: str) -> str:
+            """A test tool registered by the extension."""
+            return f"Extension tool received: {query}"
+
+
+class TestMCPExtensionBase:
+    """Tests for MCPExtension base class."""
+
+    def test_mcp_extension_is_abstract(self):
+        """MCPExtension.register_tools is abstract and must be implemented."""
+        with pytest.raises(TypeError, match="abstract method"):
+            MCPExtension()
+
+    def test_subclass_can_be_instantiated(self):
+        """Subclass implementing register_tools can be instantiated."""
+        ext = MockMCPExtension()
+        assert ext is not None
+        assert ext.register_tools_called is False
+
+    def test_register_tools_receives_mcp_and_memory(self):
+        """register_tools receives FastMCP and MemoryEngine instances."""
+        ext = MockMCPExtension()
+        mcp = FastMCP("test")
+        memory = MagicMock(spec=MemoryEngine)
+
+        ext.register_tools(mcp, memory)
+
+        assert ext.register_tools_called is True
+        assert ext.registered_mcp is mcp
+        assert ext.registered_memory is memory
+
+
+class TestMCPExtensionLoading:
+    """Tests for MCPExtension loading in create_mcp_server."""
+
+    @pytest.fixture
+    def mock_memory(self):
+        """Create a mock MemoryEngine."""
+        memory = MagicMock()
+        memory._tenant_extension = MagicMock()
+        memory._tenant_extension.authenticate_mcp = MagicMock()
+        return memory
+
+    def test_create_mcp_server_without_extension(self, mock_memory):
+        """create_mcp_server works without MCPExtension configured."""
+        from hindsight_api.api.mcp import create_mcp_server
+
+        with patch("hindsight_api.api.mcp.load_extension", return_value=None):
+            mcp = create_mcp_server(mock_memory)
+
+        # Core tools should be registered
+        tools = mcp._tool_manager._tools
+        assert "retain" in tools
+        assert "recall" in tools
+        assert "reflect" in tools
+        # Extension tool should NOT be present
+        assert "test_extension_tool" not in tools
+
+    def test_create_mcp_server_with_extension(self, mock_memory):
+        """create_mcp_server loads and calls MCPExtension when configured."""
+        from hindsight_api.api.mcp import create_mcp_server
+
+        mock_ext = MockMCPExtension()
+
+        with patch("hindsight_api.api.mcp.load_extension", return_value=mock_ext):
+            mcp = create_mcp_server(mock_memory)
+
+        # Extension should have been called
+        assert mock_ext.register_tools_called is True
+
+        # Core tools should still be registered
+        tools = mcp._tool_manager._tools
+        assert "retain" in tools
+        assert "recall" in tools
+
+        # Extension tool should also be registered
+        assert "test_extension_tool" in tools
+
+    @pytest.mark.asyncio
+    async def test_extension_tool_is_callable(self, mock_memory):
+        """Tool registered by extension can be called."""
+        from hindsight_api.api.mcp import create_mcp_server
+
+        mock_ext = MockMCPExtension()
+
+        with patch("hindsight_api.api.mcp.load_extension", return_value=mock_ext):
+            mcp = create_mcp_server(mock_memory)
+
+        # Get and call the extension tool
+        tools = mcp._tool_manager._tools
+        test_tool = tools["test_extension_tool"]
+        result = await test_tool.fn(query="hello world")
+
+        assert result == "Extension tool received: hello world"
+
+    def test_load_extension_called_with_correct_args(self, mock_memory):
+        """load_extension is called with 'MCP' prefix and MCPExtension class."""
+        from hindsight_api.api.mcp import create_mcp_server
+
+        with patch("hindsight_api.api.mcp.load_extension") as mock_load:
+            mock_load.return_value = None
+            create_mcp_server(mock_memory)
+
+        mock_load.assert_called_once_with("MCP", MCPExtension)
+
+
+class TestMCPExtensionIntegration:
+    """Integration tests verifying extension tools work end-to-end."""
+
+    @pytest.fixture
+    def mock_memory(self):
+        """Create a mock MemoryEngine with required methods."""
+        memory = MagicMock()
+        memory.retain_batch_async = MagicMock()
+        memory.submit_async_retain = MagicMock(return_value={"operation_id": "test-op"})
+        memory.recall_async = MagicMock(return_value=MagicMock(results=[]))
+        memory.reflect_async = MagicMock(return_value=MagicMock(text="reflection"))
+        memory.list_banks = MagicMock(return_value=[])
+        memory.get_bank_profile = MagicMock(return_value={"id": "test"})
+        memory._tenant_extension = MagicMock()
+        return memory
+
+    def test_extension_tools_coexist_with_core_tools(self, mock_memory):
+        """Extension tools are added alongside core tools, not replacing them."""
+        from hindsight_api.api.mcp import create_mcp_server
+
+        mock_ext = MockMCPExtension()
+
+        with patch("hindsight_api.api.mcp.load_extension", return_value=mock_ext):
+            mcp = create_mcp_server(mock_memory)
+
+        tools = mcp._tool_manager._tools
+        # All core tools present
+        assert "retain" in tools
+        assert "recall" in tools
+        assert "reflect" in tools
+        assert "list_banks" in tools
+        assert "create_bank" in tools
+        # Extension tool also present
+        assert "test_extension_tool" in tools
+        # Total: 5 core + 1 extension = 6 tools
+        assert len(tools) == 6
@@ -97,3 +97,262 @@ def test_path_parsing_logic():
    bank_id, remaining = parse_path("/my-bank/some/path")
    assert bank_id == "my-bank"
    assert remaining == "/some/path"
+
+
+@pytest.mark.asyncio
+async def test_api_key_context_variable():
+    """Test that API key context variable works correctly."""
+    from hindsight_api.api.mcp import get_current_api_key, _current_api_key
+
+    # Initially None
+    assert get_current_api_key() is None
+
+    # Set and verify
+    token = _current_api_key.set("test-api-key-123")
+    try:
+        assert get_current_api_key() == "test-api-key-123"
+    finally:
+        _current_api_key.reset(token)
+
+    # Back to None after reset
+    assert get_current_api_key() is None
+
+
+@pytest.mark.asyncio
+async def test_mcp_tools_propagate_api_key(mock_memory):
+    """Test that MCP tools propagate API key to RequestContext."""
+    from hindsight_api.api.mcp import create_mcp_server, _current_bank_id, _current_api_key
+
+    mcp_server = create_mcp_server(mock_memory)
+    tools = mcp_server._tool_manager._tools
+
+    # Set both bank_id and api_key context
+    bank_token = _current_bank_id.set("test-bank")
+    api_key_token = _current_api_key.set("test-bearer-token")
+    try:
+        retain_tool = tools["retain"]
+        result = await retain_tool.fn(content="test content", context="test_context", async_processing=False)
+        assert "successfully" in result.lower()
+
+        # Verify the memory was called with request_context containing api_key
+        mock_memory.retain_batch_async.assert_called_once()
+        call_kwargs = mock_memory.retain_batch_async.call_args.kwargs
+        assert call_kwargs["request_context"].api_key == "test-bearer-token"
+    finally:
+        _current_bank_id.reset(bank_token)
+        _current_api_key.reset(api_key_token)
+
+
+@pytest.mark.asyncio
+async def test_tenant_id_context_variable():
+    """Test that tenant_id and api_key_id context variables work correctly."""
+    from hindsight_api.api.mcp import (
+        get_current_tenant_id, _current_tenant_id,
+        get_current_api_key_id, _current_api_key_id,
+    )
+
+    # Initially None
+    assert get_current_tenant_id() is None
+    assert get_current_api_key_id() is None
+
+    # Set and verify
+    tenant_token = _current_tenant_id.set("org-123")
+    key_id_token = _current_api_key_id.set("key-456")
+    try:
+        assert get_current_tenant_id() == "org-123"
+        assert get_current_api_key_id() == "key-456"
+    finally:
+        _current_tenant_id.reset(tenant_token)
+        _current_api_key_id.reset(key_id_token)
+
+    # Back to None after reset
+    assert get_current_tenant_id() is None
+    assert get_current_api_key_id() is None
+
+
+@pytest.mark.asyncio
+async def test_mcp_tools_propagate_tenant_id_and_api_key_id(mock_memory):
+    """Test that MCP tools propagate tenant_id and api_key_id to RequestContext.
+
+    This is the critical test for usage metering: the UsageMeteringValidator reads
+    request_context.tenant_id to identify the org for billing. Without this,
+    MCP operations get tenant_id="unknown" and billing is skipped entirely.
+    """
+    from hindsight_api.api.mcp import (
+        create_mcp_server,
+        _current_bank_id, _current_api_key,
+        _current_tenant_id, _current_api_key_id,
+    )
+
+    mcp_server = create_mcp_server(mock_memory)
+    tools = mcp_server._tool_manager._tools
+
+    # Set all context vars (simulating what MCPMiddleware does after authenticate_mcp)
+    bank_token = _current_bank_id.set("test-bank")
+    api_key_token = _current_api_key.set("hsk_test_key")
+    tenant_token = _current_tenant_id.set("org-billing-123")
+    key_id_token = _current_api_key_id.set("key-uuid-456")
+    try:
+        retain_tool = tools["retain"]
+        await retain_tool.fn(content="test content", context="test_context", async_processing=False)
+
+        # Verify the RequestContext passed to memory engine has all auth fields
+        mock_memory.retain_batch_async.assert_called_once()
+        request_context = mock_memory.retain_batch_async.call_args.kwargs["request_context"]
+        assert request_context.api_key == "hsk_test_key"
+        assert request_context.tenant_id == "org-billing-123"
+        assert request_context.api_key_id == "key-uuid-456"
+    finally:
+        _current_bank_id.reset(bank_token)
+        _current_api_key.reset(api_key_token)
+        _current_tenant_id.reset(tenant_token)
+        _current_api_key_id.reset(key_id_token)
+
+
+def test_multi_bank_mode_exposes_all_tools(mock_memory):
+    """Test that multi-bank mode exposes all tools including bank management."""
+    from hindsight_api.api.mcp import create_mcp_server
+
+    # Create server in multi-bank mode (default)
+    mcp_server = create_mcp_server(mock_memory, multi_bank=True)
+    tools = mcp_server._tool_manager._tools
+
+    # Should have all tools
+    assert "retain" in tools
+    assert "recall" in tools
+    assert "reflect" in tools
+    assert "list_banks" in tools
+    assert "create_bank" in tools
+
+
+def test_single_bank_mode_excludes_bank_management_tools(mock_memory):
+    """Test that single-bank mode only exposes bank-scoped tools."""
+    from hindsight_api.api.mcp import create_mcp_server
+
+    # Create server in single-bank mode
+    mcp_server = create_mcp_server(mock_memory, multi_bank=False)
+    tools = mcp_server._tool_manager._tools
+
+    # Should only have bank-scoped tools
+    assert "retain" in tools
+    assert "recall" in tools
+    assert "reflect" in tools
+
+    # Should NOT have bank management tools
+    assert "list_banks" not in tools
+    assert "create_bank" not in tools
+
+
+def test_multi_bank_mode_tools_have_bank_id_param(mock_memory):
+    """Test that multi-bank mode tools include bank_id parameter."""
+    from hindsight_api.api.mcp import create_mcp_server
+    import inspect
+
+    mcp_server = create_mcp_server(mock_memory, multi_bank=True)
+    tools = mcp_server._tool_manager._tools
+
+    # Check that tools have bank_id parameter
+    retain_tool = tools["retain"]
+    retain_sig = inspect.signature(retain_tool.fn)
+    assert "bank_id" in retain_sig.parameters
+
+    recall_tool = tools["recall"]
+    recall_sig = inspect.signature(recall_tool.fn)
+    assert "bank_id" in recall_sig.parameters
+
+    reflect_tool = tools["reflect"]
+    reflect_sig = inspect.signature(reflect_tool.fn)
+    assert "bank_id" in reflect_sig.parameters
+
+
+def test_single_bank_mode_tools_no_bank_id_param(mock_memory):
+    """Test that single-bank mode tools do NOT include bank_id parameter."""
+    from hindsight_api.api.mcp import create_mcp_server
+    import inspect
+
+    mcp_server = create_mcp_server(mock_memory, multi_bank=False)
+    tools = mcp_server._tool_manager._tools
+
+    # Check that tools do NOT have bank_id parameter
+    retain_tool = tools["retain"]
+    retain_sig = inspect.signature(retain_tool.fn)
+    assert "bank_id" not in retain_sig.parameters
+
+    recall_tool = tools["recall"]
+    recall_sig = inspect.signature(recall_tool.fn)
+    assert "bank_id" not in recall_sig.parameters
+
+    reflect_tool = tools["reflect"]
+    reflect_sig = inspect.signature(reflect_tool.fn)
+    assert "bank_id" not in reflect_sig.parameters
+
+
+@pytest.mark.asyncio
+async def test_middleware_handles_both_endpoints(mock_memory):
+    """Test that MCPMiddleware routes to correct server based on URL path."""
+    from hindsight_api.api.mcp import MCPMiddleware
+
+    # Create middleware (single instance)
+    middleware = MCPMiddleware(None, mock_memory)
+
+    # Verify both server instances exist
+    assert middleware.multi_bank_app is not None
+    assert middleware.single_bank_app is not None
+
+    # Verify they expose different tools
+    multi_bank_tools = middleware.multi_bank_server._tool_manager._tools
+    single_bank_tools = middleware.single_bank_server._tool_manager._tools
+
+    # Multi-bank should have all tools
+    assert "retain" in multi_bank_tools
+    assert "recall" in multi_bank_tools
+    assert "list_banks" in multi_bank_tools
+    assert "create_bank" in multi_bank_tools
+
+    # Single-bank should only have scoped tools
+    assert "retain" in single_bank_tools
+    assert "recall" in single_bank_tools
+    assert "list_banks" not in single_bank_tools
+    assert "create_bank" not in single_bank_tools
+
+
+@pytest.mark.asyncio
+async def test_routing_logic_from_url_path():
+    """Test that routing correctly selects server based on URL structure."""
+    from hindsight_api.api.mcp import MCPMiddleware
+    from unittest.mock import AsyncMock
+
+    # Mock memory
+    mock_memory = MagicMock()
+
+    # Create middleware
+    middleware = MCPMiddleware(None, mock_memory)
+
+    # Simulate different URL patterns and verify routing
+    test_cases = [
+        # (path_after_stripping_mcp, expected_bank_id_from_path, expected_bank_id, description)
+        ("/alice/messages", True, "alice", "Bank ID in path with endpoint"),
+        ("/my-agent-123/", True, "my-agent-123", "Bank ID in path with trailing slash"),
+        ("ciccio/messages", True, "ciccio", "Bank ID without leading slash (after mount strip)"),
+        ("bob", True, "bob", "Bank ID only, no leading slash"),
+        ("/messages", False, None, "MCP endpoint, no bank ID"),
+        ("/", False, None, "Root path, no bank ID"),
+    ]
+
+    for path, expected_bank_from_path, expected_bank_id, description in test_cases:
+        # Simulate the path parsing logic with leading slash normalization
+        if path and not path.startswith("/"):
+            path = "/" + path
+
+        bank_id = None
+        bank_id_from_path = False
+        MCP_ENDPOINTS = {"sse", "messages"}
+
+        if path.startswith("/") and len(path) > 1:
+            parts = path[1:].split("/", 1)
+            if parts[0] and parts[0] not in MCP_ENDPOINTS:
+                bank_id = parts[0]
+                bank_id_from_path = True
+
+        assert bank_id_from_path == expected_bank_from_path, f"Failed for: {description} (path={path})"
+        assert bank_id == expected_bank_id, f"Failed bank_id for: {description} (path={path}, got={bank_id})"
@@ -0,0 +1,206 @@
+"""Unit tests for mental model operation validator hooks.
+
+Tests that the operation validator hooks are called correctly for
+mental model GET and refresh operations.
+"""
+
+import pytest
+
+from hindsight_api.extensions.operation_validator import (
+    MentalModelGetContext,
+    MentalModelGetResult,
+    MentalModelRefreshResult,
+    OperationValidatorExtension,
+    ValidationResult,
+)
+
+
+class TestMentalModelGetContextDataclass:
+    """Tests for MentalModelGetContext dataclass."""
+
+    def test_create_context(self):
+        """Test creating a MentalModelGetContext."""
+        from unittest.mock import MagicMock
+
+        request_context = MagicMock()
+        ctx = MentalModelGetContext(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=request_context,
+        )
+
+        assert ctx.bank_id == "bank-1"
+        assert ctx.mental_model_id == "mm-1"
+        assert ctx.request_context is request_context
+
+
+class TestMentalModelGetResultDataclass:
+    """Tests for MentalModelGetResult dataclass."""
+
+    def test_create_result_success(self):
+        """Test creating a successful MentalModelGetResult."""
+        from unittest.mock import MagicMock
+
+        request_context = MagicMock()
+        result = MentalModelGetResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=request_context,
+            output_tokens=250,
+        )
+
+        assert result.bank_id == "bank-1"
+        assert result.mental_model_id == "mm-1"
+        assert result.output_tokens == 250
+        assert result.success is True
+        assert result.error is None
+
+    def test_create_result_failure(self):
+        """Test creating a failed MentalModelGetResult."""
+        from unittest.mock import MagicMock
+
+        result = MentalModelGetResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+            output_tokens=0,
+            success=False,
+            error="Not found",
+        )
+
+        assert result.success is False
+        assert result.error == "Not found"
+
+
+class TestMentalModelRefreshResultDataclass:
+    """Tests for MentalModelRefreshResult dataclass."""
+
+    def test_create_result_with_all_fields(self):
+        """Test creating a MentalModelRefreshResult with all fields."""
+        from unittest.mock import MagicMock
+
+        result = MentalModelRefreshResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+            query_tokens=50,
+            output_tokens=500,
+            context_tokens=0,
+            facts_used=10,
+            mental_models_used=2,
+        )
+
+        assert result.query_tokens == 50
+        assert result.output_tokens == 500
+        assert result.context_tokens == 0
+        assert result.facts_used == 10
+        assert result.mental_models_used == 2
+        assert result.success is True
+        assert result.error is None
+
+    def test_create_result_failure(self):
+        """Test creating a failed MentalModelRefreshResult."""
+        from unittest.mock import MagicMock
+
+        result = MentalModelRefreshResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+            query_tokens=50,
+            output_tokens=0,
+            context_tokens=0,
+            facts_used=0,
+            mental_models_used=0,
+            success=False,
+            error="Reflect failed",
+        )
+
+        assert result.success is False
+        assert result.error == "Reflect failed"
+
+
+class TestDefaultHookBehavior:
+    """Tests for default (no-op) behavior of mental model hooks on OperationValidatorExtension."""
+
+    @pytest.fixture
+    def validator(self):
+        """Create a concrete subclass for testing default behavior."""
+        from unittest.mock import MagicMock
+
+        # Create a concrete subclass that implements the abstract methods
+        class TestValidator(OperationValidatorExtension):
+            async def validate_retain(self, ctx):
+                return ValidationResult.accept()
+
+            async def validate_recall(self, ctx):
+                return ValidationResult.accept()
+
+            async def validate_reflect(self, ctx):
+                return ValidationResult.accept()
+
+        return TestValidator(config={})
+
+    @pytest.mark.asyncio
+    async def test_validate_mental_model_get_default_accepts(self, validator):
+        """Test that default validate_mental_model_get accepts."""
+        from unittest.mock import MagicMock
+
+        ctx = MentalModelGetContext(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+        )
+
+        result = await validator.validate_mental_model_get(ctx)
+
+        assert result.allowed is True
+
+    @pytest.mark.asyncio
+    async def test_on_mental_model_get_complete_default_noop(self, validator):
+        """Test that default on_mental_model_get_complete is a no-op."""
+        from unittest.mock import MagicMock
+
+        result = MentalModelGetResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+            output_tokens=100,
+        )
+
+        # Should not raise
+        await validator.on_mental_model_get_complete(result)
+
+    @pytest.mark.asyncio
+    async def test_on_mental_model_refresh_complete_default_noop(self, validator):
+        """Test that default on_mental_model_refresh_complete is a no-op."""
+        from unittest.mock import MagicMock
+
+        result = MentalModelRefreshResult(
+            bank_id="bank-1",
+            mental_model_id="mm-1",
+            request_context=MagicMock(),
+            query_tokens=50,
+            output_tokens=500,
+            context_tokens=0,
+            facts_used=5,
+            mental_models_used=1,
+        )
+
+        # Should not raise
+        await validator.on_mental_model_refresh_complete(result)
+
+
+class TestExportsAvailable:
+    """Test that mental model hooks are properly exported."""
+
+    def test_imports_from_extensions_package(self):
+        """Test that all mental model types can be imported from hindsight_api.extensions."""
+        from hindsight_api.extensions import (
+            MentalModelGetContext,
+            MentalModelGetResult,
+            MentalModelRefreshResult,
+        )
+
+        assert MentalModelGetContext is not None
+        assert MentalModelGetResult is not None
+        assert MentalModelRefreshResult is not None
@@ -312,6 +312,49 @@ class TestDirectiveTags:
        # Cleanup
        await memory.delete_bank(bank_id, request_context=request_context)

+    async def test_list_all_directives_without_filter(self, memory: MemoryEngine, request_context):
+        """Test that listing directives without tags returns ALL directives (both tagged and untagged)."""
+        bank_id = f"test-directive-list-all-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Create untagged directive
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Untagged Directive",
+            content="This has no tags",
+            request_context=request_context,
+        )
+
+        # Create tagged directive
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Tagged Directive",
+            content="This has tags",
+            tags=["project-x"],
+            request_context=request_context,
+        )
+
+        # List ALL directives (no tag filter, isolation_mode defaults to False)
+        all_directives = await memory.list_directives(
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        # Should return BOTH tagged and untagged directives
+        assert len(all_directives) == 2
+        directive_names = {d["name"] for d in all_directives}
+        assert "Untagged Directive" in directive_names
+        assert "Tagged Directive" in directive_names
+
+        # Verify the tagged directive has its tags
+        tagged = next(d for d in all_directives if d["name"] == "Tagged Directive")
+        assert tagged["tags"] == ["project-x"]
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+

 class TestReflect:
    """Test reflect endpoint."""
@@ -399,6 +442,161 @@ class TestDirectivesInReflect:
        # Cleanup
        await memory.delete_bank(bank_id, request_context=request_context)

+    async def test_tagged_directive_not_applied_without_tags(self, memory: MemoryEngine, request_context):
+        """Test that directives with tags are NOT applied to untagged reflect operations."""
+        bank_id = f"test-directive-isolation-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some untagged content
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "The sky is blue."},
+                {"content": "Water is wet."},
+            ],
+            request_context=request_context,
+        )
+
+        # Add some tagged content for the project-x context
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "The sky is blue according to project X standards.", "tags": ["project-x"]},
+                {"content": "Project X color guidelines specify sky is blue.", "tags": ["project-x"]},
+            ],
+            request_context=request_context,
+        )
+        await memory.wait_for_background_tasks()
+
+        # Create an untagged directive (should be applied)
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="General Policy",
+            content="Always be polite and start responses with 'Hello!'",
+            request_context=request_context,
+        )
+
+        # Create a tagged directive (should NOT be applied to untagged reflect)
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Tagged Policy",
+            content="ALWAYS respond in ALL CAPS and end with 'PROJECT-X ONLY'",
+            tags=["project-x"],
+            request_context=request_context,
+        )
+
+        # Run reflect without tags - should only apply the untagged directive
+        result = await memory.reflect_async(
+            bank_id=bank_id,
+            query="What color is the sky?",
+            request_context=request_context,
+        )
+
+        response_lower = result.text.lower()
+
+        # Should follow the untagged directive (polite greeting)
+        assert "hello" in response_lower, f"Expected 'Hello' from untagged directive, but got: {result.text}"
+
+        # Should NOT follow the tagged directive (all caps and PROJECT-X)
+        # If it did follow, the entire response would be in caps
+        all_caps = result.text.replace(" ", "").replace("!", "").replace(".", "").isupper()
+        assert not all_caps, f"Tagged directive was incorrectly applied to untagged operation: {result.text}"
+        assert "project-x only" not in response_lower, f"Tagged directive was incorrectly applied: {result.text}"
+
+        # Now run reflect WITH the tag - should apply BOTH directives
+        result_tagged = await memory.reflect_async(
+            bank_id=bank_id,
+            query="What color is the sky?",
+            tags=["project-x"],
+            tags_match="all_strict",
+            request_context=request_context,
+        )
+
+        response_tagged_lower = result_tagged.text.lower()
+
+        # With strict matching and tags, should apply the tagged directive
+        assert "project-x only" in response_tagged_lower, f"Tagged directive should be applied with tags: {result_tagged.text}"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+    async def test_reflect_based_on_structure(self, memory: MemoryEngine, request_context):
+        """Test that reflect returns correct based_on structure with directives and memories separated."""
+        bank_id = f"test-reflect-based-on-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some memories
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice works at Google as a software engineer."},
+                {"content": "Bob is a product manager at Microsoft."},
+                {"content": "The team meets every Monday at 9am."},
+            ],
+            request_context=request_context,
+        )
+        await memory.wait_for_background_tasks()
+
+        # Create a directive
+        directive = await memory.create_directive(
+            bank_id=bank_id,
+            name="Professional Tone",
+            content="Always maintain a professional and formal tone in responses.",
+            request_context=request_context,
+        )
+        directive_id = directive["id"]
+
+        # Run reflect which returns the core result
+        result = await memory.reflect_async(
+            bank_id=bank_id,
+            query="Who works at Google?",
+            request_context=request_context,
+        )
+
+        # Verify based_on structure exists
+        assert result.based_on is not None
+
+        # Verify directives key exists and contains our directive
+        assert "directives" in result.based_on
+        directives_list = result.based_on.get("directives", [])
+
+        # Verify directives are dicts with id, name, content (not MemoryFact objects)
+        assert len(directives_list) > 0, "Should have at least one directive"
+        directive_found = False
+        for d in directives_list:
+            assert isinstance(d, dict), f"Directive should be dict, got {type(d)}"
+            assert "id" in d, "Directive dict should have 'id'"
+            assert "name" in d, "Directive dict should have 'name'"
+            assert "content" in d, "Directive dict should have 'content'"
+            # Check if this is our directive
+            if d["id"] == directive_id:
+                directive_found = True
+                assert d["name"] == "Professional Tone"
+                assert "professional" in d["content"].lower()
+
+        assert directive_found, f"Our directive {directive_id} should be in based_on.directives"
+
+        # Verify memories (world/experience) are separate from directives
+        has_memories = "world" in result.based_on or "experience" in result.based_on
+        assert has_memories, "Should have world or experience memories"
+
+        # Verify that if mental-models key exists, it's separate from directives
+        if "mental-models" in result.based_on:
+            mental_models = result.based_on.get("mental-models", [])
+            # Verify mental models are MemoryFact objects, not dicts like directives
+            for mm in mental_models:
+                assert hasattr(mm, "fact_type"), "Mental model should be MemoryFact with fact_type"
+                assert mm.fact_type == "mental-models"
+                assert hasattr(mm, "context")
+                assert "mental model" in mm.context.lower()
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+

 class TestDirectivesPromptInjection:
    """Test that directives are properly injected into the system prompt."""
@@ -451,3 +649,264 @@ class TestDirectivesPromptInjection:
        directives_pos = prompt.find("## DIRECTIVES")
        critical_rules_pos = prompt.find("## CRITICAL RULES")
        assert directives_pos < critical_rules_pos
+
+
+class TestMentalModelRefreshTagSecurity:
+    """Test that mental model refresh respects tag-based security boundaries."""
+
+    async def test_refresh_with_tags_only_accesses_same_tagged_models(
+        self, memory: MemoryEngine, request_context
+    ):
+        """Test that refreshing a mental model with tags can only access other models with the same tags.
+
+        This is a security test to ensure that mental models with tags (e.g., user:alice)
+        cannot access mental models from other scopes (e.g., user:bob or no tags) during refresh.
+        """
+        bank_id = f"test-refresh-tags-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some facts with different tags
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice works on the frontend React project. Alice's favorite color is blue.", "tags": ["user:alice"]},
+                {"content": "Alice prefers working in the morning. Alice drinks coffee every day.", "tags": ["user:alice"]},
+                {"content": "Bob works on the backend API services. Bob's favorite language is Python.", "tags": ["user:bob"]},
+                {"content": "Bob prefers working at night. Bob drinks tea every day.", "tags": ["user:bob"]},
+                {"content": "The company has 100 employees and is growing fast.", "tags": []},  # No tags
+            ],
+            request_context=request_context,
+        )
+
+        # Wait for background processing
+        await memory.wait_for_background_tasks()
+
+        # Create mental model for user:alice with sensitive data
+        mm_alice = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Work Profile",
+            source_query="What does Alice work on?",
+            content="Alice is a frontend engineer specializing in React",
+            tags=["user:alice"],
+            request_context=request_context,
+        )
+
+        # Create mental model for user:bob with sensitive data
+        mm_bob = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Bob's Work Profile",
+            source_query="What does Bob work on?",
+            content="Bob is a backend engineer specializing in Python",
+            tags=["user:bob"],
+            request_context=request_context,
+        )
+
+        # Create mental model with no tags (should not be accessible from tagged models)
+        mm_untagged = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Company Info",
+            source_query="What is the company info?",
+            content="The company has 100 employees",
+            request_context=request_context,
+        )
+
+        # Create a mental model for user:alice that will be refreshed
+        mm_alice_refresh = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Summary",
+            source_query="What are all the facts about work and preferences?",  # Broad query that should match all facts
+            content="Initial content",
+            tags=["user:alice"],
+            request_context=request_context,
+        )
+
+        # Refresh Alice's mental model
+        refreshed = await memory.refresh_mental_model(
+            bank_id=bank_id,
+            mental_model_id=mm_alice_refresh["id"],
+            request_context=request_context,
+        )
+
+        # SECURITY CHECK: The refreshed content should ONLY include information from
+        # memories/models tagged with user:alice, NOT from user:bob or untagged
+        refreshed_content = refreshed["content"].lower()
+
+        # Should include Alice's content (either from facts or mental models)
+        assert "alice" in refreshed_content, \
+            "Refreshed model should access memories/models with matching tags (user:alice)"
+
+        # MUST NOT include Bob's content (security violation)
+        # Use word boundary matching to avoid false positives (e.g., "team" contains "tea")
+        import re
+        def contains_word(text: str, word: str) -> bool:
+            """Check if text contains word as a whole word (not substring)."""
+            return bool(re.search(rf'\b{re.escape(word)}\b', text, re.IGNORECASE))
+
+        assert not contains_word(refreshed_content, "bob") and \
+               not contains_word(refreshed_content, "python") and \
+               not contains_word(refreshed_content, "tea"), \
+            f"SECURITY VIOLATION: Refreshed model accessed memories/models with different tags (user:bob). Content: {refreshed['content']}"
+
+        # MUST NOT include untagged content (security violation)
+        assert "100 employees" not in refreshed_content and "growing fast" not in refreshed_content, \
+            f"SECURITY VIOLATION: Refreshed model accessed untagged memories/models. Content: {refreshed['content']}"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+    async def test_consolidation_only_refreshes_matching_tagged_models(
+        self, memory: MemoryEngine, request_context
+    ):
+        """Test that consolidation only triggers refresh for mental models with matching tags.
+
+        This is a security test to ensure that when tagged memories are consolidated,
+        only mental models with overlapping tags get refreshed, not all mental models.
+        """
+        bank_id = f"test-consolidation-refresh-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Create mental models with different tags, all with refresh_after_consolidation=true
+        mm_alice = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Model",
+            source_query="What about Alice?",
+            content="Initial Alice content",
+            tags=["user:alice"],
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        mm_bob = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Bob's Model",
+            source_query="What about Bob?",
+            content="Initial Bob content",
+            tags=["user:bob"],
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        mm_untagged = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Untagged Model",
+            source_query="What about general stuff?",
+            content="Initial untagged content",
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        # Record initial last_refreshed_at timestamps
+        alice_initial = mm_alice["last_refreshed_at"]
+        bob_initial = mm_bob["last_refreshed_at"]
+        untagged_initial = mm_untagged["last_refreshed_at"]
+
+        # Add memories with user:alice tags
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice likes React", "tags": ["user:alice"]},
+                {"content": "Alice drinks coffee", "tags": ["user:alice"]},
+            ],
+            request_context=request_context,
+        )
+
+        # Trigger consolidation manually (this should only refresh Alice's mental model)
+        from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
+
+        result = await run_consolidation_job(
+            memory_engine=memory,
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        # Wait for background refresh tasks to complete
+        await memory.wait_for_background_tasks()
+
+        # Check that mental models were refreshed appropriately
+        mm_alice_after = await memory.get_mental_model(
+            bank_id, mm_alice["id"], request_context=request_context
+        )
+        mm_bob_after = await memory.get_mental_model(
+            bank_id, mm_bob["id"], request_context=request_context
+        )
+        mm_untagged_after = await memory.get_mental_model(
+            bank_id, mm_untagged["id"], request_context=request_context
+        )
+
+        # SECURITY CHECK: Only Alice's mental model and untagged model should be refreshed
+        # Alice's model should be refreshed (tags match)
+        assert mm_alice_after["last_refreshed_at"] != alice_initial or mm_alice_after["content"] != mm_alice["content"], \
+            "Alice's mental model should be refreshed when user:alice memories are consolidated"
+
+        # Bob's model should NOT be refreshed (tags don't match)
+        assert mm_bob_after["last_refreshed_at"] == bob_initial, \
+            "SECURITY VIOLATION: Bob's mental model was refreshed even though user:bob memories were not consolidated"
+
+        # Untagged model should be refreshed (untagged models are always refreshed)
+        assert mm_untagged_after["last_refreshed_at"] != untagged_initial or mm_untagged_after["content"] != mm_untagged["content"], \
+            "Untagged mental model should be refreshed after any consolidation"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+    async def test_refresh_mental_model_with_directives(self, memory: MemoryEngine, request_context):
+        """Test that refreshing a mental model with directives works correctly."""
+        bank_id = f"test-refresh-directives-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Create a directive
+        directive = await memory.create_directive(
+            bank_id=bank_id,
+            name="Response Style",
+            content="Always be concise and professional",
+            request_context=request_context,
+        )
+
+        # Create a concept mental model to refresh
+        concept = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Team Info",
+            source_query="Team information summary",
+            content="Initial team information",
+            request_context=request_context,
+        )
+
+        # Add some memories
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice is the team lead and handles project planning."},
+                {"content": "Bob is a senior engineer who mentors junior developers."},
+            ],
+            request_context=request_context,
+        )
+
+        # Wait for retain to complete
+        await memory.wait_for_background_tasks()
+
+        # Refresh the concept mental model (this should include directive in based_on)
+        refreshed = await memory.refresh_mental_model(
+            bank_id=bank_id,
+            mental_model_id=concept["id"],
+            request_context=request_context,
+        )
+
+        # Wait for background tasks to complete
+        await memory.wait_for_background_tasks()
+
+        # Verify the refresh completed without errors
+        assert refreshed is not None
+        assert refreshed["content"] is not None
+
+        # Get the updated mental model
+        updated = await memory.get_mental_model(bank_id, concept["id"], request_context=request_context)
+        assert updated["content"] != "Initial team information"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
@@ -358,7 +358,7 @@ class TestLLMMetrics:
        collector.record_llm_call(
            provider="gemini",
            model="gemini-pro",
-            scope="entity_observation",
+            scope="memory",
            duration=2.0,
            success=True,
        )
@@ -369,11 +369,11 @@ class TestLLMMetrics:
        assert call_args[0][0] == 1
        assert call_args[0][1]["provider"] == "gemini"
        assert call_args[0][1]["model"] == "gemini-pro"
-        assert call_args[0][1]["scope"] == "entity_observation"
+        assert call_args[0][1]["scope"] == "memory"

    def test_record_llm_call_different_scopes(self, collector):
        """Test recording LLM calls with different scopes."""
-        scopes = ["memory", "reflect", "entity_observation", "answer"]
+        scopes = ["memory", "reflect", "consolidation", "answer"]

        for scope in scopes:
            collector.llm_duration.record.reset_mock()
@@ -469,7 +469,6 @@ async def test_mixed_language_entities(memory, request_context):
            budget=Budget.MID,
            max_tokens=1000,
            fact_type=["world"],
-            include_entities=True,
            request_context=request_context,
        )

@@ -91,156 +91,13 @@ async def test_entity_extraction_on_retain(memory, request_context):
            await conn.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)


-@pytest.mark.asyncio
-async def test_regenerate_entity_observations(memory, request_context):
-    """
-    Test explicit regeneration of summary for an entity.
-    """
-    bank_id = f"test_regen_obs_{datetime.now(timezone.utc).timestamp()}"
-
-    try:
-        # Store facts about an entity
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Sarah is a product manager who loves user research and data analysis.",
-            context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        await memory.wait_for_background_tasks()
-
-        # Find the Sarah entity
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            entity_row = await conn.fetchrow(
-                """
-                SELECT id, canonical_name
-                FROM entities
-                WHERE bank_id = $1 AND LOWER(canonical_name) LIKE '%sarah%'
-                LIMIT 1
-                """,
-                bank_id
-            )
-
-        if entity_row:
-            entity_id = str(entity_row['id'])
-            entity_name = entity_row['canonical_name']
-
-            # Manually regenerate summary (via observations API for backwards compat)
-            created_ids = await memory.regenerate_entity_observations(
-                bank_id=bank_id,
-                entity_id=entity_id,
-                entity_name=entity_name,
-                request_context=request_context,
-            )
-
-            print(f"\n=== Regenerated Summary ===")
-            print(f"Created {len(created_ids)} summary for {entity_name}")
-
-            # Get entity state
-            state = await memory.get_entity_state(
-                bank_id, entity_id, entity_name, request_context=request_context
-            )
-            for obs in state.observations:
-                print(f"  - {obs.text}")
-
-            # Verify summary was created
-            if len(created_ids) > 0:
-                assert len(state.observations) == 1, "Should have exactly 1 observation (the summary)"
-                print(f"Summary regenerated successfully")
-            else:
-                print(f"Note: No summary was regenerated")
-
-        else:
-            print(f"Note: No 'Sarah' entity was extracted")
-
-    finally:
-        # Cleanup
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            await conn.execute("DELETE FROM memory_units WHERE bank_id = $1", bank_id)
-            await conn.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)
-
-
-@pytest.mark.asyncio
-async def test_entity_state_retrieval(memory, request_context):
-    """
-    Test retrieving entity state with facts.
-    """
-    bank_id = f"test_entity_state_{datetime.now(timezone.utc).timestamp()}"
-
-    try:
-        # Store facts
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice works at Google as a senior software engineer.",
-            context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice loves hiking and outdoor photography.",
-            context="hobbies",
-            event_date=datetime(2024, 1, 16, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        # Find the Alice entity
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            entity_row = await conn.fetchrow(
-                """
-                SELECT id, canonical_name
-                FROM entities
-                WHERE bank_id = $1 AND LOWER(canonical_name) LIKE '%alice%'
-                LIMIT 1
-                """,
-                bank_id
-            )
-
-        assert entity_row is not None, "Alice entity should have been extracted"
-
-        entity_id = str(entity_row['id'])
-        entity_name = entity_row['canonical_name']
-
-        # Check fact count
-        async with pool.acquire() as conn:
-            fact_count = await conn.fetchval(
-                "SELECT COUNT(*) FROM unit_entities WHERE entity_id = $1",
-                entity_row['id']
-            )
-
-        print(f"\n=== Entity State Test ===")
-        print(f"Entity: {entity_name} (id: {entity_id})")
-        print(f"Linked facts: {fact_count}")
-
-        # Get entity state
-        state = await memory.get_entity_state(
-            bank_id, entity_id, entity_name, request_context=request_context
-        )
-
-        assert state.entity_id == entity_id
-        assert state.canonical_name == entity_name
-        print(f"Entity state retrieved successfully")
-
-    finally:
-        # Cleanup
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            await conn.execute("DELETE FROM memory_units WHERE bank_id = $1", bank_id)
-            await conn.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)
-
-
@pytest.mark.asyncio
 async def test_search_with_include_entities(memory, request_context):
    """
-    Test that search with include_entities=True returns entity information.
+    Test that recall accepts include_entities parameter for backwards compatibility.

-    This test verifies that:
-    1. Entities are extracted after retain
-    2. Entity info is returned in recall results with include_entities=True
+    Note: Entity observations have been deprecated. This test verifies the parameter
+    is still accepted without errors.
    """
    bank_id = f"test_search_ent_{datetime.now(timezone.utc).timestamp()}"

@@ -249,10 +106,6 @@ async def test_search_with_include_entities(memory, request_context):
        contents = [
            "Alice is a data scientist who works on recommendation systems at Netflix.",
            "Alice presented her research at the ML conference last month.",
-            "Alice is an expert in deep learning and neural networks.",
-            "Alice graduated from Stanford with a PhD in Computer Science.",
-            "Alice leads a team of 5 data scientists at Netflix.",
-            "Alice published a paper on collaborative filtering algorithms.",
        ]

        for i, content in enumerate(contents):
@@ -267,7 +120,7 @@ async def test_search_with_include_entities(memory, request_context):
        # Wait for background tasks
        await memory.wait_for_background_tasks()

-        # Search with include_entities=True
+        # Search with include_entities=True (should be accepted for backwards compatibility)
        result = await memory.recall_async(
            bank_id=bank_id,
            query="What does Alice do?",
@@ -279,98 +132,9 @@ async def test_search_with_include_entities(memory, request_context):
            request_context=request_context,
        )

-        print(f"\n=== Search Results ===")
-        print(f"Found {len(result.results)} facts")
-        for fact in result.results:
-            print(f"  - {fact.text}")
-            if fact.entities:
-                print(f"    Entities: {', '.join(fact.entities)}")
-
-        # Verify results
+        # Verify recall works
        assert len(result.results) > 0, "Should find some facts"
-
-        # Check if entities are included in facts
-        facts_with_entities = [f for f in result.results if f.entities]
-        assert len(facts_with_entities) > 0, "Some facts should have entity information"
-        print(f"{len(facts_with_entities)} facts have entity information")
-
-        # Check if entity info is returned
-        if result.entities:
-            print(f"Entity info included for {len(result.entities)} entities")
-
-            # Verify Alice entity is in results
-            alice_found = False
-            for name, state in result.entities.items():
-                assert state.canonical_name == name, "Entity canonical_name should match key"
-                assert state.entity_id, "Entity should have an ID"
-                if "alice" in name.lower():
-                    alice_found = True
-                    print(f"Alice entity found: {name}")
-
-            assert alice_found, "Alice entity should be in recall results"
-
-    finally:
-        # Cleanup
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            await conn.execute("DELETE FROM memory_units WHERE bank_id = $1", bank_id)
-            await conn.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)
-
-
-@pytest.mark.asyncio
-async def test_get_entity_state(memory, request_context):
-    """
-    Test getting the full state of an entity.
-    """
-    bank_id = f"test_entity_state_{datetime.now(timezone.utc).timestamp()}"
-
-    try:
-        # Store facts
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Bob is a frontend developer who specializes in React and TypeScript.",
-            context="work info",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        await memory.wait_for_background_tasks()
-
-        # Find entity
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            entity_row = await conn.fetchrow(
-                """
-                SELECT id, canonical_name
-                FROM entities
-                WHERE bank_id = $1 AND LOWER(canonical_name) LIKE '%bob%'
-                LIMIT 1
-                """,
-                bank_id
-            )
-
-        if entity_row:
-            entity_id = str(entity_row['id'])
-            entity_name = entity_row['canonical_name']
-
-            # Get entity state
-            state = await memory.get_entity_state(
-                bank_id=bank_id,
-                entity_id=entity_id,
-                entity_name=entity_name,
-                limit=10,
-                request_context=request_context,
-            )
-
-            print(f"\n=== Entity State for {entity_name} ===")
-            print(f"Entity ID: {state.entity_id}")
-            print(f"Canonical Name: {state.canonical_name}")
-            print(f"Observations: {len(state.observations)}")
-            for obs in state.observations:
-                print(f"  - {obs.text}")
-
-            assert state.entity_id == entity_id, "Entity ID should match"
-            assert state.canonical_name == entity_name, "Canonical name should match"
+        print(f"Found {len(result.results)} facts")

    finally:
        # Cleanup
@@ -275,3 +275,88 @@ class TestReflectUsesReflectLLMConfig:

        # Verify it's different from the retain config
        assert engine._reflect_llm_config.model != engine._retain_llm_config.model
+
+
+class TestRetryAndBackoffConfiguration:
+    """Test retry and backoff configuration options."""
+
+    def test_global_retry_backoff_config_defaults(self):
+        """Test that global retry/backoff settings have correct defaults."""
+        from hindsight_api.config import get_config
+
+        config = get_config()
+
+        # Verify global defaults
+        assert config.llm_max_retries == 10
+        assert config.llm_initial_backoff == 1.0
+        assert config.llm_max_backoff == 60.0
+
+    def test_per_operation_retry_backoff_config_from_env(self):
+        """Test that per-operation retry/backoff settings are loaded from environment."""
+        from hindsight_api.config import clear_config_cache
+
+        # Set per-operation overrides
+        os.environ["HINDSIGHT_API_RETAIN_LLM_MAX_RETRIES"] = "3"
+        os.environ["HINDSIGHT_API_RETAIN_LLM_INITIAL_BACKOFF"] = "2.0"
+        os.environ["HINDSIGHT_API_RETAIN_LLM_MAX_BACKOFF"] = "120.0"
+        os.environ["HINDSIGHT_API_REFLECT_LLM_MAX_RETRIES"] = "5"
+        os.environ["HINDSIGHT_API_REFLECT_LLM_INITIAL_BACKOFF"] = "1.5"
+        os.environ["HINDSIGHT_API_REFLECT_LLM_MAX_BACKOFF"] = "90.0"
+
+        try:
+            clear_config_cache()
+            from hindsight_api.config import get_config
+
+            config = get_config()
+
+            # Verify retain overrides
+            assert config.retain_llm_max_retries == 3
+            assert config.retain_llm_initial_backoff == 2.0
+            assert config.retain_llm_max_backoff == 120.0
+
+            # Verify reflect overrides
+            assert config.reflect_llm_max_retries == 5
+            assert config.reflect_llm_initial_backoff == 1.5
+            assert config.reflect_llm_max_backoff == 90.0
+
+            # Verify global defaults remain unchanged
+            assert config.llm_max_retries == 10
+            assert config.llm_initial_backoff == 1.0
+            assert config.llm_max_backoff == 60.0
+        finally:
+            # Clean up
+            os.environ.pop("HINDSIGHT_API_RETAIN_LLM_MAX_RETRIES", None)
+            os.environ.pop("HINDSIGHT_API_RETAIN_LLM_INITIAL_BACKOFF", None)
+            os.environ.pop("HINDSIGHT_API_RETAIN_LLM_MAX_BACKOFF", None)
+            os.environ.pop("HINDSIGHT_API_REFLECT_LLM_MAX_RETRIES", None)
+            os.environ.pop("HINDSIGHT_API_REFLECT_LLM_INITIAL_BACKOFF", None)
+            os.environ.pop("HINDSIGHT_API_REFLECT_LLM_MAX_BACKOFF", None)
+            clear_config_cache()
+
+    def test_per_operation_retry_backoff_fallback_to_global(self):
+        """Test that per-operation settings fall back to global when not set."""
+        from hindsight_api.config import clear_config_cache, get_config
+
+        # Set only global values
+        os.environ["HINDSIGHT_API_LLM_MAX_RETRIES"] = "7"
+        os.environ["HINDSIGHT_API_LLM_INITIAL_BACKOFF"] = "3.0"
+        os.environ["HINDSIGHT_API_LLM_MAX_BACKOFF"] = "180.0"
+
+        try:
+            clear_config_cache()
+            config = get_config()
+
+            # Per-operation should be None (will fall back to global at runtime)
+            assert config.retain_llm_max_retries is None
+            assert config.retain_llm_initial_backoff is None
+            assert config.retain_llm_max_backoff is None
+
+            # Global values should be set
+            assert config.llm_max_retries == 7
+            assert config.llm_initial_backoff == 3.0
+            assert config.llm_max_backoff == 180.0
+        finally:
+            os.environ.pop("HINDSIGHT_API_LLM_MAX_RETRIES", None)
+            os.environ.pop("HINDSIGHT_API_LLM_INITIAL_BACKOFF", None)
+            os.environ.pop("HINDSIGHT_API_LLM_MAX_BACKOFF", None)
+            clear_config_cache()
@@ -0,0 +1,123 @@
+"""Test provider-specific default models in config."""
+
+import os
+
+import pytest
+
+
+def test_provider_default_models():
+    """Test that each provider has a default model and it's used when model is not explicitly set."""
+    from hindsight_api.config import PROVIDER_DEFAULT_MODELS, HindsightConfig, clear_config_cache
+
+    # Save original env vars
+    original_provider = os.environ.get("HINDSIGHT_API_LLM_PROVIDER")
+    original_model = os.environ.get("HINDSIGHT_API_LLM_MODEL")
+
+    try:
+        # Test each provider has a default
+        for provider, expected_model in PROVIDER_DEFAULT_MODELS.items():
+            clear_config_cache()
+            os.environ["HINDSIGHT_API_LLM_PROVIDER"] = provider
+            # Remove explicit model setting to test default
+            if "HINDSIGHT_API_LLM_MODEL" in os.environ:
+                del os.environ["HINDSIGHT_API_LLM_MODEL"]
+
+            config = HindsightConfig.from_env()
+            assert config.llm_provider == provider, f"Provider mismatch for {provider}"
+            assert config.llm_model == expected_model, f"Expected {expected_model} for {provider}, got {config.llm_model}"
+
+    finally:
+        # Restore original env vars
+        clear_config_cache()
+        if original_provider:
+            os.environ["HINDSIGHT_API_LLM_PROVIDER"] = original_provider
+        elif "HINDSIGHT_API_LLM_PROVIDER" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_PROVIDER"]
+
+        if original_model:
+            os.environ["HINDSIGHT_API_LLM_MODEL"] = original_model
+        elif "HINDSIGHT_API_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_MODEL"]
+
+
+def test_explicit_model_overrides_provider_default():
+    """Test that explicit model setting overrides provider default."""
+    from hindsight_api.config import HindsightConfig, clear_config_cache
+
+    original_provider = os.environ.get("HINDSIGHT_API_LLM_PROVIDER")
+    original_model = os.environ.get("HINDSIGHT_API_LLM_MODEL")
+
+    try:
+        clear_config_cache()
+        os.environ["HINDSIGHT_API_LLM_PROVIDER"] = "anthropic"
+        os.environ["HINDSIGHT_API_LLM_MODEL"] = "claude-sonnet-4-5-20250929"
+
+        config = HindsightConfig.from_env()
+        assert config.llm_provider == "anthropic"
+        assert config.llm_model == "claude-sonnet-4-5-20250929", "Explicit model should override default"
+
+    finally:
+        clear_config_cache()
+        if original_provider:
+            os.environ["HINDSIGHT_API_LLM_PROVIDER"] = original_provider
+        elif "HINDSIGHT_API_LLM_PROVIDER" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_PROVIDER"]
+
+        if original_model:
+            os.environ["HINDSIGHT_API_LLM_MODEL"] = original_model
+        elif "HINDSIGHT_API_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_MODEL"]
+
+
+def test_per_operation_provider_default_model():
+    """Test that per-operation providers use their own default models."""
+    from hindsight_api.config import HindsightConfig, clear_config_cache
+
+    original_provider = os.environ.get("HINDSIGHT_API_LLM_PROVIDER")
+    original_model = os.environ.get("HINDSIGHT_API_LLM_MODEL")
+    original_retain_provider = os.environ.get("HINDSIGHT_API_RETAIN_LLM_PROVIDER")
+    original_retain_model = os.environ.get("HINDSIGHT_API_RETAIN_LLM_MODEL")
+
+    try:
+        clear_config_cache()
+        os.environ["HINDSIGHT_API_LLM_PROVIDER"] = "openai"
+        # Remove explicit model to use provider default
+        if "HINDSIGHT_API_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_MODEL"]
+
+        # Set retain-specific provider but not model
+        os.environ["HINDSIGHT_API_RETAIN_LLM_PROVIDER"] = "anthropic"
+        if "HINDSIGHT_API_RETAIN_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_RETAIN_LLM_MODEL"]
+
+        config = HindsightConfig.from_env()
+
+        # Global LLM should use OpenAI default
+        assert config.llm_model == "o3-mini", f"Expected o3-mini, got {config.llm_model}"
+
+        # Retain should use Anthropic default
+        assert (
+            config.retain_llm_model == "claude-haiku-4-5-20251001"
+        ), f"Expected claude-haiku-4-5-20251001, got {config.retain_llm_model}"
+
+    finally:
+        clear_config_cache()
+        if original_provider:
+            os.environ["HINDSIGHT_API_LLM_PROVIDER"] = original_provider
+        elif "HINDSIGHT_API_LLM_PROVIDER" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_PROVIDER"]
+
+        if original_model:
+            os.environ["HINDSIGHT_API_LLM_MODEL"] = original_model
+        elif "HINDSIGHT_API_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_LLM_MODEL"]
+
+        if original_retain_provider:
+            os.environ["HINDSIGHT_API_RETAIN_LLM_PROVIDER"] = original_retain_provider
+        elif "HINDSIGHT_API_RETAIN_LLM_PROVIDER" in os.environ:
+            del os.environ["HINDSIGHT_API_RETAIN_LLM_PROVIDER"]
+
+        if original_retain_model:
+            os.environ["HINDSIGHT_API_RETAIN_LLM_MODEL"] = original_retain_model
+        elif "HINDSIGHT_API_RETAIN_LLM_MODEL" in os.environ:
+            del os.environ["HINDSIGHT_API_RETAIN_LLM_MODEL"]
@@ -175,6 +175,45 @@ class TestMentalModelsCRUD:
        # Cleanup
        await memory.delete_bank(bank_id, request_context=request_context)

+    @pytest.mark.asyncio
+    async def test_create_mental_model_with_custom_id(self, memory: MemoryEngine, request_context):
+        """Test creating a mental model with a custom ID."""
+        bank_id = f"test-mental-model-custom-id-{uuid.uuid4().hex[:8]}"
+
+        # Create the bank first
+        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
+
+        # Create a mental model with a custom ID
+        custom_id = "team-communication-preferences"
+        mental_model = await memory.create_mental_model(
+            bank_id=bank_id,
+            mental_model_id=custom_id,
+            name="Team Communication Preferences",
+            source_query="How does the team prefer to communicate?",
+            content="The team prefers async communication via Slack",
+            tags=["team", "communication"],
+            request_context=request_context,
+        )
+
+        # Verify the custom ID was used
+        assert mental_model["id"] == custom_id
+        assert mental_model["name"] == "Team Communication Preferences"
+        assert mental_model["tags"] == ["team", "communication"]
+
+        # Verify we can retrieve it with the custom ID
+        fetched = await memory.get_mental_model(
+            bank_id=bank_id,
+            mental_model_id=custom_id,
+            request_context=request_context,
+        )
+
+        assert fetched is not None
+        assert fetched["id"] == custom_id
+        assert fetched["name"] == "Team Communication Preferences"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+

 class TestObservationsAPI:
    """Test observations API endpoints.
@@ -16,7 +16,6 @@ async def test_retain_with_chunks(memory, request_context):
    Test that retain function:
    1. Stores facts with associated chunks
    2. Recall returns chunk_id for each fact
-    3. Recall with include_entities=True also works (for compatibility)
    """
    bank_id = f"test_chunks_{datetime.now(timezone.utc).timestamp()}"
    document_id = "test_doc_123"
@@ -56,7 +55,6 @@ async def test_retain_with_chunks(memory, request_context):
            budget=Budget.LOW,
            max_tokens=500,
            fact_type=["world"],  # Search for world facts
-            include_entities=False,  # Disable entities for simpler test
            include_chunks=True,  # Enable chunks
            max_chunk_tokens=8192,
            request_context=request_context,
@@ -146,7 +144,6 @@ async def test_chunks_and_entities_follow_fact_order(memory, request_context):
            budget=Budget.MID,
            max_tokens=1000,
            fact_type=["world"],
-            include_entities=True,
            include_chunks=True,
            max_chunk_tokens=8192,
            request_context=request_context,
@@ -2196,3 +2193,65 @@ If the text contains both Italian and English content, extract ONLY the Italian

        # Clear cache again to restore original config
        clear_config_cache()
+
+
+@pytest.mark.asyncio
+async def test_retain_batch_with_per_item_tags_on_document(memory, request_context):
+    """
+    Test that per-item tags are correctly stored on documents.
+
+    This test verifies the fix for a bug where per-item tags in content dictionaries
+    were not being merged and passed to document tracking, causing tags to be lost
+    even though they were correctly sent through the API.
+
+    Without the fix, this test would fail because:
+    - Tags are correctly passed in the content dict
+    - Tags are correctly stored on memory_units (facts)
+    - BUT tags were NOT stored on the document record itself
+    """
+    bank_id = f"test_doc_tags_{datetime.now(timezone.utc).timestamp()}"
+    document_id = "app-state-testuser"
+
+    try:
+        # Retain content with per-item tags (simulating the TasteAI use case)
+        contents = [
+            {
+                "content": '{"username":"testuser","meals":[],"preferences":{"nickname":"testuser"}}',
+                "document_id": document_id,
+                "tags": ["user:testuser", "app-type:taste-ai"],
+            }
+        ]
+
+        result = await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=contents,
+            request_context=request_context,
+        )
+
+        assert len(result) > 0, "Should have retained content"
+        print(f"\n=== Retained content with tags ===")
+
+        # Retrieve the document
+        doc = await memory.get_document(
+            document_id=document_id,
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        assert doc is not None, "Document should exist"
+        assert "tags" in doc, "Document should have tags field"
+
+        # This is the critical assertion - tags should be stored on the document
+        doc_tags = doc["tags"] or []
+        print(f"Document tags: {doc_tags}")
+
+        assert "user:testuser" in doc_tags, \
+            f"Document should have 'user:testuser' tag, but got: {doc_tags}"
+        assert "app-type:taste-ai" in doc_tags, \
+            f"Document should have 'app-type:taste-ai' tag, but got: {doc_tags}"
+
+        print("✓ Per-item tags correctly stored on document")
+
+    finally:
+        await memory.delete_bank(bank_id, request_context=request_context)
+        print(f"\n=== Cleaned up bank: {bank_id} ===")
@@ -0,0 +1,834 @@
+"""Tests for the Supabase Tenant Extension."""
+
+import time
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import jwt as pyjwt
+import pytest
+from jwt import PyJWK
+
+from hindsight_api.extensions.builtin.supabase_tenant import (
+    JWKS_CACHE_TTL_SECONDS,
+    JWKS_MIN_REFRESH_INTERVAL_SECONDS,
+    MIN_TOKEN_LENGTH,
+    SupabaseTenantExtension,
+)
+from hindsight_api.extensions.context import ExtensionContext
+from hindsight_api.extensions.loader import load_extension
+from hindsight_api.extensions.tenant import AuthenticationError, Tenant, TenantContext, TenantExtension
+from hindsight_api.models import RequestContext
+
+# A valid UUID for test user IDs
+VALID_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+
+# Minimal JWKS response with one RSA key
+MOCK_JWKS_RESPONSE = {
+    "keys": [
+        {
+            "kid": "test-key-1",
+            "kty": "RSA",
+            "alg": "RS256",
+            "use": "sig",
+            "n": "0vx7agoebGcQSuuPiLJXZptN9nndrQmbXEps2aiAFbWhM78LhWx4cbbfAAtVT86zwu1RK7aPFFxuhDR1L6tSoc_BJECPebWKRXjBZCiFV4n3oknjhMstn64tZ_2W-5JsGY4Hc5n9yBXArwl93lqt7_RN5w6Cf0h4QyQ5v-65YGjQR0_FDW2QvzqY368QQMicAtaSqzs8KJZgnYb9c7d0zgdAZHzu6qMQvRL5hajrn1n91CbOpbISD08qNLyrdkt-bFTWhAI4vMQFh6WeZu0fM4lFd2NcRwr3XPksINHaQ-G_xBniIqbw0Ls1jF44-csFCur-kEgU8awapJzKnqDKgw",
+            "e": "AQAB",
+        }
+    ]
+}
+
+
+def _make_extension(
+    supabase_url: str = "https://test.supabase.co",
+    service_key: str | None = "test-service-key",
+    schema_prefix: str | None = None,
+) -> SupabaseTenantExtension:
+    """Helper to create a SupabaseTenantExtension with test config."""
+    config = {
+        "supabase_url": supabase_url,
+    }
+    if service_key is not None:
+        config["supabase_service_key"] = service_key
+    if schema_prefix is not None:
+        config["schema_prefix"] = schema_prefix
+    return SupabaseTenantExtension(config)
+
+
+def _make_mock_response(status_code: int = 200, json_data: dict | None = None) -> MagicMock:
+    """Helper to create a mock httpx.Response."""
+    response = MagicMock(spec=httpx.Response)
+    response.status_code = status_code
+    response.json.return_value = json_data or {}
+    response.raise_for_status = MagicMock()
+    if status_code >= 400:
+        response.raise_for_status.side_effect = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
+    return response
+
+
+def _make_valid_token() -> str:
+    """Return a token that passes the MIN_TOKEN_LENGTH check."""
+    return "a" * (MIN_TOKEN_LENGTH + 10)
+
+
+def _setup_jwks_ext() -> tuple[SupabaseTenantExtension, AsyncMock]:
+    """Create an extension in JWKS mode with mocked internals."""
+    ext = _make_extension()
+    mock_client = AsyncMock(spec=httpx.AsyncClient)
+    ext._http_client = mock_client
+    ext._use_jwks = True
+    ext._jwks_keys = {"test-key-1": MagicMock(spec=PyJWK)}
+    ext._jwks_keys["test-key-1"].key = "mock-public-key"
+    ext._jwks_last_fetched = time.monotonic()
+    return ext, mock_client
+
+
+def _setup_legacy_ext() -> tuple[SupabaseTenantExtension, AsyncMock]:
+    """Create an extension in legacy mode with mocked internals."""
+    ext = _make_extension()
+    mock_client = AsyncMock(spec=httpx.AsyncClient)
+    ext._http_client = mock_client
+    ext._use_jwks = False
+    return ext, mock_client
+
+
+# ======================================================================
+# Initialization
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionInit:
+    """Tests for extension initialization."""
+
+    def test_init_with_valid_config(self):
+        ext = _make_extension()
+        assert ext.supabase_url == "https://test.supabase.co"
+        assert ext.supabase_service_key == "test-service-key"
+        assert ext.schema_prefix == "user"
+        assert ext._initialized_schemas == set()
+        assert ext._http_client is None
+        assert ext._use_jwks is False
+        assert ext._jwks_keys == {}
+
+    def test_init_missing_supabase_url(self):
+        with pytest.raises(ValueError, match="HINDSIGHT_API_TENANT_SUPABASE_URL is required"):
+            SupabaseTenantExtension({})
+
+    def test_init_without_service_key(self):
+        """Service key is optional — JWKS mode doesn't require it."""
+        ext = _make_extension(service_key=None)
+        assert ext.supabase_service_key is None
+
+    def test_init_default_schema_prefix(self):
+        ext = _make_extension()
+        assert ext.schema_prefix == "user"
+
+    def test_init_custom_schema_prefix(self):
+        ext = _make_extension(schema_prefix="tenant")
+        assert ext.schema_prefix == "tenant"
+
+    def test_init_strips_trailing_slash(self):
+        ext = _make_extension(supabase_url="https://test.supabase.co/")
+        assert ext.supabase_url == "https://test.supabase.co"
+
+    def test_init_rejects_invalid_schema_prefix(self):
+        """Schema prefix with special characters should be rejected."""
+        with pytest.raises(ValueError, match="Invalid schema_prefix"):
+            _make_extension(schema_prefix='"; DROP TABLE')
+
+    def test_init_rejects_empty_schema_prefix(self):
+        with pytest.raises(ValueError, match="Invalid schema_prefix"):
+            _make_extension(schema_prefix="")
+
+    def test_init_rejects_schema_prefix_starting_with_digit(self):
+        with pytest.raises(ValueError, match="Invalid schema_prefix"):
+            _make_extension(schema_prefix="123abc")
+
+    def test_init_allows_underscore_prefix(self):
+        ext = _make_extension(schema_prefix="_internal")
+        assert ext.schema_prefix == "_internal"
+
+    def test_is_tenant_extension_subclass(self):
+        ext = _make_extension()
+        assert isinstance(ext, TenantExtension)
+
+
+# ======================================================================
+# Startup — JWKS initialization
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionStartup:
+    """Tests for on_startup behavior."""
+
+    @pytest.mark.asyncio
+    async def test_on_startup_creates_http_client(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        # JWKS fetch returns keys
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            with patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK"):
+                await ext.on_startup()
+
+        assert ext._http_client is mock_client
+
+    @pytest.mark.asyncio
+    async def test_on_startup_fetches_jwks(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            with patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK") as mock_pyjwk:
+                mock_pyjwk.return_value = MagicMock(spec=PyJWK)
+                await ext.on_startup()
+
+        assert ext._use_jwks is True
+        # First call: JWKS fetch, second call: health check
+        assert mock_client.get.call_count == 2
+        jwks_call = mock_client.get.call_args_list[0]
+        assert jwks_call.args[0] == "https://test.supabase.co/auth/v1/.well-known/jwks.json"
+
+    @pytest.mark.asyncio
+    async def test_on_startup_falls_back_to_legacy_when_jwks_empty(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+
+        # JWKS returns empty keys, health check succeeds
+        def mock_get(url, **kwargs):
+            if "jwks" in url:
+                return _make_mock_response(200, {"keys": []})
+            return _make_mock_response(200)
+
+        mock_client.get.side_effect = mock_get
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            await ext.on_startup()
+
+        assert ext._use_jwks is False
+
+    @pytest.mark.asyncio
+    async def test_on_startup_falls_back_to_legacy_when_jwks_fetch_fails(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+
+        call_count = 0
+
+        def mock_get(url, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                # JWKS fetch fails
+                raise httpx.ConnectError("Connection refused")
+            # health check
+            return _make_mock_response(200)
+
+        mock_client.get.side_effect = mock_get
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            await ext.on_startup()
+
+        assert ext._use_jwks is False
+
+    @pytest.mark.asyncio
+    async def test_on_startup_raises_if_no_jwks_and_no_service_key(self):
+        ext = _make_extension(service_key=None)
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        mock_client.get.return_value = _make_mock_response(200, {"keys": []})
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            with pytest.raises(ValueError, match="HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY is required"):
+                await ext.on_startup()
+
+    @pytest.mark.asyncio
+    async def test_on_startup_health_check_with_service_key(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            with patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK"):
+                await ext.on_startup()
+
+        # Second call should be health check
+        health_call = mock_client.get.call_args_list[1]
+        assert health_call.args[0] == "https://test.supabase.co/auth/v1/health"
+        assert health_call.kwargs["headers"] == {"apikey": "test-service-key"}
+
+    @pytest.mark.asyncio
+    async def test_on_startup_skips_health_check_without_service_key(self):
+        ext = _make_extension(service_key=None)
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.httpx.AsyncClient", return_value=mock_client):
+            with patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK"):
+                await ext.on_startup()
+
+        # Only one call: JWKS fetch, no health check
+        assert mock_client.get.call_count == 1
+
+
+# ======================================================================
+# JWKS cache management
+# ======================================================================
+
+
+class TestJWKSCacheManagement:
+    """Tests for JWKS key fetching, caching, and rotation handling."""
+
+    @pytest.mark.asyncio
+    async def test_get_signing_key_from_cache(self):
+        ext, _ = _setup_jwks_ext()
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header:
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            key = await ext._get_signing_key("fake-token")
+
+        assert key is ext._jwks_keys["test-key-1"]
+
+    @pytest.mark.asyncio
+    async def test_get_signing_key_refreshes_stale_cache(self):
+        ext, mock_client = _setup_jwks_ext()
+        # Make cache expired
+        ext._jwks_last_fetched = time.monotonic() - JWKS_CACHE_TTL_SECONDS - 1
+
+        new_key = MagicMock(spec=PyJWK)
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK", return_value=new_key),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            key = await ext._get_signing_key("fake-token")
+
+        assert key is new_key
+        mock_client.get.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_signing_key_handles_key_rotation(self):
+        """When kid not in cache and cache is old enough, refresh once for key rotation."""
+        ext, mock_client = _setup_jwks_ext()
+        # Make cache just old enough to allow a refresh
+        ext._jwks_last_fetched = time.monotonic() - JWKS_MIN_REFRESH_INTERVAL_SECONDS - 1
+
+        rotated_key = MagicMock(spec=PyJWK)
+        mock_client.get.return_value = _make_mock_response(200, MOCK_JWKS_RESPONSE)
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.PyJWK", return_value=rotated_key),
+        ):
+            mock_header.return_value = {"kid": "rotated-key-99", "alg": "RS256"}
+            # The refreshed JWKS won't have "rotated-key-99" either, so this should raise
+            with pytest.raises(AuthenticationError, match="Unable to find signing key"):
+                await ext._get_signing_key("fake-token")
+
+        # Should have attempted one refresh
+        mock_client.get.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_get_signing_key_missing_kid_header(self):
+        ext, _ = _setup_jwks_ext()
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header:
+            mock_header.return_value = {"alg": "RS256"}  # no kid
+            with pytest.raises(AuthenticationError, match="Token missing key ID"):
+                await ext._get_signing_key("fake-token")
+
+    @pytest.mark.asyncio
+    async def test_get_signing_key_refresh_network_error(self):
+        """If JWKS refresh fails during key rotation, error should propagate."""
+        ext, mock_client = _setup_jwks_ext()
+        ext._jwks_last_fetched = time.monotonic() - JWKS_MIN_REFRESH_INTERVAL_SECONDS - 1
+
+        mock_client.get.side_effect = httpx.ConnectError("Connection refused")
+
+        with patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header:
+            mock_header.return_value = {"kid": "unknown-key", "alg": "RS256"}
+            with pytest.raises(Exception):
+                await ext._get_signing_key("fake-token")
+
+
+# ======================================================================
+# Authentication — JWKS mode
+# ======================================================================
+
+
+class TestAuthenticateJWKS:
+    """Tests for JWKS-based JWT verification."""
+
+    @pytest.mark.asyncio
+    async def test_authenticate_valid_token(self):
+        ext, _ = _setup_jwks_ext()
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID, "aud": "authenticated"}
+
+            result = await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        assert isinstance(result, TenantContext)
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        assert result.schema_name == expected_schema
+
+    @pytest.mark.asyncio
+    async def test_authenticate_custom_prefix(self):
+        ext, _ = _setup_jwks_ext()
+        ext.schema_prefix = "org"
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID}
+
+            result = await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        assert result.schema_name.startswith("org_")
+
+    @pytest.mark.asyncio
+    async def test_authenticate_expired_token(self):
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch(
+                "hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode",
+                side_effect=pyjwt.ExpiredSignatureError(),
+            ),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+
+            with pytest.raises(AuthenticationError, match="Token has expired"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_invalid_audience(self):
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch(
+                "hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode",
+                side_effect=pyjwt.InvalidAudienceError(),
+            ),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+
+            with pytest.raises(AuthenticationError, match="Invalid token audience"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_invalid_issuer(self):
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch(
+                "hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode",
+                side_effect=pyjwt.InvalidIssuerError(),
+            ),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+
+            with pytest.raises(AuthenticationError, match="Invalid token issuer"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_decode_error(self):
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch(
+                "hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode",
+                side_effect=pyjwt.DecodeError(),
+            ),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+
+            with pytest.raises(AuthenticationError, match="Invalid token"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_missing_sub_claim(self):
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"email": "[email protected]"}  # no sub
+
+            with pytest.raises(AuthenticationError, match="missing subject"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_empty_sub_claim(self):
+        """Empty string sub claim should be treated as missing."""
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": ""}
+
+            with pytest.raises(AuthenticationError, match="missing subject"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_generic_exception(self):
+        """Unexpected exceptions during decode should be caught and wrapped."""
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch(
+                "hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode",
+                side_effect=RuntimeError("unexpected internal error"),
+            ),
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+
+            with pytest.raises(AuthenticationError, match="Token verification failed"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+
+# ======================================================================
+# Authentication — Legacy mode
+# ======================================================================
+
+
+class TestAuthenticateLegacy:
+    """Tests for legacy /auth/v1/user endpoint verification."""
+
+    @pytest.mark.asyncio
+    async def test_authenticate_valid_token(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.return_value = _make_mock_response(200, {"id": VALID_UUID})
+
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        result = await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        assert isinstance(result, TenantContext)
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        assert result.schema_name == expected_schema
+
+    @pytest.mark.asyncio
+    async def test_authenticate_calls_user_endpoint(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.return_value = _make_mock_response(200, {"id": VALID_UUID})
+
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        token = _make_valid_token()
+        await ext.authenticate(RequestContext(api_key=token))
+
+        mock_client.get.assert_called_once_with(
+            "https://test.supabase.co/auth/v1/user",
+            headers={
+                "Authorization": f"Bearer {token}",
+                "apikey": "test-service-key",
+            },
+        )
+
+    @pytest.mark.asyncio
+    async def test_authenticate_expired_token_401(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.return_value = _make_mock_response(401)
+
+        with pytest.raises(AuthenticationError, match="Invalid or expired token"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_supabase_error_500(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.return_value = _make_mock_response(500)
+
+        with pytest.raises(AuthenticationError, match="Authentication failed: 500"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_no_user_id(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.return_value = _make_mock_response(200, {"email": "[email protected]"})
+
+        with pytest.raises(AuthenticationError, match="no user ID found"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_timeout(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.side_effect = httpx.TimeoutException("Request timed out")
+
+        with pytest.raises(AuthenticationError, match="Authentication timeout"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_connection_error(self):
+        ext, mock_client = _setup_legacy_ext()
+        mock_client.get.side_effect = httpx.ConnectError("Connection refused")
+
+        with pytest.raises(AuthenticationError, match="Connection error"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+
+# ======================================================================
+# Authentication — common (both modes)
+# ======================================================================
+
+
+class TestAuthenticateCommon:
+    """Tests that apply regardless of verification mode."""
+
+    @pytest.mark.asyncio
+    async def test_authenticate_missing_token(self):
+        ext, _ = _setup_jwks_ext()
+
+        with pytest.raises(AuthenticationError, match="Missing Authorization header"):
+            await ext.authenticate(RequestContext(api_key=None))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_empty_token(self):
+        ext, _ = _setup_jwks_ext()
+
+        with pytest.raises(AuthenticationError, match="Missing Authorization header"):
+            await ext.authenticate(RequestContext(api_key=""))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_short_token(self):
+        ext, _ = _setup_jwks_ext()
+
+        with pytest.raises(AuthenticationError, match="Invalid token format"):
+            await ext.authenticate(RequestContext(api_key="short"))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_not_initialized(self):
+        ext = _make_extension()
+        # _http_client is None by default
+
+        with pytest.raises(AuthenticationError, match="Extension not initialized"):
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_rejects_non_uuid_user_id(self):
+        """User IDs that aren't valid UUIDs should be rejected for schema safety."""
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": "not-a-uuid"}
+
+            with pytest.raises(AuthenticationError, match="Invalid user ID format"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+    @pytest.mark.asyncio
+    async def test_authenticate_rejects_malicious_user_id(self):
+        """User IDs with SQL injection attempts should be rejected."""
+        ext, _ = _setup_jwks_ext()
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": "'; DROP TABLE users;--"}
+
+            with pytest.raises(AuthenticationError, match="Invalid user ID format"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+
+# ======================================================================
+# Schema management
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionSchemaManagement:
+    """Tests for schema initialization and caching."""
+
+    @pytest.mark.asyncio
+    async def test_schema_initialized_on_first_access(self):
+        ext, _ = _setup_jwks_ext()
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID}
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        mock_context.run_migration.assert_called_once_with(expected_schema)
+        assert expected_schema in ext._initialized_schemas
+
+    @pytest.mark.asyncio
+    async def test_schema_cached_on_second_access(self):
+        ext, _ = _setup_jwks_ext()
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID}
+
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        # run_migration should only be called once
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        mock_context.run_migration.assert_called_once_with(expected_schema)
+
+    @pytest.mark.asyncio
+    async def test_schema_init_failure(self):
+        ext, _ = _setup_jwks_ext()
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock(side_effect=RuntimeError("Migration failed"))
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID}
+
+            with pytest.raises(AuthenticationError, match="Failed to initialize tenant"):
+                await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        # Schema should NOT be cached on failure
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        assert expected_schema not in ext._initialized_schemas
+
+
+# ======================================================================
+# List tenants
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionListTenants:
+    """Tests for list_tenants behavior."""
+
+    @pytest.mark.asyncio
+    async def test_list_tenants_empty(self):
+        ext = _make_extension()
+        tenants = await ext.list_tenants()
+        assert tenants == []
+
+    @pytest.mark.asyncio
+    async def test_list_tenants_after_auth(self):
+        ext, _ = _setup_jwks_ext()
+        mock_context = AsyncMock(spec=ExtensionContext)
+        mock_context.run_migration = AsyncMock()
+        ext._context = mock_context
+
+        with (
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.get_unverified_header") as mock_header,
+            patch("hindsight_api.extensions.builtin.supabase_tenant.pyjwt.decode") as mock_decode,
+        ):
+            mock_header.return_value = {"kid": "test-key-1", "alg": "RS256"}
+            mock_decode.return_value = {"sub": VALID_UUID}
+            await ext.authenticate(RequestContext(api_key=_make_valid_token()))
+
+        tenants = await ext.list_tenants()
+        assert len(tenants) == 1
+        assert isinstance(tenants[0], Tenant)
+        expected_schema = "user_" + VALID_UUID.replace("-", "_")
+        assert tenants[0].schema == expected_schema
+
+
+# ======================================================================
+# Shutdown
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionShutdown:
+    """Tests for on_shutdown behavior."""
+
+    @pytest.mark.asyncio
+    async def test_on_shutdown_closes_client(self):
+        ext = _make_extension()
+        mock_client = AsyncMock(spec=httpx.AsyncClient)
+        ext._http_client = mock_client
+
+        await ext.on_shutdown()
+
+        mock_client.aclose.assert_called_once()
+        assert ext._http_client is None
+
+    @pytest.mark.asyncio
+    async def test_on_shutdown_no_client(self):
+        ext = _make_extension()
+        # _http_client is None by default — should not raise
+        await ext.on_shutdown()
+
+
+# ======================================================================
+# Extension loader integration
+# ======================================================================
+
+
+class TestSupabaseTenantExtensionLoader:
+    """Tests for loading via the extension loader."""
+
+    def test_load_via_extension_loader(self, monkeypatch):
+        monkeypatch.setenv(
+            "HINDSIGHT_API_TENANT_EXTENSION",
+            "hindsight_api.extensions.builtin.supabase_tenant:SupabaseTenantExtension",
+        )
+        monkeypatch.setenv("HINDSIGHT_API_TENANT_SUPABASE_URL", "https://test.supabase.co")
+        monkeypatch.setenv("HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY", "test-key")
+        monkeypatch.setenv("HINDSIGHT_API_TENANT_SCHEMA_PREFIX", "custom")
+
+        ext = load_extension("TENANT", TenantExtension)
+
+        assert ext is not None
+        assert isinstance(ext, SupabaseTenantExtension)
+        assert ext.supabase_url == "https://test.supabase.co"
+        assert ext.supabase_service_key == "test-key"
+        assert ext.schema_prefix == "custom"
+
+    def test_load_without_service_key(self, monkeypatch):
+        """Extension should load without service key — JWKS mode doesn't need it."""
+        monkeypatch.setenv(
+            "HINDSIGHT_API_TENANT_EXTENSION",
+            "hindsight_api.extensions.builtin.supabase_tenant:SupabaseTenantExtension",
+        )
+        monkeypatch.setenv("HINDSIGHT_API_TENANT_SUPABASE_URL", "https://test.supabase.co")
+        monkeypatch.delenv("HINDSIGHT_API_TENANT_SUPABASE_SERVICE_KEY", raising=False)
+
+        ext = load_extension("TENANT", TenantExtension)
+
+        assert ext is not None
+        assert isinstance(ext, SupabaseTenantExtension)
+        assert ext.supabase_service_key is None
@@ -527,6 +527,7 @@ class TestRemoteTEICrossEncoderConfig:
        """Test creating encoder from environment variables."""
        import os

+        from hindsight_api.config import clear_config_cache
        from hindsight_api.engine.cross_encoder import create_cross_encoder_from_env

        with patch.dict(
@@ -538,6 +539,7 @@ class TestRemoteTEICrossEncoderConfig:
                "HINDSIGHT_API_RERANKER_TEI_MAX_CONCURRENT": "16",
            },
        ):
+            clear_config_cache()  # Clear cache to pick up patched env vars
            encoder = create_cross_encoder_from_env()

            assert isinstance(encoder, RemoteTEICrossEncoder)
@@ -545,6 +547,8 @@ class TestRemoteTEICrossEncoderConfig:
            assert encoder.batch_size == 256
            assert encoder.max_concurrent == 16

+        clear_config_cache()  # Clear cache after test
+

 # ============================================================================
 # TEI Reranker Performance Benchmark Tests
@@ -1,5 +1,5 @@
 """
-Test think function for opinion generation and consistency.
+Test reflect (think) function.
 """
 import pytest
 from datetime import datetime, timezone
@@ -7,131 +7,6 @@ from hindsight_api.engine.memory_engine import Budget
 from hindsight_api import RequestContext


-@pytest.mark.asyncio
-async def test_think_opinion_consistency(memory, request_context):
-    """
-    Test that think function:
-    1. Generates an opinion
-    2. Stores the opinion in the database
-    3. Returns consistent response on subsequent calls with the same query
-    """
-    bank_id = f"test_think_{datetime.now(timezone.utc).timestamp()}"
-
-    try:
-
-        # Store some initial facts to give context for opinion formation
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice is a software engineer who has worked on 5 major projects. She always delivers on time and writes clean, well-documented code.",
-            context="performance review",
-            event_date=datetime(2024, 1, 15, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Bob recently joined the team. He missed his first deadline and his code had many bugs.",
-            context="performance review",
-            event_date=datetime(2024, 2, 1, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        # First think call - should generate opinions
-        query = "Who is a more reliable engineer?"
-        result1 = await memory.reflect_async(
-            bank_id=bank_id,
-            query=query,
-            budget=Budget.LOW,
-            request_context=request_context,
-        )
-
-        print(f"\n=== First Think Call ===")
-        print(f"Answer: {result1.text}")
-
-        # Verify we got an answer
-        assert result1.text, "First think call should return an answer"
-        assert result1.based_on, "Should return based_on facts"
-
-        # Wait for background opinion processing tasks to complete
-        await memory.wait_for_background_tasks()
-
-        # Search for stored opinions to verify they were actually saved
-        pool = await memory._get_pool()
-        async with pool.acquire() as conn:
-            stored_opinions = await conn.fetch(
-                """
-                SELECT id, text, confidence_score, fact_type
-                FROM memory_units
-                WHERE bank_id = $1 AND fact_type = 'opinion'
-                ORDER BY created_at DESC
-                """,
-                bank_id
-            )
-
-        print(f"\n=== Stored Opinions in Database ===")
-        print(f"Total opinions stored: {len(stored_opinions)}")
-        for op in stored_opinions:
-            print(f"  - {op['text']} (confidence: {op['confidence_score']:.2f})")
-
-        # Verify opinions were actually written to database
-        # NOTE: Opinion extraction may not always detect opinions depending on the LLM response format
-        if len(stored_opinions) > 0:
-            assert all(op['fact_type'] == 'opinion' for op in stored_opinions), "All stored items should have fact_type='opinion'"
-            print(f"✓ Opinions were successfully stored in database")
-        else:
-            print(f"⚠ Note: No opinions were extracted/stored (this can happen if the LLM response format doesn't trigger opinion extraction)")
-
-        # Second think call - should use the stored opinions
-        result2 = await memory.reflect_async(
-            bank_id=bank_id,
-            query=query,
-            budget=Budget.LOW,
-            request_context=request_context,
-        )
-
-        print(f"\n=== Second Think Call ===")
-        print(f"Answer: {result2.text}")
-        print(f"Existing opinions used: {len(result2.based_on.get('opinion', []))}")
-        for opinion in result2.based_on.get('opinion', []):
-            print(f"  - {opinion.text}")
-
-        # Verify second call also got an answer
-        assert result2.text, "Second think call should return an answer"
-
-        # Verify second call used the stored opinions (if any were stored)
-        if len(stored_opinions) > 0:
-            assert len(result2.based_on.get('opinion', [])) > 0, "Second call should retrieve stored opinions"
-
-        # The responses should be consistent (both should mention the same person as more reliable)
-        # We'll do a basic check that they're not contradictory
-        text1_lower = result1.text.lower()
-        text2_lower = result2.text.lower()
-
-        print(f"\n=== Consistency Check ===")
-
-        # Check if Alice is mentioned as more reliable in first response
-        if 'alice' in text1_lower and ('reliable' in text1_lower or 'better' in text1_lower):
-            print("First response favors Alice")
-            # Second response should also favor Alice (consistency)
-            assert 'alice' in text2_lower, "Second response should also mention Alice"
-            print("Second response also mentions Alice - CONSISTENT ✓")
-
-        # Check if Bob is mentioned
-        if 'bob' in text1_lower:
-            print("First response mentions Bob")
-            if 'bob' in text2_lower:
-                print("Second response also mentions Bob - CONSISTENT ✓")
-
-        print(f"\n✅ Test passed - opinions were formed, stored, and used consistently")
-
-    finally:
-        # Clean up agent data
-        try:
-            await memory.delete_bank(bank_id, request_context=request_context)
-        except Exception as e:
-            print(f"Warning: Error during cleanup: {e}")
-
-
@pytest.mark.asyncio
 async def test_think_without_prior_context(memory, request_context):
    """
@@ -0,0 +1,244 @@
+"""
+Test Vertex AI provider integration using native genai SDK.
+"""
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# Skip all tests if google-auth not available
+pytest.importorskip("google.auth")
+
+
+def test_llm_wrapper_vertexai_missing_dependency():
+    """Test error when google-auth is not available and service account key is set."""
+    from hindsight_api.engine import llm_wrapper
+
+    # VERTEXAI_AVAILABLE only matters when a service account key is provided
+    original_available = llm_wrapper.VERTEXAI_AVAILABLE
+    try:
+        llm_wrapper.VERTEXAI_AVAILABLE = False
+
+        with patch.dict(
+            os.environ,
+            {
+                "HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": "test-project",
+                "HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY": "/path/to/key.json",
+            },
+            clear=False,
+        ):
+            from hindsight_api.config import clear_config_cache
+
+            clear_config_cache()
+
+            with pytest.raises(ValueError, match="google-auth"):
+                from hindsight_api.engine.llm_wrapper import LLMProvider
+
+                LLMProvider(
+                    provider="vertexai",
+                    api_key="",
+                    base_url="",
+                    model="google/gemini-2.0-flash-001",
+                )
+
+            clear_config_cache()
+    finally:
+        llm_wrapper.VERTEXAI_AVAILABLE = original_available
+
+
+def test_llm_wrapper_vertexai_missing_project_id():
+    """Test error when project ID is not configured."""
+    with patch.dict(os.environ, {"HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": ""}, clear=False):
+        from hindsight_api.config import clear_config_cache
+
+        clear_config_cache()
+
+        with pytest.raises(ValueError, match="HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID"):
+            from hindsight_api.engine.llm_wrapper import LLMProvider
+
+            LLMProvider(
+                provider="vertexai",
+                api_key="",
+                base_url="",
+                model="google/gemini-2.0-flash-001",
+            )
+
+        clear_config_cache()
+
+
+def test_llm_wrapper_vertexai_adc_auth():
+    """Test Vertex AI with ADC authentication creates native genai client."""
+    from hindsight_api.engine.llm_wrapper import LLMProvider
+
+    with patch.dict(
+        os.environ,
+        {"HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": "test-project"},
+        clear=False,
+    ):
+        from hindsight_api.config import clear_config_cache
+
+        clear_config_cache()
+
+        # genai.Client handles ADC internally — just verify it creates the client
+        with patch("google.genai.Client") as mock_client_cls:
+            mock_client_cls.return_value = MagicMock()
+
+            provider = LLMProvider(
+                provider="vertexai",
+                api_key="",
+                base_url="",
+                model="google/gemini-2.0-flash-001",
+            )
+
+            assert provider.provider == "vertexai"
+            assert provider.model == "gemini-2.0-flash-001"  # google/ prefix stripped
+            assert provider._gemini_client is not None
+
+            # Verify genai.Client was called with vertexai=True
+            mock_client_cls.assert_called_once_with(
+                vertexai=True,
+                project="test-project",
+                location="us-central1",
+            )
+
+        clear_config_cache()
+
+
+def test_llm_wrapper_vertexai_sa_auth():
+    """Test Vertex AI with service account authentication passes credentials to genai client."""
+    from hindsight_api.engine.llm_wrapper import LLMProvider
+
+    mock_credentials = MagicMock()
+
+    with patch.dict(
+        os.environ,
+        {
+            "HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": "test-project",
+            "HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY": "/path/to/key.json",
+        },
+        clear=False,
+    ):
+        from hindsight_api.config import clear_config_cache
+
+        clear_config_cache()
+
+        with patch(
+            "google.oauth2.service_account.Credentials.from_service_account_file",
+            return_value=mock_credentials,
+        ):
+            with patch("google.genai.Client") as mock_client_cls:
+                mock_client_cls.return_value = MagicMock()
+
+                provider = LLMProvider(
+                    provider="vertexai",
+                    api_key="",
+                    base_url="",
+                    model="google/gemini-2.0-flash-001",
+                )
+
+                assert provider.provider == "vertexai"
+                assert provider._gemini_client is not None
+
+                # Verify credentials were passed to genai.Client
+                mock_client_cls.assert_called_once_with(
+                    vertexai=True,
+                    project="test-project",
+                    location="us-central1",
+                    credentials=mock_credentials,
+                )
+
+        clear_config_cache()
+
+
+def test_llm_wrapper_vertexai_strips_google_prefix():
+    """Test that google/ prefix is stripped from model name for native SDK."""
+    from hindsight_api.engine.llm_wrapper import LLMProvider
+
+    with patch.dict(
+        os.environ,
+        {"HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": "test-project"},
+        clear=False,
+    ):
+        from hindsight_api.config import clear_config_cache
+
+        clear_config_cache()
+
+        with patch("google.genai.Client") as mock_client_cls:
+            mock_client_cls.return_value = MagicMock()
+
+            provider = LLMProvider(
+                provider="vertexai",
+                api_key="",
+                base_url="",
+                model="google/gemini-2.0-flash-lite-001",
+            )
+
+            assert provider.model == "gemini-2.0-flash-lite-001"
+
+        clear_config_cache()
+
+
+def test_llm_wrapper_vertexai_no_prefix_model():
+    """Test that model without google/ prefix is unchanged."""
+    from hindsight_api.engine.llm_wrapper import LLMProvider
+
+    with patch.dict(
+        os.environ,
+        {"HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID": "test-project"},
+        clear=False,
+    ):
+        from hindsight_api.config import clear_config_cache
+
+        clear_config_cache()
+
+        with patch("google.genai.Client") as mock_client_cls:
+            mock_client_cls.return_value = MagicMock()
+
+            provider = LLMProvider(
+                provider="vertexai",
+                api_key="",
+                base_url="",
+                model="gemini-2.0-flash-001",
+            )
+
+            assert provider.model == "gemini-2.0-flash-001"
+
+        clear_config_cache()
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+    not os.getenv("HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID"),
+    reason="Vertex AI integration tests require HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID",
+)
+async def test_vertexai_integration_actual_api():
+    """
+    Integration test with actual Vertex AI API.
+
+    Requires:
+    - HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID
+    - ADC or HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY
+    """
+    from hindsight_api.engine.llm_wrapper import LLMProvider
+
+    provider = LLMProvider(
+        provider="vertexai",
+        api_key="",
+        base_url="",
+        model="google/gemini-2.0-flash-001",
+    )
+
+    try:
+        # Simple test call
+        response = await provider.call(
+            messages=[{"role": "user", "content": "Say 'ok' and nothing else"}],
+            max_completion_tokens=10,
+        )
+
+        assert response is not None
+        assert isinstance(response, str)
+        assert len(response) > 0
+
+    finally:
+        await provider.cleanup()
@@ -156,7 +156,6 @@ class TestWorkerPoller:
            pool=pool,
            worker_id="test-worker-1",
            executor=mock_executor,
-            batch_size=10,
        )

        claimed = await poller.claim_batch()
@@ -177,8 +176,8 @@ class TestWorkerPoller:
            assert row["worker_id"] == "test-worker-1"

    @pytest.mark.asyncio
-    async def test_claim_batch_respects_batch_size(self, pool, clean_operations):
-        """Test that claim_batch respects the batch_size limit."""
+    async def test_claim_batch_respects_max_slots(self, pool, clean_operations):
+        """Test that claim_batch respects the max_slots limit."""
        from hindsight_api.worker import WorkerPoller

        # Create 10 pending tasks
@@ -196,12 +195,11 @@ class TestWorkerPoller:
                payload,
            )

-        # Claim with batch_size=3
        poller = WorkerPoller(
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=3,
+            max_slots=3,  # Limit to 3 concurrent tasks
        )

        claimed = await poller.claim_batch()
@@ -238,11 +236,14 @@ class TestWorkerPoller:
            executor=mock_executor,
        )

-        # Execute the task
+        # Execute the task (fire-and-forget)
        task_dict = json.loads(payload)
        claimed_task = ClaimedTask(operation_id=str(op_id), task_dict=task_dict, schema=None)
        await poller.execute_task(claimed_task)

+        # Wait for background task to complete
+        completed = await poller.wait_for_active_tasks(timeout=5.0)
+        assert completed, "Task did not complete within timeout"
        assert len(executed) == 1

        # Verify task is marked as completed
@@ -283,11 +284,15 @@ class TestWorkerPoller:
            max_retries=3,
        )

-        # Execute (should fail and retry)
+        # Execute (should fail and retry) - fire-and-forget
        task_dict = json.loads(payload)
        claimed_task = ClaimedTask(operation_id=str(op_id), task_dict=task_dict, schema=None)
        await poller.execute_task(claimed_task)

+        # Wait for background task to complete
+        completed = await poller.wait_for_active_tasks(timeout=5.0)
+        assert completed, "Task did not complete within timeout"
+
        # Verify task is back to pending with incremented retry_count
        row = await pool.fetchrow(
            "SELECT status, retry_count, worker_id FROM async_operations WHERE operation_id = $1",
@@ -327,11 +332,15 @@ class TestWorkerPoller:
            max_retries=3,
        )

-        # Execute (should fail permanently)
+        # Execute (should fail permanently) - fire-and-forget
        task_dict = json.loads(payload)
        claimed_task = ClaimedTask(operation_id=str(op_id), task_dict=task_dict, schema=None)
        await poller.execute_task(claimed_task)

+        # Wait for background task to complete
+        completed = await poller.wait_for_active_tasks(timeout=5.0)
+        assert completed, "Task did not complete within timeout"
+
        # Verify task is marked as failed
        row = await pool.fetchrow(
            "SELECT status, error_message FROM async_operations WHERE operation_id = $1",
@@ -388,7 +397,6 @@ class TestWorkerPoller:
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=10,
        )

        claimed = await poller.claim_batch()
@@ -440,7 +448,6 @@ class TestWorkerPoller:
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=10,
        )

        claimed = await poller.claim_batch()
@@ -607,7 +614,6 @@ class TestConcurrentWorkers:
                pool=pool,
                worker_id=worker_id,
                executor=lambda x: None,
-                batch_size=5,  # Each worker tries to claim 5
            )
            claimed = await poller.claim_batch()
            workers_claimed[worker_id] = [task.operation_id for task in claimed]
@@ -680,7 +686,6 @@ class TestConcurrentWorkers:
            pool=pool,
            worker_id="new-worker",
            executor=lambda x: None,
-            batch_size=10,
        )

        claimed = await poller.claim_batch()
@@ -879,7 +884,6 @@ class TestDynamicTenantDiscovery:
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=10,
            tenant_extension=mock_extension,
        )

@@ -946,7 +950,6 @@ class TestDynamicTenantDiscovery:
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=10,
            tenant_extension=dynamic_extension,
        )

@@ -1008,7 +1011,6 @@ class TestDynamicTenantDiscovery:
            pool=pool,
            worker_id="test-worker-1",
            executor=lambda x: None,
-            batch_size=10,
        )

        claimed = await poller.claim_batch()
@@ -1017,3 +1019,273 @@ class TestDynamicTenantDiscovery:
        # All tasks should have schema=None (public)
        for task in claimed:
            assert task.schema is None
+
+    @pytest.mark.asyncio
+    async def test_poller_with_custom_schema(self, pool):
+        """Test that poller uses custom schema when schema parameter is provided."""
+        from hindsight_api.worker import WorkerPoller
+
+        # Create a custom schema for testing
+        test_schema = "test_custom_schema"
+
+        try:
+            # Create schema and copy table structure
+            await pool.execute(f'CREATE SCHEMA IF NOT EXISTS "{test_schema}"')
+            await pool.execute(
+                f"""
+                CREATE TABLE "{test_schema}".async_operations (
+                    LIKE public.async_operations INCLUDING ALL
+                )
+                """
+            )
+
+            # Create pending tasks in the custom schema
+            bank_id = f"test-worker-{uuid.uuid4().hex[:8]}"
+            task_ids = []
+            for i in range(3):
+                op_id = uuid.uuid4()
+                task_ids.append(str(op_id))
+                payload = json.dumps({"type": "test_task", "index": i, "bank_id": bank_id})
+                await pool.execute(
+                    f"""
+                    INSERT INTO "{test_schema}".async_operations (operation_id, bank_id, operation_type, status, task_payload)
+                    VALUES ($1, $2, 'test', 'pending', $3::jsonb)
+                    """,
+                    op_id,
+                    bank_id,
+                    payload,
+                )
+
+            # Create poller with custom schema
+            poller = WorkerPoller(
+                pool=pool,
+                worker_id="test-worker-custom-schema",
+                executor=lambda x: None,
+                schema=test_schema,
+            )
+
+            # Claim tasks
+            claimed = await poller.claim_batch()
+            assert len(claimed) == 3, f"Expected 3 tasks, got {len(claimed)}"
+
+            # All tasks should have schema=test_schema
+            claimed_ids = []
+            for task in claimed:
+                assert task.schema == test_schema, f"Expected schema '{test_schema}', got '{task.schema}'"
+                claimed_ids.append(task.operation_id)
+
+            # Verify claimed tasks match what we inserted
+            assert set(claimed_ids) == set(task_ids)
+
+            # Verify tasks are marked as processing in the custom schema
+            rows = await pool.fetch(
+                f"""
+                SELECT operation_id, status, worker_id
+                FROM "{test_schema}".async_operations
+                WHERE operation_id = ANY($1)
+                """,
+                [uuid.UUID(tid) for tid in task_ids],
+            )
+            assert len(rows) == 3
+            for row in rows:
+                assert row["status"] == "processing"
+                assert row["worker_id"] == "test-worker-custom-schema"
+
+        finally:
+            # Clean up: drop the custom schema
+            await pool.execute(f'DROP SCHEMA IF EXISTS "{test_schema}" CASCADE')
+
+
+async def test_worker_fire_and_forget_nonblocking(pool, clean_operations):
+    """
+    Test that worker continues polling while tasks run (fire-and-forget pattern).
+
+    This test verifies the FIX: With the old blocking behavior, the worker would
+    wait for all tasks in a batch to complete before claiming more. This test
+    would FAIL with the old code because tasks 3-4 wouldn't be claimed until
+    tasks 1-2 complete. With fire-and-forget, tasks 3-4 are claimed immediately.
+    """
+    from hindsight_api.worker.poller import WorkerPoller
+
+    task_started = {}  # operation_id -> Event (set when task starts)
+    task_canfinish = {}  # operation_id -> Event (wait before finishing)
+
+    async def blocking_executor(task_dict: dict):
+        op_id = task_dict["operation_id"]
+        # Signal that this task has started
+        started = asyncio.Event()
+        task_started[op_id] = started
+        started.set()
+
+        # Block until we're told to finish
+        finish = asyncio.Event()
+        task_canfinish[op_id] = finish
+        await finish.wait()
+
+    poller = WorkerPoller(
+        pool=pool,
+        worker_id="test-worker",
+        executor=blocking_executor,
+        poll_interval_ms=50,  # Fast polling
+        max_slots=10,
+        consolidation_max_slots=2,
+    )
+
+    bank_id = f"test-worker-{uuid.uuid4().hex[:8]}"
+
+    # Submit initial 2 tasks
+    task_ids = []
+    for i in range(2):
+        op_id = uuid.uuid4()
+        task_ids.append(str(op_id))
+        payload = json.dumps({"type": "test", "operation_type": "retain", "operation_id": str(op_id), "bank_id": bank_id})
+        await pool.execute(
+            """
+            INSERT INTO async_operations (operation_id, bank_id, operation_type, status, task_payload)
+            VALUES ($1, $2, 'retain', 'pending', $3::jsonb)
+            """,
+            op_id,
+            bank_id,
+            payload,
+        )
+
+    poll_task = asyncio.create_task(poller.run())
+
+    try:
+        # Wait for first 2 tasks to start executing (but not finish)
+        for i in range(100):  # Try for up to 1 second
+            if len(task_started) >= 2:
+                break
+            await asyncio.sleep(0.01)
+        assert len(task_started) == 2, f"Expected 2 tasks started, got {len(task_started)}"
+
+        # Verify tasks are in_flight
+        async with poller._in_flight_lock:
+            assert poller._in_flight_count == 2
+
+        # NOW submit 2 more tasks WHILE the first 2 are still running
+        for i in range(2):
+            op_id = uuid.uuid4()
+            task_ids.append(str(op_id))
+            payload = json.dumps({"type": "test", "operation_type": "retain", "operation_id": str(op_id), "bank_id": bank_id})
+            await pool.execute(
+                """
+                INSERT INTO async_operations (operation_id, bank_id, operation_type, status, task_payload)
+                VALUES ($1, $2, 'retain', 'pending', $3::jsonb)
+                """,
+                op_id,
+                bank_id,
+                payload,
+            )
+
+        # KEY ASSERTION: Worker should claim tasks 3-4 WITHOUT waiting for 1-2 to finish
+        # This would FAIL with the old blocking behavior
+        for i in range(100):  # Try for up to 1 second
+            if len(task_started) >= 4:
+                break
+            await asyncio.sleep(0.01)
+
+        assert len(task_started) == 4, (
+            f"Fire-and-forget FAILED: Expected 4 tasks started, got {len(task_started)}. "
+            "This means the worker blocked waiting for the first batch to complete."
+        )
+
+        # Verify all 4 tasks are in-flight
+        async with poller._in_flight_lock:
+            assert poller._in_flight_count == 4
+
+        # Clean up: allow all tasks to finish
+        for event in task_canfinish.values():
+            event.set()
+
+    finally:
+        # Ensure cleanup
+        for event in task_canfinish.values():
+            event.set()
+        await poller.shutdown_graceful(timeout=2.0)
+        try:
+            await asyncio.wait_for(poll_task, timeout=1.0)
+        except asyncio.CancelledError:
+            pass
+
+
+async def test_worker_slot_limits_enforced(pool, clean_operations):
+    """Test that worker respects max_slots and won't exceed the limit."""
+    from hindsight_api.worker.poller import WorkerPoller
+
+    tasks_started = set()
+    task_events = {}
+
+    async def controlled_executor(task_dict: dict):
+        op_id = task_dict["operation_id"]
+        tasks_started.add(op_id)
+        event = asyncio.Event()
+        task_events[op_id] = event
+        await event.wait()
+
+    poller = WorkerPoller(
+        pool=pool,
+        worker_id="test-worker",
+        executor=controlled_executor,
+        poll_interval_ms=50,
+        max_slots=3,  # Only allow 3 concurrent tasks
+        consolidation_max_slots=1,
+    )
+
+    # Submit 10 tasks
+    bank_id = f"test-worker-{uuid.uuid4().hex[:8]}"
+    for i in range(10):
+        op_id = uuid.uuid4()
+        payload = json.dumps({"type": "test", "operation_type": "retain", "operation_id": str(op_id), "bank_id": bank_id})
+        await pool.execute(
+            """
+            INSERT INTO async_operations (operation_id, bank_id, operation_type, status, task_payload)
+            VALUES ($1, $2, 'retain', 'pending', $3::jsonb)
+            """,
+            op_id,
+            bank_id,
+            payload,
+        )
+
+    poll_task = asyncio.create_task(poller.run())
+
+    try:
+        # Wait for slots to fill
+        for i in range(100):
+            if len(tasks_started) >= 3:
+                break
+            await asyncio.sleep(0.01)
+
+        # Should have claimed exactly 3 tasks (slot limit)
+        assert len(tasks_started) == 3
+
+        # Wait to ensure no additional tasks are claimed
+        for i in range(30):
+            await asyncio.sleep(0.01)
+        assert len(tasks_started) == 3, "Worker exceeded slot limit!"
+
+        # Release tasks one by one and verify remaining are claimed
+        completed = 0
+        while completed < 10 and len(tasks_started) < 10:
+            # Release the next batch
+            events_to_release = list(task_events.values())[completed:completed+3]
+            for event in events_to_release:
+                event.set()
+            completed += len(events_to_release)
+
+            # Wait for new tasks to be claimed
+            for i in range(100):
+                if len(tasks_started) >= min(completed + 3, 10):
+                    break
+                await asyncio.sleep(0.01)
+
+        assert len(tasks_started) == 10
+
+    finally:
+        for event in task_events.values():
+            event.set()
+        await poller.shutdown_graceful(timeout=2.0)
+        try:
+            await asyncio.wait_for(poll_task, timeout=1.0)
+        except asyncio.CancelledError:
+            pass
@@ -1,6 +1,6 @@
 [package]
 name = "hindsight-cli"
-version = "0.4.0"
+version = "0.4.10"
 edition = "2021"
 authors = ["Hindsight Team"]
 description = "A beautiful CLI for Hindsight - semantic memory system"
@@ -500,6 +500,8 @@ pub fn delete(
 pub fn consolidate(
    client: &ApiClient,
    bank_id: &str,
+    wait: bool,
+    poll_interval: u64,
    verbose: bool,
    output_format: OutputFormat,
 ) -> Result<()> {
@@ -517,17 +519,82 @@ pub fn consolidate(

    match response {
        Ok(result) => {
+            let operation_id = result.operation_id.clone();
+
            if output_format == OutputFormat::Pretty {
                ui::print_success("Consolidation triggered");
-                println!("  {} {}", ui::dim("Operation ID:"), result.operation_id);
+                println!("  {} {}", ui::dim("Operation ID:"), operation_id);
                if result.deduplicated {
                    println!("  {} {}", ui::dim("Note:"), "Reusing existing pending consolidation task");
                }
-                println!();
-                println!("{}", ui::dim("Use 'hindsight operation get' to check the operation status."));
            } else {
                output::print_output(&result, output_format)?;
            }
+
+            if !wait {
+                if output_format == OutputFormat::Pretty {
+                    println!();
+                    println!("{}", ui::dim("Use --wait to poll for completion, or 'hindsight operation get' to check status."));
+                }
+                return Ok(());
+            }
+
+            // Poll for completion
+            if output_format == OutputFormat::Pretty {
+                println!();
+                println!("{}", ui::dim(&format!("Polling every {}s for completion...", poll_interval)));
+            }
+
+            let start = std::time::Instant::now();
+            loop {
+                std::thread::sleep(std::time::Duration::from_secs(poll_interval));
+                let elapsed = start.elapsed().as_secs();
+
+                let ops_result = client.list_operations(bank_id, verbose);
+                match ops_result {
+                    Ok(ops) => {
+                        // Find the operation by ID
+                        let op = ops.operations.iter().find(|o| o.id == operation_id);
+
+                        match op.map(|o| o.status.as_str()) {
+                            Some("completed") => {
+                                if output_format == OutputFormat::Pretty {
+                                    ui::print_success(&format!("Consolidation completed ({}s)", elapsed));
+                                }
+                                break;
+                            }
+                            Some("failed") => {
+                                let error_msg = op
+                                    .and_then(|o| o.error_message.as_ref())
+                                    .map(|s| s.as_str())
+                                    .unwrap_or("Unknown error");
+                                if output_format == OutputFormat::Pretty {
+                                    ui::print_error(&format!("Consolidation failed: {}", error_msg));
+                                }
+                                std::process::exit(1);
+                            }
+                            Some(status) => {
+                                if output_format == OutputFormat::Pretty {
+                                    println!("  ⏳ {} ({}s elapsed)", status, elapsed);
+                                }
+                            }
+                            None => {
+                                if output_format == OutputFormat::Pretty {
+                                    ui::print_warning(&format!("Operation {} not found in list", operation_id));
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        if output_format == OutputFormat::Pretty {
+                            ui::print_error(&format!("Failed to check operation status: {}", e));
+                        }
+                        return Err(e);
+                    }
+                }
+            }
+
            Ok(())
        }
        Err(e) => Err(e),
@@ -1,4 +1,6 @@
 use anyhow::Result;
+use chrono::{Duration as ChronoDuration, NaiveDate, Utc};
+use std::collections::BTreeMap;
 use crate::api::ApiClient;
 use crate::output::{self, OutputFormat};
 use crate::ui;
@@ -7,11 +9,17 @@ pub fn list(
    client: &ApiClient,
    agent_id: &str,
    query: Option<String>,
+    date: Option<String>,
    limit: i32,
    offset: i32,
    verbose: bool,
    output_format: OutputFormat,
 ) -> Result<()> {
+    // If date filter is provided, use the date-aware listing
+    if date.is_some() {
+        return list_with_date(client, agent_id, date.as_deref(), verbose, output_format);
+    }
+
    let spinner = if output_format == OutputFormat::Pretty {
        Some(ui::create_spinner("Fetching documents..."))
    } else {
@@ -50,6 +58,139 @@ pub fn list(
    }
 }

+/// List documents with date filtering
+fn list_with_date(
+    client: &ApiClient,
+    bank_id: &str,
+    date_filter: Option<&str>,
+    verbose: bool,
+    output_format: OutputFormat,
+) -> Result<()> {
+    let spinner = if output_format == OutputFormat::Pretty {
+        Some(ui::create_spinner("Fetching all documents..."))
+    } else {
+        None
+    };
+
+    // Fetch all documents with pagination
+    let all_docs = fetch_all_documents(client, bank_id, verbose)?;
+
+    if let Some(mut sp) = spinner {
+        sp.finish();
+    }
+
+    // Parse the date filter
+    let target_date = parse_date_filter(date_filter)?;
+
+    // Filter and group documents by date
+    let mut by_date: BTreeMap<String, Vec<serde_json::Value>> = BTreeMap::new();
+    let mut filtered_count = 0;
+
+    for doc in all_docs {
+        let created_at = doc.get("created_at")
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+
+        // Parse the date part (YYYY-MM-DD) from created_at
+        let doc_date = created_at.split('T').next().unwrap_or("");
+
+        // Apply date filter if specified
+        if let Some(ref target) = target_date {
+            let target_str = target.format("%Y-%m-%d").to_string();
+            if doc_date != target_str {
+                continue;
+            }
+        }
+
+        filtered_count += 1;
+        by_date.entry(doc_date.to_string()).or_default().push(doc);
+    }
+
+    // Output
+    if output_format == OutputFormat::Pretty {
+        let filter_desc = match date_filter {
+            None | Some("yesterday") => "yesterday".to_string(),
+            Some("today") => "today".to_string(),
+            Some("all") => "all dates".to_string(),
+            Some(d) => d.to_string(),
+        };
+
+        ui::print_info(&format!(
+            "Documents for bank '{}' (filter: {}, showing: {})",
+            bank_id, filter_desc, filtered_count
+        ));
+        println!();
+
+        // Show documents grouped by date (reverse order - newest first)
+        for (date_str, docs) in by_date.iter().rev() {
+            println!("  {} ({} documents)", date_str, docs.len());
+            for doc in docs {
+                let id = doc.get("id").and_then(|v| v.as_str()).unwrap_or("unknown");
+                let mem_count = doc.get("memory_unit_count").and_then(|v| v.as_i64()).unwrap_or(0);
+                println!("    - {} ({} memories)", id, mem_count);
+            }
+            println!();
+        }
+    } else {
+        // JSON/YAML output - convert to a list structure
+        let output: Vec<serde_json::Value> = by_date.values().flatten().cloned().collect();
+        output::print_output(&output, output_format)?;
+    }
+
+    Ok(())
+}
+
+/// Fetch all documents with pagination
+fn fetch_all_documents(
+    client: &ApiClient,
+    bank_id: &str,
+    verbose: bool,
+) -> Result<Vec<serde_json::Value>> {
+    let mut all_docs = Vec::new();
+    let mut offset = 0;
+    let limit = 500;
+
+    loop {
+        let response = client.list_documents(bank_id, None, Some(limit), Some(offset), verbose)?;
+
+        if response.items.is_empty() {
+            break;
+        }
+
+        // Convert Map<String, Value> to Value for each item
+        for item in response.items {
+            all_docs.push(serde_json::Value::Object(item));
+        }
+
+        offset += limit;
+
+        // Check if we've fetched everything
+        if all_docs.len() >= response.total as usize {
+            break;
+        }
+    }
+
+    Ok(all_docs)
+}
+
+/// Parse date filter string into a NaiveDate
+fn parse_date_filter(filter: Option<&str>) -> Result<Option<NaiveDate>> {
+    match filter {
+        None | Some("yesterday") => {
+            // Default to yesterday
+            Ok(Some(Utc::now().date_naive() - ChronoDuration::days(1)))
+        }
+        Some("today") => Ok(Some(Utc::now().date_naive())),
+        Some("all") => Ok(None), // No filtering
+        Some(date_str) => {
+            // Try to parse as YYYY-MM-DD
+            NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
+                .map(Some)
+                .map_err(|e| anyhow::anyhow!("Invalid date format '{}': {}. Use YYYY-MM-DD, 'yesterday', 'today', or 'all'", date_str, e))
+        }
+    }
+}
+
 pub fn get(
    client: &ApiClient,
    agent_id: &str,
@@ -98,6 +98,7 @@ pub fn create(
    bank_id: &str,
    name: &str,
    source_query: &str,
+    id: Option<&str>,
    verbose: bool,
    output_format: OutputFormat,
 ) -> Result<()> {
@@ -108,6 +109,7 @@ pub fn create(
    };

    let request = types::CreateMentalModelRequest {
+        id: id.map(|s| s.to_string()),
        name: name.to_string(),
        source_query: source_query.to_string(),
        max_tokens: 2048,
@@ -260,6 +260,14 @@ enum BankCommands {
    Consolidate {
        /// Bank ID
        bank_id: String,
+
+        /// Wait for consolidation to complete (poll for status)
+        #[arg(long)]
+        wait: bool,
+
+        /// Poll interval in seconds (only used with --wait)
+        #[arg(long, default_value = "10")]
+        poll_interval: u64,
    },

    /// Clear all observations for a bank
@@ -441,6 +449,10 @@ enum DocumentCommands {
        #[arg(short = 'q', long)]
        query: Option<String>,

+        /// Filter by date (yesterday, today, YYYY-MM-DD, or all)
+        #[arg(short = 'd', long)]
+        date: Option<String>,
+
        /// Maximum number of results
        #[arg(short = 'l', long, default_value = "100")]
        limit: i32,
@@ -584,6 +596,10 @@ enum MentalModelCommands {

        /// Source query to generate the mental model from
        source_query: String,
+
+        /// Optional custom ID for the mental model (alphanumeric lowercase with hyphens)
+        #[arg(long)]
+        id: Option<String>,
    },

    /// Update a mental model
@@ -754,8 +770,8 @@ fn run() -> Result<()> {
            BankCommands::Delete { bank_id, yes } => {
                commands::bank::delete(&client, &bank_id, yes, verbose, output_format)
            }
-            BankCommands::Consolidate { bank_id } => {
-                commands::bank::consolidate(&client, &bank_id, verbose, output_format)
+            BankCommands::Consolidate { bank_id, wait, poll_interval } => {
+                commands::bank::consolidate(&client, &bank_id, wait, poll_interval, verbose, output_format)
            }
            BankCommands::ClearObservations { bank_id, yes } => {
                commands::bank::clear_observations(&client, &bank_id, yes, verbose, output_format)
@@ -792,8 +808,8 @@ fn run() -> Result<()> {

        // Document commands
        Commands::Document(doc_cmd) => match doc_cmd {
-            DocumentCommands::List { bank_id, query, limit, offset } => {
-                commands::document::list(&client, &bank_id, query, limit, offset, verbose, output_format)
+            DocumentCommands::List { bank_id, query, date, limit, offset } => {
+                commands::document::list(&client, &bank_id, query, date, limit, offset, verbose, output_format)
            }
            DocumentCommands::Get { bank_id, document_id } => {
                commands::document::get(&client, &bank_id, &document_id, verbose, output_format)
@@ -851,8 +867,8 @@ fn run() -> Result<()> {
            MentalModelCommands::Get { bank_id, mental_model_id } => {
                commands::mental_model::get(&client, &bank_id, &mental_model_id, verbose, output_format)
            }
-            MentalModelCommands::Create { bank_id, name, source_query } => {
-                commands::mental_model::create(&client, &bank_id, &name, &source_query, verbose, output_format)
+            MentalModelCommands::Create { bank_id, name, source_query, id } => {
+                commands::mental_model::create(&client, &bank_id, &name, &source_query, id.as_deref(), verbose, output_format)
            }
            MentalModelCommands::Update { bank_id, mental_model_id, name } => {
                commands::mental_model::update(&client, &bank_id, &mental_model_id, name, verbose, output_format)
@@ -0,0 +1,125 @@
+use std::process::Command;
+
+#[test]
+fn test_cli_help() {
+    let output = Command::new("cargo")
+        .args(["run", "--", "--help"])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Hindsight CLI"));
+}
+
+#[test]
+fn test_cli_version() {
+    let output = Command::new("cargo")
+        .args(["run", "--", "--version"])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("hindsight"));
+}
+
+#[test]
+fn test_ui_command_without_config() {
+    // Test that the ui command handles missing config gracefully
+    // Create a temp home directory with no config
+    let temp_dir = std::env::temp_dir().join(format!("hindsight-test-ui-{}", std::process::id()));
+    std::fs::create_dir_all(&temp_dir).expect("Failed to create temp dir");
+
+    let output = Command::new("cargo")
+        .args(["run", "--", "ui"])
+        .env_remove("HINDSIGHT_API_URL")
+        .env_remove("HINDSIGHT_API_KEY")
+        .env("HOME", &temp_dir)
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Either it fails with a config error or it succeeds if there's a default config
+    // Just verify it doesn't crash unexpectedly
+    assert!(
+        !output.status.success()
+        || stdout.contains("Launching Hindsight Control Plane UI")
+        || stderr.contains("Configuration error")
+        || stderr.contains("HINDSIGHT_API_URL"),
+        "Unexpected output - stdout: {}, stderr: {}",
+        stdout,
+        stderr
+    );
+
+    // Cleanup
+    std::fs::remove_dir_all(&temp_dir).ok();
+}
+
+#[test]
+fn test_ui_command_with_config() {
+    // This test is skipped by default since it requires a running control plane
+    // and would block for a long time. The other tests cover the basic functionality.
+    // To run this test manually:
+    // 1. Build the control plane: cd hindsight-control-plane && npm run build
+    // 2. Run: cargo test test_ui_command_with_config -- --ignored
+
+    // Just verify that the ui command accepts the configuration
+    let temp_dir = std::env::temp_dir().join(format!("hindsight-test-ui-valid-{}", std::process::id()));
+    std::fs::create_dir_all(&temp_dir).expect("Failed to create temp dir");
+
+    // Write a minimal config
+    let config_dir = temp_dir.join(".config").join("hindsight");
+    std::fs::create_dir_all(&config_dir).expect("Failed to create config dir");
+    let config_file = config_dir.join("config");
+    std::fs::write(&config_file, "api_url=http://localhost:8888\napi_key=test-key\n")
+        .expect("Failed to write config");
+
+    let output = Command::new("cargo")
+        .args(["run", "--", "ui", "--help"])
+        .env("HOME", &temp_dir)
+        .output()
+        .expect("Failed to execute command");
+
+    // The --help should work regardless
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Hindsight CLI") || output.status.success());
+
+    // Cleanup
+    std::fs::remove_dir_all(&temp_dir).ok();
+}
+
+#[test]
+fn test_configure_command() {
+    // Test that configure command creates/updates config
+    let temp_dir = std::env::temp_dir().join(format!("hindsight-test-{}", std::process::id()));
+    std::fs::create_dir_all(&temp_dir).expect("Failed to create temp dir");
+
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "configure",
+            "--api-url",
+            "http://localhost:9999",
+            "--api-key",
+            "test-key-123"
+        ])
+        .env("HOME", &temp_dir)
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(
+        output.status.success(),
+        "Configure command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Configuration saved") || stdout.contains("success"));
+
+    // Cleanup
+    std::fs::remove_dir_all(&temp_dir).ok();
+}
--- a/Show More
+++ b/Show More