doc: add 0.4.17 release blog post

2026-03-10 17:35:30 +01:00
709 changed files with 3442 additions and 40347 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, vertexai, minimax
+# 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=gpt-4o-mini
@@ -20,11 +20,6 @@ HINDSIGHT_API_LLM_BASE_URL=https://api.openai.com/v1
 # 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: MiniMax configuration (1M context window)
-# HINDSIGHT_API_LLM_PROVIDER=minimax
-# HINDSIGHT_API_LLM_API_KEY=your-minimax-api-key
-# HINDSIGHT_API_LLM_MODEL=MiniMax-M2.7
-
 # Example: LM Studio local configuration (Qwen 2.5 32B recommended)
 # HINDSIGHT_API_LLM_PROVIDER=lmstudio
 # HINDSIGHT_API_LLM_API_KEY=lmstudio
@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
@@ -21,20 +21,20 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
          cache-dependency-path: package-lock.json
-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@v4
      - run: npm ci --workspace=hindsight-docs
      - run: uv run generate-llms-full
      - run: npm run build --workspace=hindsight-docs
        env:
          UMAMI_URL: https://analytics.hindsight.vectorize.io
          UMAMI_WEBSITE_ID: ${{ secrets.UMAMI_WEBSITE_ID }}
-      - uses: actions/upload-pages-artifact@v4
+      - uses: actions/upload-pages-artifact@v3
        with:
          path: hindsight-docs/build
  deploy:
@@ -1,99 +0,0 @@
-name: Release Integration
-
-on:
-  push:
-    tags:
-      - 'integrations/**'
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write  # for PyPI trusted publishing
-
-    steps:
-    - uses: actions/checkout@v6
-
-    - name: Extract integration info
-      id: info
-      run: |
-        # refs/tags/integrations/litellm/v0.1.0 → integration=litellm, version=0.1.0
-        TAG="${GITHUB_REF#refs/tags/}"
-        INTEGRATION=$(echo "$TAG" | cut -d'/' -f2)
-        VERSION=$(echo "$TAG" | cut -d'/' -f3 | sed 's/^v//')
-        echo "integration=$INTEGRATION" >> $GITHUB_OUTPUT
-        echo "version=$VERSION" >> $GITHUB_OUTPUT
-        echo "tag=$TAG" >> $GITHUB_OUTPUT
-        echo "Integration: $INTEGRATION, Version: $VERSION"
-
-    - name: Detect integration type
-      id: type
-      run: |
-        if [ -f "hindsight-integrations/${{ steps.info.outputs.integration }}/pyproject.toml" ]; then
-          echo "type=python" >> $GITHUB_OUTPUT
-        else
-          echo "type=typescript" >> $GITHUB_OUTPUT
-        fi
-
-    # ── Python integrations (litellm, pydantic-ai, crewai) ──────────────────
-
-    - name: Install uv
-      if: steps.type.outputs.type == 'python'
-      uses: astral-sh/setup-uv@v7
-      with:
-        enable-cache: true
-
-    - name: Set up Python
-      if: steps.type.outputs.type == 'python'
-      uses: actions/setup-python@v5
-      with:
-        python-version-file: ".python-version"
-
-    - name: Build Python package
-      if: steps.type.outputs.type == 'python'
-      working-directory: ./hindsight-integrations/${{ steps.info.outputs.integration }}
-      run: uv build --out-dir dist
-
-    - name: Publish Python package to PyPI
-      if: steps.type.outputs.type == 'python'
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        packages-dir: ./hindsight-integrations/${{ steps.info.outputs.integration }}/dist
-        skip-existing: true
-
-    # ── TypeScript integrations (ai-sdk, chat, openclaw) ────────────────────
-
-    - name: Set up Node.js
-      if: steps.type.outputs.type == 'typescript'
-      uses: actions/setup-node@v6
-      with:
-        node-version: '22'
-        registry-url: 'https://registry.npmjs.org'
-
-    - name: Install dependencies
-      if: steps.type.outputs.type == 'typescript'
-      working-directory: ./hindsight-integrations/${{ steps.info.outputs.integration }}
-      run: npm ci
-
-    - name: Build TypeScript package
-      if: steps.type.outputs.type == 'typescript'
-      working-directory: ./hindsight-integrations/${{ steps.info.outputs.integration }}
-      run: npm run build
-
-    - name: Publish TypeScript package to npm
-      if: steps.type.outputs.type == 'typescript'
-      working-directory: ./hindsight-integrations/${{ steps.info.outputs.integration }}
-      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 }}
@@ -13,15 +13,15 @@ jobs:
      id-token: write

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Install uv
-      uses: astral-sh/setup-uv@v7
+      uses: astral-sh/setup-uv@v5
      with:
        enable-cache: true

    - name: Set up Python
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v5
      with:
        python-version-file: ".python-version"

@@ -30,39 +30,37 @@ jobs:
      working-directory: ./hindsight-clients/python
      run: uv build --out-dir dist

-    - name: Build hindsight-api-slim
-      working-directory: ./hindsight-api-slim
-      run: uv build --out-dir dist
-
    - name: Build hindsight-api
      working-directory: ./hindsight-api
      run: uv build --out-dir dist

    - name: Build hindsight-all
-      working-directory: ./hindsight-all
+      working-directory: ./hindsight
      run: uv build --out-dir dist

-    - name: Build hindsight-all-slim
-      working-directory: ./hindsight-all-slim
+    - name: Build hindsight-litellm
+      working-directory: ./hindsight-integrations/litellm
      run: uv build --out-dir dist

    - name: Build hindsight-embed
      working-directory: ./hindsight-embed
      run: uv build --out-dir dist

-    # Publish in order (client and api-slim first, then api/all wrappers which depend on them)
+    - name: Build hindsight-crewai
+      working-directory: ./hindsight-integrations/crewai
+      run: uv build --out-dir dist
+
+    - name: Build hindsight-pydantic-ai
+      working-directory: ./hindsight-integrations/pydantic-ai
+      run: uv build --out-dir dist
+
+    # Publish in order (client and api first, then hindsight-all which depends on them)
    - name: Publish hindsight-client to PyPI
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        packages-dir: ./hindsight-clients/python/dist
        skip-existing: true

-    - name: Publish hindsight-api-slim to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        packages-dir: ./hindsight-api-slim/dist
-        skip-existing: true
-
    - name: Publish hindsight-api to PyPI
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
@@ -72,13 +70,13 @@ jobs:
    - name: Publish hindsight-all to PyPI
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
-        packages-dir: ./hindsight-all/dist
+        packages-dir: ./hindsight/dist
        skip-existing: true

-    - name: Publish hindsight-all-slim to PyPI
+    - name: Publish hindsight-litellm to PyPI
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
-        packages-dir: ./hindsight-all-slim/dist
+        packages-dir: ./hindsight-integrations/litellm/dist
        skip-existing: true

    - name: Publish hindsight-embed to PyPI
@@ -87,18 +85,31 @@ jobs:
        packages-dir: ./hindsight-embed/dist
        skip-existing: true

+    - name: Publish hindsight-crewai to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        packages-dir: ./hindsight-integrations/crewai/dist
+        skip-existing: true
+
+    - name: Publish hindsight-pydantic-ai to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        packages-dir: ./hindsight-integrations/pydantic-ai/dist
+        skip-existing: true
+
    # Upload artifacts for GitHub release
    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: python-packages
        path: |
          hindsight-clients/python/dist/*
-          hindsight-api-slim/dist/*
          hindsight-api/dist/*
-          hindsight-all/dist/*
-          hindsight-all-slim/dist/*
+          hindsight/dist/*
+          hindsight-integrations/litellm/dist/*
          hindsight-embed/dist/*
+          hindsight-integrations/crewai/dist/*
+          hindsight-integrations/pydantic-ai/dist/*
        retention-days: 1

  release-typescript-client:
@@ -106,10 +117,10 @@ jobs:
    environment: npm

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Set up Node.js
-      uses: actions/setup-node@v6
+      uses: actions/setup-node@v4
      with:
        node-version: '20'
        registry-url: 'https://registry.npmjs.org'
@@ -144,21 +155,168 @@ jobs:
      run: npm pack

    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: typescript-client
        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-chat-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/chat
+      run: npm ci
+
+    - name: Build
+      working-directory: ./hindsight-integrations/chat
+      run: npm run build
+
+    - name: Publish to npm
+      working-directory: ./hindsight-integrations/chat
+      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/chat
+      run: npm pack
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: chat-integration
+        path: hindsight-integrations/chat/*.tgz
+        retention-days: 1
+
  release-control-plane:
    runs-on: ubuntu-latest
    environment: npm

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Set up Node.js
-      uses: actions/setup-node@v6
+      uses: actions/setup-node@v4
      with:
        node-version: '20'
        registry-url: 'https://registry.npmjs.org'
@@ -206,7 +364,7 @@ jobs:
      run: npm pack

    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: control-plane
        path: hindsight-control-plane/*.tgz
@@ -235,7 +393,7 @@ jobs:
            asset_name: hindsight-linux-arm64

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Install Rust
      uses: dtolnay/rust-toolchain@stable
@@ -253,7 +411,7 @@ jobs:
        chmod +x artifacts/${{ matrix.asset_name }}

    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: rust-cli-${{ matrix.asset_name }}
        path: artifacts/${{ matrix.asset_name }}
@@ -294,7 +452,7 @@ jobs:
              PRELOAD_ML_MODELS=false

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Free Disk Space
      uses: jlumbroso/free-disk-space@main
@@ -308,13 +466,13 @@ jobs:
        swap-storage: true

    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v4
+      uses: docker/setup-qemu-action@v3

    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v4
+      uses: docker/setup-buildx-action@v3

    - name: Log in to GitHub Container Registry
-      uses: docker/login-action@v4
+      uses: docker/login-action@v3
      with:
        registry: ghcr.io
        username: ${{ github.actor }}
@@ -326,7 +484,7 @@ jobs:

    - name: Extract metadata for release tags
      id: meta
-      uses: docker/metadata-action@v6
+      uses: docker/metadata-action@v5
      with:
        images: ghcr.io/${{ github.repository_owner }}/${{ matrix.image_name }}
        flavor: |
@@ -342,7 +500,7 @@ jobs:
    # # Step 1: Build for local testing (single platform, no push)
    # # This creates an identical image to what will be released, just for one platform
    # - name: Build image for testing
-    #   uses: docker/build-push-action@v7
+    #   uses: docker/build-push-action@v6
    #   with:
    #     context: .
    #     file: docker/standalone/Dockerfile
@@ -361,7 +519,7 @@ jobs:

    # Build multi-platform and push to release tags
    - name: Build and push release images
-      uses: docker/build-push-action@v7
+      uses: docker/build-push-action@v6
      with:
        context: .
        file: docker/standalone/Dockerfile
@@ -379,7 +537,7 @@ jobs:
      packages: write

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Install Helm
      uses: azure/setup-helm@v4
@@ -399,7 +557,7 @@ jobs:
      run: helm push helm-packages/*.tgz oci://ghcr.io/${{ github.repository_owner }}/charts

    - name: Upload artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: helm-chart
        path: helm-packages/*.tgz
@@ -407,55 +565,73 @@ 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-chat-integration, release-control-plane, release-rust-cli, release-docker-images, release-helm-chart]
    permissions:
      contents: write

    steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4

    - name: Extract version from tag
      id: get_version
      run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT

    - name: Download Python packages
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: python-packages
        path: ./artifacts/python-packages

    - name: Download TypeScript client
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        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 Chat Integration
+      uses: actions/download-artifact@v4
+      with:
+        name: chat-integration
+        path: ./artifacts/chat-integration
+
    - name: Download Control Plane
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: control-plane
        path: ./artifacts/control-plane

    - name: Download Rust CLI (Linux)
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: rust-cli-hindsight-linux-amd64
        path: ./artifacts/rust-cli-linux

    - name: Download Rust CLI (macOS Intel)
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: rust-cli-hindsight-darwin-amd64
        path: ./artifacts/rust-cli-darwin-amd64

    - name: Download Rust CLI (macOS ARM)
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: rust-cli-hindsight-darwin-arm64
        path: ./artifacts/rust-cli-darwin-arm64

    - name: Download Helm chart
-      uses: actions/download-artifact@v8
+      uses: actions/download-artifact@v4
      with:
        name: helm-chart
        path: ./artifacts/helm-chart
@@ -465,13 +641,19 @@ jobs:
        mkdir -p release-assets
        # Python packages
        cp artifacts/python-packages/hindsight-clients/python/dist/* release-assets/ || true
-        cp artifacts/python-packages/hindsight-api-slim/dist/* release-assets/ || true
        cp artifacts/python-packages/hindsight-api/dist/* release-assets/ || true
-        cp artifacts/python-packages/hindsight-all/dist/* release-assets/ || true
-        cp artifacts/python-packages/hindsight-all-slim/dist/* release-assets/ || true
+        cp artifacts/python-packages/hindsight/dist/* release-assets/ || true
+        cp artifacts/python-packages/hindsight-integrations/litellm/dist/* release-assets/ || true
+        cp artifacts/python-packages/hindsight-integrations/pydantic-ai/dist/* release-assets/ || true
        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
+        # Chat Integration
+        cp artifacts/chat-integration/*.tgz release-assets/ || true
        # Control Plane
        cp artifacts/control-plane/*.tgz release-assets/ || true
        # Rust CLI binaries
@@ -17,20 +17,20 @@ Hindsight is an agent memory system that provides long-term memory for AI agents
 ./scripts/dev/start-api.sh

 # Run all tests (parallelized with pytest-xdist)
-cd hindsight-api-slim && uv run pytest tests/
+cd hindsight-api && uv run pytest tests/

 # Run specific test file
-cd hindsight-api-slim && uv run pytest tests/test_http_api_integration.py -v
+cd hindsight-api && uv run pytest tests/test_http_api_integration.py -v

 # Run single test function
-cd hindsight-api-slim && uv run pytest tests/test_retain.py::test_retain_simple -v
+cd hindsight-api && uv run pytest tests/test_retain.py::test_retain_simple -v

 # Lint and format
-cd hindsight-api-slim && uv run ruff check .
-cd hindsight-api-slim && uv run ruff format .
+cd hindsight-api && uv run ruff check .
+cd hindsight-api && uv run ruff format .

 # Type checking (uses ty - extremely fast type checker from Astral)
-cd hindsight-api-slim && uv run ty check hindsight_api/
+cd hindsight-api && uv run ty check hindsight_api/
 ```

 ### Control Plane (Next.js)
@@ -72,7 +72,7 @@ cd hindsight-control-plane && npm run dev
 ## Architecture

 ### Monorepo Structure
- **hindsight-api-slim/**: Core FastAPI server with memory engine (Python, uv)
+- **hindsight-api/**: Core FastAPI server with memory engine (Python, uv)
 - **hindsight/**: Embedded Python bundle (hindsight-all package)
 - **hindsight-control-plane/**: Admin UI (Next.js, npm)
 - **hindsight-cli/**: CLI tool (Rust, cargo, uses progenitor for API client)
@@ -81,9 +81,9 @@ cd hindsight-control-plane && npm run dev
 - **hindsight-integrations/**: Framework integrations (LiteLLM, OpenAI)
 - **hindsight-dev/**: Development tools and benchmarks

-### Core Engine (hindsight-api-slim/hindsight_api/engine/)
+### Core Engine (hindsight-api/hindsight_api/engine/)
 - `memory_engine.py`: Main orchestrator (~170KB) for retain/recall/reflect operations
- `llm_wrapper.py`: LLM abstraction supporting OpenAI, Anthropic, Gemini, Groq, MiniMax, Ollama, LM Studio
+- `llm_wrapper.py`: LLM abstraction supporting OpenAI, Anthropic, Gemini, Groq, Ollama, LM Studio
 - `embeddings.py`: Embedding generation (local sentence-transformers or TEI)
 - `cross_encoder.py`: Reranking (local or TEI)
 - `entity_resolver.py`: Entity extraction and normalization
@@ -101,7 +101,7 @@ cd hindsight-control-plane && npm run dev
 - `fusion.py`: Reciprocal rank fusion for combining results
 - `reranking.py`: Cross-encoder reranking

-### API Layer (hindsight-api-slim/hindsight_api/api/)
+### API Layer (hindsight-api/hindsight_api/api/)
 - `http.py`: FastAPI HTTP routers (~80KB) for all REST endpoints
 - `mcp.py`: Model Context Protocol server implementation

@@ -111,13 +111,13 @@ Main operations:
 - **Reflect**: Disposition-aware reasoning using memories and mental models.

 ### Database
-PostgreSQL with pgvector. Schema managed via Alembic migrations in `hindsight-api-slim/hindsight_api/alembic/`. Migrations run automatically on API startup.
+PostgreSQL with pgvector. Schema managed via Alembic migrations in `hindsight-api/hindsight_api/alembic/`. Migrations run automatically on API startup.

 Key tables: `banks`, `memory_units`, `documents`, `entities`, `entity_links`

 ### Adding Database Migrations

-1. **Create a new migration file** in `hindsight-api-slim/hindsight_api/alembic/versions/`:
+1. **Create a new migration file** in `hindsight-api/hindsight_api/alembic/versions/`:
   - File name format: `<revision_id>_<description>.py` (e.g., `f1a2b3c4d5e6_add_new_index.py`)
   - Use a unique hex revision ID (12 chars)
   - Set `down_revision` to the previous migration's revision ID
@@ -251,7 +251,7 @@ Fields must be categorized as either **hierarchical** (can be overridden per-ten

 #### Adding a New Configuration Field

-1. **config.py** (`hindsight-api-slim/hindsight_api/config.py`):
+1. **config.py** (`hindsight-api/hindsight_api/config.py`):
   - Add `ENV_*` constant for the environment variable name (e.g., `ENV_MY_SETTING = "HINDSIGHT_API_MY_SETTING"`)
   - Add `DEFAULT_*` constant for the default value
   - Add field to `HindsightConfig` dataclass with type annotation
@@ -268,7 +268,7 @@ Fields must be categorized as either **hierarchical** (can be overridden per-ten
   # Static field - just don't add to _HIERARCHICAL_FIELDS
   ```

-2. **main.py** (`hindsight-api-slim/hindsight_api/main.py`):
+2. **main.py** (`hindsight-api/hindsight_api/main.py`):
   - Add field to the manual `HindsightConfig()` constructor call (search for "CLI override")

 3. **Use hierarchical config in MemoryEngine**:
@@ -308,14 +308,14 @@ cp .env.example .env
 # Edit .env with LLM API key

 # Python deps
-uv sync --directory hindsight-api-slim/
+uv sync --directory hindsight-api/

 # Node deps (uses npm workspaces)
 npm install
 ```

 Required env vars:
- `HINDSIGHT_API_LLM_PROVIDER`: openai, anthropic, gemini, groq, minimax, ollama, lmstudio
+- `HINDSIGHT_API_LLM_PROVIDER`: openai, anthropic, gemini, groq, ollama, lmstudio
 - `HINDSIGHT_API_LLM_API_KEY`: Your API key
 - `HINDSIGHT_API_LLM_MODEL`: Model name (e.g., gpt-4o-mini, claude-sonnet-4-20250514)

@@ -9,9 +9,8 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/hindsight-api?label=PyPI)
 ![NPM Downloads](https://img.shields.io/npm/dm/%40vectorize-io%2Fhindsight-client?logoColor=orange&label=NPM&color=blue&link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F%40vectorize-io%2Fhindsight-client)
-<br/>

-<a href="https://trendshift.io/repositories/15603" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15603" alt="vectorize-io%2Fhindsight | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 </div>

 ---
@@ -70,7 +69,7 @@ docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \
 >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`, `lmstudio`, and `minimax`. The documentation provides more details on [supported models](https://hindsight.vectorize.io/developer/models).
+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).



@@ -1,139 +0,0 @@
-{
-  "version": "5",
-  "specifiers": {
-    "jsr:@std/assert@^1.0.17": "1.0.19",
-    "jsr:@std/assert@^1.0.19": "1.0.19",
-    "jsr:@std/expect@*": "1.0.18",
-    "jsr:@std/internal@^1.0.12": "1.0.12",
-    "jsr:@std/path@^1.1.4": "1.1.4",
-    "jsr:@std/testing@*": "1.0.17"
-  },
-  "jsr": {
-    "@std/[email protected]": {
-      "integrity": "eaada96ee120cb980bc47e040f82814d786fe8162ecc53c91d8df60b8755991e",
-      "dependencies": [
-        "jsr:@std/internal"
-      ]
-    },
-    "@std/[email protected]": {
-      "integrity": "8566eab35200466f8609eb7e7aed062ed0db314e9a258d5d201b1b8997ce801a",
-      "dependencies": [
-        "jsr:@std/assert@^1.0.19",
-        "jsr:@std/internal",
-        "jsr:@std/path"
-      ]
-    },
-    "@std/[email protected]": {
-      "integrity": "972a634fd5bc34b242024402972cd5143eac68d8dffaca5eaa4dba30ce17b027"
-    },
-    "@std/[email protected]": {
-      "integrity": "1d2d43f39efb1b42f0b1882a25486647cb851481862dc7313390b2bb044314b5",
-      "dependencies": [
-        "jsr:@std/internal"
-      ]
-    },
-    "@std/[email protected]": {
-      "integrity": "87bdc2700fa98249d48a17cd72413352d3d3680dcfbdb64947fd0982d6bbf681",
-      "dependencies": [
-        "jsr:@std/assert@^1.0.17",
-        "jsr:@std/internal"
-      ]
-    }
-  },
-  "workspace": {
-    "members": {
-      "hindsight-clients/typescript": {
-        "packageJson": {
-          "dependencies": [
-            "npm:@hey-api/[email protected]",
-            "npm:@types/jest@29",
-            "npm:@types/node@20",
-            "npm:jest@29",
-            "npm:ts-jest@29",
-            "npm:tsup@^8.5.1",
-            "npm:typescript@5"
-          ]
-        }
-      },
-      "hindsight-control-plane": {
-        "packageJson": {
-          "dependencies": [
-            "npm:@eslint/eslintrc@^3.3.3",
-            "npm:@eslint/js@^9.39.2",
-            "npm:@radix-ui/react-alert-dialog@^1.1.15",
-            "npm:@radix-ui/react-checkbox@^1.3.3",
-            "npm:@radix-ui/react-dialog@^1.1.15",
-            "npm:@radix-ui/react-dropdown-menu@^2.1.16",
-            "npm:@radix-ui/react-label@^2.1.8",
-            "npm:@radix-ui/react-popover@^1.1.15",
-            "npm:@radix-ui/react-radio-group@^1.3.8",
-            "npm:@radix-ui/react-select@^2.2.6",
-            "npm:@radix-ui/react-slider@^1.3.6",
-            "npm:@radix-ui/react-slot@^1.2.4",
-            "npm:@radix-ui/react-switch@^1.2.6",
-            "npm:@radix-ui/react-tabs@^1.1.13",
-            "npm:@radix-ui/react-tooltip@^1.2.8",
-            "npm:@tailwindcss/postcss@^4.1.17",
-            "npm:@tailwindcss/typography@~0.5.19",
-            "npm:@types/cytoscape@^3.21.9",
-            "npm:@types/node@^24.10.0",
-            "npm:@types/react-dom@^19.2.2",
-            "npm:@types/react@^19.2.2",
-            "npm:autoprefixer@^10.4.21",
-            "npm:class-variance-authority@~0.7.1",
-            "npm:clsx@^2.1.1",
-            "npm:cmdk@^1.1.1",
-            "npm:cytoscape-fcose@^2.2.0",
-            "npm:cytoscape@^3.33.1",
-            "npm:eslint-config-next@^16.0.1",
-            "npm:eslint-plugin-react-hooks@^7.0.1",
-            "npm:eslint-plugin-react@^7.37.5",
-            "npm:eslint@^9.39.1",
-            "npm:[email protected]",
-            "npm:next-themes@~0.4.6",
-            "npm:next@^16.1.6",
-            "npm:postcss@^8.5.6",
-            "npm:prettier@^3.7.4",
-            "npm:react-chrono@^2.9.1",
-            "npm:react-dom@^19.2.0",
-            "npm:react-markdown@^10.1.0",
-            "npm:react18-json-view@~0.2.9",
-            "npm:react@^19.2.0",
-            "npm:recharts@^3.5.1",
-            "npm:remark-gfm@^4.0.1",
-            "npm:sonner@^2.0.7",
-            "npm:tailwind-merge@^3.4.0",
-            "npm:tailwindcss-animate@^1.0.7",
-            "npm:tailwindcss@^4.1.17",
-            "npm:[email protected]",
-            "npm:typescript-eslint@^8.50.0",
-            "npm:typescript@^5.9.3"
-          ]
-        }
-      },
-      "hindsight-docs": {
-        "packageJson": {
-          "dependencies": [
-            "npm:@docusaurus/[email protected]",
-            "npm:@docusaurus/[email protected]",
-            "npm:@docusaurus/[email protected]",
-            "npm:@docusaurus/theme-common@^3.9.2",
-            "npm:@docusaurus/theme-mermaid@^3.9.2",
-            "npm:@docusaurus/[email protected]",
-            "npm:@docusaurus/[email protected]",
-            "npm:@easyops-cn/docusaurus-search-local@~0.52.2",
-            "npm:@mdx-js/react@3",
-            "npm:clsx@2",
-            "npm:prism-react-renderer@^2.3.0",
-            "npm:raw-loader@^4.0.2",
-            "npm:react-dom@19",
-            "npm:react-icons@^5.6.0",
-            "npm:react@19",
-            "npm:redocusaurus@^2.5.0",
-            "npm:typescript@~5.6.2"
-          ]
-        }
-      }
-    }
-  }
-}
@@ -42,22 +42,25 @@ RUN apt-get update && apt-get install -y \
    && pip install --no-cache-dir uv

 # Copy dependency files and README (required by pyproject.toml)
-COPY hindsight-api-slim/pyproject.toml ./api/
-COPY hindsight-api-slim/README.md ./api/
+COPY hindsight-api/pyproject.toml ./api/
+COPY hindsight-api/README.md ./api/

 WORKDIR /app/api

-# Sync dependencies using appropriate extras based on INCLUDE_LOCAL_MODELS
-# local-ml: torch, sentence-transformers, transformers, einops, flashrank, mlx (optional)
-# embedded-db: pg0-embedded (always included for embedded PostgreSQL support)
-RUN if [ "$INCLUDE_LOCAL_MODELS" = "true" ]; then \
-        uv sync --extra local-ml --extra embedded-db; \
-    else \
-        uv sync --extra embedded-db; \
+# Remove local ML model dependencies if INCLUDE_LOCAL_MODELS=false
+# This creates a smaller image when using external providers (TEI, OpenAI, Cohere)
+RUN if [ "$INCLUDE_LOCAL_MODELS" != "true" ]; then \
+        echo "Removing local-models dependencies (sentence-transformers, torch, transformers)..." && \
+        sed -i '/"sentence-transformers/d' pyproject.toml && \
+        sed -i '/"transformers/d' pyproject.toml && \
+        sed -i '/"torch/d' pyproject.toml; \
    fi

+# Sync dependencies (will create lock file if needed)
+RUN uv sync
+
 # Copy source code (alembic migrations are inside hindsight_api/)
-COPY hindsight-api-slim/hindsight_api ./hindsight_api
+COPY hindsight-api/hindsight_api ./hindsight_api

 # Install the local package (uv sync only installed dependencies, not the package itself)
 RUN uv pip install -e .
@@ -111,7 +111,6 @@ fi
 if [ "$ENABLE_CP" = "true" ]; then
    echo "🎛️  Starting Control Plane..."
    cd /app/control-plane
-    export HOSTNAME="${HINDSIGHT_CP_HOSTNAME:-0.0.0.0}"
    PORT="${HINDSIGHT_CP_PORT:-9999}" node server.js &
    CP_PID=$!
    PIDS+=($CP_PID)
@@ -49,9 +49,6 @@

 set -euo pipefail

-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(dirname "$SCRIPT_DIR")"
-
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -181,21 +178,6 @@ for i in $(seq 1 "$TIMEOUT"); do
        echo "=== Health Response ==="
        curl -s "http://localhost:${HEALTH_PORT}${HEALTH_PATH}" | python3 -m json.tool 2>/dev/null || curl -s "http://localhost:${HEALTH_PORT}${HEALTH_PATH}"
        echo ""
-
-        # Run retain/recall smoke test for API targets
-        if [ "$TARGET" != "cp-only" ]; then
-            echo ""
-            echo "=== Retain/Recall Smoke Test ==="
-            if ! "$REPO_ROOT/scripts/smoke-test-slim.sh" "http://localhost:${HEALTH_PORT}"; then
-                echo ""
-                echo "=== Container Logs (last 50 lines) ==="
-                docker logs "$CONTAINER_NAME" 2>&1 | tail -50
-                echo ""
-                echo -e "${RED}Smoke test FAILED${NC}"
-                exit 1
-            fi
-        fi
-
        echo ""
        echo "=== Container Logs (last 50 lines) ==="
        docker logs "$CONTAINER_NAME" 2>&1 | tail -50
@@ -2,8 +2,8 @@ apiVersion: v2
 name: hindsight
 description: Hindsight helm chart
 type: application
-version: 0.4.19
-appVersion: "0.4.19"
+version: 0.4.17
+appVersion: "0.4.17"
 keywords:
  - ai
  - memory
@@ -1,33 +0,0 @@
-[build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "hindsight-all-slim"
-version = "0.4.19"
-description = "Hindsight: Agent Memory That Works Like Human Memory - Slim All-in-One Bundle"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = [
-    "hindsight-api-slim>=0.4.17",
-    "hindsight-client>=0.0.7",
-    "hindsight-embed>=0.1.0",
-]
-
-[tool.uv.sources]
-hindsight-api-slim = { workspace = true }
-hindsight-client = { workspace = true }
-hindsight-embed = { workspace = true }
-
-[project.optional-dependencies]
-test = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-]
-
-[tool.setuptools]
-packages = []
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
@@ -1,48 +0,0 @@
-# hindsight-all
-
-All-in-one package for Hindsight - Agent Memory That Works Like Human Memory
-
-## Quick Start
-
-```python
-from hindsight import start_server, HindsightClient
-
-# Start server with embedded PostgreSQL
-server = start_server(
-    llm_provider="groq",
-    llm_api_key="your-api-key",
-    llm_model="openai/gpt-oss-120b"
-)
-
-# Create client
-client = HindsightClient(base_url=server.url)
-
-# Store memories
-client.put(agent_id="assistant", content="User prefers Python for data analysis")
-
-# Search memories
-results = client.search(agent_id="assistant", query="programming preferences")
-
-# Generate contextual response
-response = client.think(agent_id="assistant", query="What languages should I recommend?")
-
-# Stop server when done
-server.stop()
-```
-
-## Using Context Manager
-
-```python
-from hindsight import HindsightServer, HindsightClient
-
-with HindsightServer(llm_provider="groq", llm_api_key="...") as server:
-    client = HindsightClient(base_url=server.url)
-    # ... use client ...
-# Server automatically stops
-```
-
-## Installation
-
-```bash
-pip install hindsight-all
-```
@@ -1,423 +0,0 @@
-"""
-Wrapper for Hindsight client that adds API namespaces.
-
-Provides organized access to different parts of the Hindsight API through
-namespaces like .banks, .mental_models, etc.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from hindsight_client import Hindsight
-
-
-class BanksAPI:
-    """Namespace for bank-related operations.
-    
-    Provides methods to create, delete, and manage memory banks.
-    """
-
-    def __init__(self, client: Hindsight):
-        self._client = client
-
-    def create(
-        self,
-        bank_id: str,
-        name: str | None = None,
-        mission: str | None = None,
-        disposition: dict[str, Any] | None = None,
-    ) -> Any:
-        """Create a new bank.
-        
-        Args:
-            bank_id: Unique identifier for the bank.
-            name: Optional display name for the bank.
-            mission: Optional mission statement for the bank.
-            disposition: Optional disposition configuration dict.
-            
-        Returns:
-            Bank creation response from the API.
-        """
-        return self._client.create_bank(
-            bank_id=bank_id,
-            name=name,
-            mission=mission,
-            disposition=disposition,
-        )
-
-    def delete(self, bank_id: str) -> Any:
-        """Delete a bank.
-        
-        Args:
-            bank_id: The ID of the bank to delete.
-            
-        Returns:
-            Deletion response from the API.
-        """
-        return self._client.delete_bank(bank_id=bank_id)
-
-    def set_mission(self, bank_id: str, mission: str) -> Any:
-        """Set or update the mission for a bank.
-        
-        Args:
-            bank_id: The ID of the bank.
-            mission: The mission statement to set.
-            
-        Returns:
-            API response confirming the update.
-        """
-        return self._client.set_mission(bank_id=bank_id, mission=mission)
-
-    def set_disposition(self, bank_id: str, disposition: dict[str, Any]) -> Any:
-        """Set or update the disposition for a bank.
-        
-        Args:
-            bank_id: The ID of the bank.
-            disposition: The disposition configuration dict.
-            
-        Returns:
-            API response confirming the update.
-        """
-        return self._client.set_disposition(bank_id=bank_id, disposition=disposition)
-
-    def list(self) -> Any:
-        """List all banks.
-        
-        Returns:
-            List of banks from the API.
-        """
-        from hindsight_client.hindsight_client import _run_async
-
-        return _run_async(self._client._banks_api.list_banks())
-
-
-class MentalModelsAPI:
-    """Namespace for mental model operations.
-    
-    Mental models are reusable knowledge structures that guide agent behavior.
-    """
-
-    def __init__(self, client: Hindsight):
-        self._client = client
-
-    def create(
-        self,
-        bank_id: str,
-        name: str,
-        content: str,
-        tags: list[str] | None = None,
-    ) -> Any:
-        """Create a new mental model.
-        
-        Args:
-            bank_id: The ID of the bank to add the model to.
-            name: Name for the mental model.
-            content: The content/instructions for the mental model.
-            tags: Optional list of tags for categorization.
-            
-        Returns:
-            Creation response from the API.
-        """
-        return self._client.create_mental_model(
-            bank_id=bank_id,
-            name=name,
-            content=content,
-            tags=tags,
-        )
-
-    def list(self, bank_id: str, tags: list[str] | None = None) -> Any:
-        """List all mental models for a bank.
-        
-        Args:
-            bank_id: The ID of the bank.
-            tags: Optional filter by tags.
-            
-        Returns:
-            List of mental models.
-        """
-        return self._client.list_mental_models(bank_id=bank_id, tags=tags)
-
-    def get(self, bank_id: str, mental_model_id: str) -> Any:
-        """Get a specific mental model.
-        
-        Args:
-            bank_id: The ID of the bank.
-            mental_model_id: The ID of the mental model.
-            
-        Returns:
-            The mental model details.
-        """
-        return self._client.get_mental_model(bank_id=bank_id, mental_model_id=mental_model_id)
-
-    def refresh(self, bank_id: str, mental_model_id: str) -> Any:
-        """Refresh a mental model.
-        
-        Args:
-            bank_id: The ID of the bank.
-            mental_model_id: The ID of the mental model to refresh.
-            
-        Returns:
-            Refresh response from the API.
-        """
-        return self._client.refresh_mental_model(bank_id=bank_id, mental_model_id=mental_model_id)
-
-    def update(
-        self,
-        bank_id: str,
-        mental_model_id: str,
-        name: str | None = None,
-        content: str | None = None,
-        tags: list[str] | None = None,
-    ) -> Any:
-        """Update a mental model.
-        
-        Args:
-            bank_id: The ID of the bank.
-            mental_model_id: The ID of the mental model to update.
-            name: Optional new name.
-            content: Optional new content.
-            tags: Optional new tags list.
-            
-        Returns:
-            Update response from the API.
-        """
-        return self._client.update_mental_model(
-            bank_id=bank_id,
-            mental_model_id=mental_model_id,
-            name=name,
-            content=content,
-            tags=tags,
-        )
-
-    def delete(self, bank_id: str, mental_model_id: str) -> Any:
-        """Delete a mental model.
-        
-        Args:
-            bank_id: The ID of the bank.
-            mental_model_id: The ID of the mental model to delete.
-            
-        Returns:
-            Deletion response from the API.
-        """
-        return self._client.delete_mental_model(bank_id=bank_id, mental_model_id=mental_model_id)
-
-
-class DirectivesAPI:
-    """Namespace for directive operations.
-    
-    Directives are explicit instructions that guide agent behavior.
-    """
-
-    def __init__(self, client: Hindsight):
-        self._client = client
-
-    def create(
-        self,
-        bank_id: str,
-        name: str,
-        content: str,
-        tags: list[str] | None = None,
-    ) -> Any:
-        """Create a new directive.
-        
-        Args:
-            bank_id: The ID of the bank to add the directive to.
-            name: Name for the directive.
-            content: The directive content/instructions.
-            tags: Optional list of tags for categorization.
-            
-        Returns:
-            Creation response from the API.
-        """
-        return self._client.create_directive(
-            bank_id=bank_id,
-            name=name,
-            content=content,
-            tags=tags,
-        )
-
-    def list(self, bank_id: str, tags: list[str] | None = None) -> Any:
-        """List all directives for a bank.
-        
-        Args:
-            bank_id: The ID of the bank.
-            tags: Optional filter by tags.
-            
-        Returns:
-            List of directives.
-        """
-        return self._client.list_directives(bank_id=bank_id, tags=tags)
-
-    def get(self, bank_id: str, directive_id: str) -> Any:
-        """Get a specific directive.
-        
-        Args:
-            bank_id: The ID of the bank.
-            directive_id: The ID of the directive.
-            
-        Returns:
-            The directive details.
-        """
-        return self._client.get_directive(bank_id=bank_id, directive_id=directive_id)
-
-    def update(
-        self,
-        bank_id: str,
-        directive_id: str,
-        name: str | None = None,
-        content: str | None = None,
-        tags: list[str] | None = None,
-    ) -> Any:
-        """Update a directive.
-        
-        Args:
-            bank_id: The ID of the bank.
-            directive_id: The ID of the directive to update.
-            name: Optional new name.
-            content: Optional new content.
-            tags: Optional new tags list.
-            
-        Returns:
-            Update response from the API.
-        """
-        return self._client.update_directive(
-            bank_id=bank_id,
-            directive_id=directive_id,
-            name=name,
-            content=content,
-            tags=tags,
-        )
-
-    def delete(self, bank_id: str, directive_id: str) -> Any:
-        """Delete a directive.
-        
-        Args:
-            bank_id: The ID of the bank.
-            directive_id: The ID of the directive to delete.
-            
-        Returns:
-            Deletion response from the API.
-        """
-        return self._client.delete_directive(bank_id=bank_id, directive_id=directive_id)
-
-
-class MemoriesAPI:
-    """Namespace for memory operations.
-    
-    Provides methods to query and retrieve stored memories.
-    """
-
-    def __init__(self, client: Hindsight):
-        self._client = client
-
-    def list(
-        self,
-        bank_id: str,
-        type: str | None = None,
-        search_query: str | None = None,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> Any:
-        """List memories in a bank.
-        
-        Args:
-            bank_id: The ID of the bank to query.
-            type: Optional filter by memory type.
-            search_query: Optional search query for filtering.
-            limit: Maximum number of results to return (default: 100).
-            offset: Number of results to skip for pagination (default: 0).
-            
-        Returns:
-            List of memories matching the criteria.
-        """
-        return self._client.list_memories(
-            bank_id=bank_id,
-            type=type,
-            search_query=search_query,
-            limit=limit,
-            offset=offset,
-        )
-
-
-class HindsightClient(Hindsight):
-    """
-    Enhanced Hindsight client with organized API namespaces.
-
-    This wrapper extends the auto-generated Hindsight client with organized
-    access to different parts of the API through namespaces.
-
-    Example:
-        ```python
-        from hindsight import HindsightClient
-
-        client = HindsightClient(base_url="http://localhost:8888")
-
-        # Core operations (inherited from Hindsight)
-        client.retain(bank_id="test", content="Hello")
-        results = client.recall(bank_id="test", query="Hello")
-
-        # Organized API access through namespaces
-        client.banks.create(bank_id="test", name="Test Bank")
-        models = client.mental_models.list(bank_id="test")
-        directives = client.directives.list(bank_id="test")
-        memories = client.memories.list(bank_id="test")
-        ```
-        
-    Attributes:
-        banks: Namespace for bank management operations.
-        mental_models: Namespace for mental model operations.
-        directives: Namespace for directive operations.
-        memories: Namespace for memory listing operations.
-    """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self._banks_namespace: BanksAPI | None = None
-        self._mental_models_namespace: MentalModelsAPI | None = None
-        self._directives_namespace: DirectivesAPI | None = None
-        self._memories_namespace: MemoriesAPI | None = None
-
-    @property
-    def banks(self) -> BanksAPI:
-        """Access bank management operations.
-        
-        Returns:
-            BanksAPI instance for bank operations.
-        """
-        if self._banks_namespace is None:
-            self._banks_namespace = BanksAPI(self)
-        return self._banks_namespace
-
-    @property
-    def mental_models(self) -> MentalModelsAPI:
-        """Access mental model operations.
-        
-        Returns:
-            MentalModelsAPI instance for mental model operations.
-        """
-        if self._mental_models_namespace is None:
-            self._mental_models_namespace = MentalModelsAPI(self)
-        return self._mental_models_namespace
-
-    @property
-    def directives(self) -> DirectivesAPI:
-        """Access directive operations.
-        
-        Returns:
-            DirectivesAPI instance for directive operations.
-        """
-        if self._directives_namespace is None:
-            self._directives_namespace = DirectivesAPI(self)
-        return self._directives_namespace
-
-    @property
-    def memories(self) -> MemoriesAPI:
-        """Access memory listing operations.
-        
-        Returns:
-            MemoriesAPI instance for memory operations.
-        """
-        if self._memories_namespace is None:
-            self._memories_namespace = MemoriesAPI(self)
-        return self._memories_namespace
@@ -1,137 +0,0 @@
-# Hindsight API
-
-**Memory System for AI Agents** — Temporal + Semantic + Entity Memory Architecture using PostgreSQL with pgvector.
-
-Hindsight gives AI agents persistent memory that works like human memory: it stores facts, tracks entities and relationships, handles temporal reasoning ("what happened last spring?"), and forms opinions based on configurable disposition traits.
-
-## Installation
-
-```bash
-pip install hindsight-api
-```
-
-## Quick Start
-
-### Run the Server
-
-```bash
-# Set your LLM provider
-export HINDSIGHT_API_LLM_PROVIDER=openai
-export HINDSIGHT_API_LLM_API_KEY=sk-xxxxxxxxxxxx
-
-# Start the server (uses embedded PostgreSQL by default)
-hindsight-api
-```
-
-The server starts at http://localhost:8888 with:
- REST API for memory operations
- MCP server at `/mcp` for tool-use integration
-
-### Use the Python API
-
-```python
-from hindsight_api import MemoryEngine
-
-# Create and initialize the memory engine
-memory = MemoryEngine()
-await memory.initialize()
-
-# Create a memory bank for your agent
-bank = await memory.create_memory_bank(
-    name="my-assistant",
-    background="A helpful coding assistant"
-)
-
-# Store a memory
-await memory.retain(
-    memory_bank_id=bank.id,
-    content="The user prefers Python for data science projects"
-)
-
-# Recall memories
-results = await memory.recall(
-    memory_bank_id=bank.id,
-    query="What programming language does the user prefer?"
-)
-
-# Reflect with reasoning
-response = await memory.reflect(
-    memory_bank_id=bank.id,
-    query="Should I recommend Python or R for this ML project?"
-)
-```
-
-## CLI Options
-
-```bash
-hindsight-api --help
-
-# Common options
-hindsight-api --port 9000          # Custom port (default: 8888)
-hindsight-api --host 127.0.0.1     # Bind to localhost only
-hindsight-api --workers 4          # Multiple worker processes
-hindsight-api --log-level debug    # Verbose logging
-```
-
-## Configuration
-
-Configure via environment variables:
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `HINDSIGHT_API_DATABASE_URL` | PostgreSQL connection string | `pg0` (embedded) |
-| `HINDSIGHT_API_LLM_PROVIDER` | `openai`, `anthropic`, `gemini`, `groq`, `ollama`, `lmstudio` | `openai` |
-| `HINDSIGHT_API_LLM_API_KEY` | API key for LLM provider | - |
-| `HINDSIGHT_API_LLM_MODEL` | Model name | `gpt-4o-mini` |
-| `HINDSIGHT_API_HOST` | Server bind address | `0.0.0.0` |
-| `HINDSIGHT_API_PORT` | Server port | `8888` |
-
-### Example with External PostgreSQL
-
-```bash
-export HINDSIGHT_API_DATABASE_URL=postgresql://user:pass@localhost:5432/hindsight
-export HINDSIGHT_API_LLM_PROVIDER=groq
-export HINDSIGHT_API_LLM_API_KEY=gsk_xxxxxxxxxxxx
-
-hindsight-api
-```
-
-## Docker
-
-```bash
-docker run --rm -it -p 8888:8888 \
-  -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \
-  -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \
-  ghcr.io/vectorize-io/hindsight:latest
-```
-
-## MCP Server
-
-For local MCP integration without running the full API server:
-
-```bash
-hindsight-local-mcp
-```
-
-This runs a stdio-based MCP server that can be used directly with MCP-compatible clients.
-
-## Key Features
-
- **Multi-Strategy Retrieval (TEMPR)** — Semantic, keyword, graph, and temporal search combined with RRF fusion
- **Entity Graph** — Automatic entity extraction and relationship tracking
- **Temporal Reasoning** — Native support for time-based queries
- **Disposition Traits** — Configurable skepticism, literalism, and empathy influence opinion formation
- **Three Memory Types** — World facts, bank actions, and formed opinions with confidence scores
-
-## Documentation
-
-Full documentation: [https://hindsight.vectorize.io](https://hindsight.vectorize.io)
-
- [Installation Guide](https://hindsight.vectorize.io/developer/installation)
- [Configuration Reference](https://hindsight.vectorize.io/developer/configuration)
- [API Reference](https://hindsight.vectorize.io/api-reference)
- [Python SDK](https://hindsight.vectorize.io/sdks/python)
-
-## License
-
-Apache 2.0
@@ -1,52 +0,0 @@
-"""Add consolidation_failed_at column to memory_units for tracking persistent LLM failures.
-
-When all LLM retries are exhausted on a single-memory batch, the memory is marked
-with consolidation_failed_at instead of consolidated_at, so it is not silently lost
-and can be retried later via the API.
-
-Revision ID: a3b4c5d6e7f8
-Revises: g7h8i9j0k1l2
-Create Date: 2026-03-17
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "a3b4c5d6e7f8"
-down_revision: str | Sequence[str] | None = "g7h8i9j0k1l2"
-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:
-    schema = _get_schema_prefix()
-
-    op.execute(
-        f"""
-        ALTER TABLE {schema}memory_units
-        ADD COLUMN IF NOT EXISTS consolidation_failed_at TIMESTAMPTZ DEFAULT NULL
-        """
-    )
-
-    # Index to efficiently query memories that failed consolidation for a given bank
-    op.execute(
-        f"""
-        CREATE INDEX IF NOT EXISTS idx_memory_units_consolidation_failed
-        ON {schema}memory_units (bank_id, consolidation_failed_at)
-        WHERE consolidation_failed_at IS NOT NULL AND fact_type IN ('experience', 'world')
-        """
-    )
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_memory_units_consolidation_failed")
-    op.execute(f"ALTER TABLE {schema}memory_units DROP COLUMN IF EXISTS consolidation_failed_at")
@@ -1,53 +0,0 @@
-"""Recreate idx_memory_units_source_memory_ids GIN index with fastupdate=off
-
-GIN indexes use a "fastupdate" pending list by default: small writes are
-buffered there and flushed to the main GIN tree in bulk. Flushing requires
-AccessExclusiveLock on the index. Under high insert concurrency (e.g. 8
-parallel pytest-xdist workers all calling retain_async) two transactions can
-each trigger a flush simultaneously and deadlock.
-
-Disabling fastupdate makes every insert write directly to the GIN tree
-(slightly slower per insert, but no pending-list lock cycles).
-
-Revision ID: d4e5f6g7h8i9
-Revises: d5e6f7a8b9c0
-Create Date: 2026-03-11
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "d4e5f6g7h8i9"
-down_revision: str | Sequence[str] | None = "d5e6f7a8b9c0"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def _get_schema_prefix() -> str:
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    schema = _get_schema_prefix()
-    # DROP + CREATE CONCURRENTLY must run outside a transaction block.
-    op.execute("COMMIT")
-    op.execute(f"DROP INDEX CONCURRENTLY IF EXISTS {schema}idx_memory_units_source_memory_ids")
-    op.execute(
-        f"CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_memory_units_source_memory_ids "
-        f"ON {schema}memory_units USING GIN (source_memory_ids) "
-        f"WITH (fastupdate=off) "
-        f"WHERE source_memory_ids IS NOT NULL"
-    )
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-    op.execute("COMMIT")
-    op.execute(f"DROP INDEX CONCURRENTLY IF EXISTS {schema}idx_memory_units_source_memory_ids")
-    op.execute(
-        f"CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_memory_units_source_memory_ids "
-        f"ON {schema}memory_units USING GIN (source_memory_ids) "
-        f"WHERE source_memory_ids IS NOT NULL"
-    )
@@ -1,131 +0,0 @@
-"""Add internal_id to banks and per-(bank, fact_type) partial HNSW indexes
-
-Revision ID: d5e6f7a8b9c0
-Revises: a3b4c5d6e7f8
-Create Date: 2026-03-11
-
-This migration:
-1. Adds internal_id UUID column to banks (stable identifier for index naming)
-2. Drops the global HNSW index (competes with per-bank partial indexes)
-3. Creates per-(bank_id, fact_type) partial HNSW indexes for all existing banks
-   (new banks get indexes created at bank-creation time via bank_utils.create_bank_hnsw_indexes)
-
-Why per-(bank, fact_type) indexes:
- fact_type-only partial indexes are never chosen by the planner when bank_id is in the WHERE
-  clause, because the idx_memory_units_bank_id B-tree index always wins at planning time.
- Per-(bank, fact_type) partial indexes have both predicates matching → planner selects them.
- The global HNSW index competes for larger partitions (world, observation) and must be dropped.
-
-For large deployments, create indexes CONCURRENTLY before running this migration:
-    SELECT internal_id, bank_id FROM banks;
-    -- for each bank and each fact_type in (world, experience, observation):
-    CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_mu_emb_{ft}_{uid16}
-        ON memory_units USING hnsw (embedding vector_cosine_ops)
-        WHERE fact_type = '{ft}' AND bank_id = '{bank_id}';
-    DROP INDEX CONCURRENTLY IF EXISTS idx_memory_units_embedding;
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-from sqlalchemy import text
-
-revision: str = "d5e6f7a8b9c0"
-down_revision: str | Sequence[str] | None = "c3d4e5f6g7h8"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-_HNSW_FACT_TYPES: dict[str, str] = {
-    "world": "worl",
-    "experience": "expr",
-    "observation": "obsv",
-}
-
-
-def _get_schema_prefix() -> str:
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    schema = _get_schema_prefix()
-
-    # 1. Add internal_id column to banks
-    op.execute(
-        f"ALTER TABLE {schema}banks ADD COLUMN IF NOT EXISTS internal_id UUID DEFAULT gen_random_uuid() NOT NULL"
-    )
-    op.execute(f"ALTER TABLE {schema}banks ADD CONSTRAINT banks_internal_id_unique UNIQUE (internal_id)")
-
-    # 2. Drop any fact_type-only partial HNSW indexes that may exist from prior migrations
-    #    (bank_id B-tree always wins over them when bank_id is in the WHERE clause)
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_mu_emb_world")
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_mu_emb_observation")
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_mu_emb_experience")
-
-    # 4. Drop global HNSW index (competes with per-bank partial indexes)
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_memory_units_embedding")
-
-    # 5. Create per-(bank, fact_type) partial HNSW indexes for all existing banks
-    bind = op.get_bind()
-    schema_name = context.config.get_main_option("target_schema")
-    table_ref = f'"{schema_name}".memory_units' if schema_name else "memory_units"
-    banks_ref = f'"{schema_name}".banks' if schema_name else "banks"
-
-    rows = bind.execute(text(f"SELECT bank_id, internal_id FROM {banks_ref}")).fetchall()  # noqa: S608
-    for row in rows:
-        bank_id = row[0]
-        internal_id = str(row[1]).replace("-", "")[:16]
-        escaped_bank_id = bank_id.replace("'", "''")
-        for ft, ft_short in _HNSW_FACT_TYPES.items():
-            idx_name = f"idx_mu_emb_{ft_short}_{internal_id}"
-            # Index name is schema-unqualified (indexes live in the schema of their table)
-            bind.execute(
-                text(
-                    f"CREATE INDEX IF NOT EXISTS {idx_name} "
-                    f"ON {table_ref} USING hnsw (embedding vector_cosine_ops) "
-                    f"WHERE fact_type = '{ft}' AND bank_id = '{escaped_bank_id}'"
-                )
-            )
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-
-    # Drop per-bank HNSW indexes (iterate existing banks)
-    bind = op.get_bind()
-    schema_name = context.config.get_main_option("target_schema")
-    banks_ref = f'"{schema_name}".banks' if schema_name else "banks"
-
-    rows = bind.execute(text(f"SELECT internal_id FROM {banks_ref}")).fetchall()  # noqa: S608
-    for row in rows:
-        internal_id = str(row[0]).replace("-", "")[:16]
-        for ft_short in _HNSW_FACT_TYPES.values():
-            idx_name = f"idx_mu_emb_{ft_short}_{internal_id}"
-            bind.execute(text(f"DROP INDEX IF EXISTS {schema}{idx_name}"))
-
-    # Restore the global HNSW index
-    table_ref = f'"{schema_name}".memory_units' if schema_name else "memory_units"
-    op.execute(
-        f"CREATE INDEX IF NOT EXISTS idx_memory_units_embedding ON {table_ref} USING hnsw (embedding vector_cosine_ops)"
-    )
-
-    # Restore old fact_type-only partial indexes
-    op.execute(
-        f"CREATE INDEX IF NOT EXISTS idx_mu_emb_world "
-        f"ON {table_ref} USING hnsw (embedding vector_cosine_ops) "
-        f"WHERE fact_type = 'world'"
-    )
-    op.execute(
-        f"CREATE INDEX IF NOT EXISTS idx_mu_emb_observation "
-        f"ON {table_ref} USING hnsw (embedding vector_cosine_ops) "
-        f"WHERE fact_type = 'observation'"
-    )
-    op.execute(
-        f"CREATE INDEX IF NOT EXISTS idx_mu_emb_experience "
-        f"ON {table_ref} USING hnsw (embedding vector_cosine_ops) "
-        f"WHERE fact_type = 'experience'"
-    )
-
-    # Drop internal_id column
-    op.execute(f"ALTER TABLE {schema}banks DROP CONSTRAINT IF EXISTS banks_internal_id_unique")
-    op.execute(f"ALTER TABLE {schema}banks DROP COLUMN IF EXISTS internal_id")
@@ -1,73 +0,0 @@
-"""Add CASCADE DELETE FK from async_operations and webhooks to banks.
-
-When a bank is deleted, all its async_operations and webhooks rows are
-automatically deleted by the database. This ensures that any in-flight
-worker tasks detect the deletion via _check_op_alive() and abort early.
-
-Revision ID: e5f6g7h8i9j0
-Revises: d4e5f6g7h8i9
-Create Date: 2026-03-11
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "e5f6g7h8i9j0"
-down_revision: str | Sequence[str] | None = "d4e5f6g7h8i9"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def _get_schema_prefix() -> str:
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    schema = _get_schema_prefix()
-
-    # Remove orphaned async_operations rows whose bank no longer exists
-    # (can happen because there was no FK before this migration).
-    op.execute(
-        f"""
-        DELETE FROM {schema}async_operations
-        WHERE bank_id IS NOT NULL
-          AND bank_id NOT IN (SELECT bank_id FROM {schema}banks)
-        """
-    )
-
-    # Remove orphaned webhooks rows whose bank no longer exists.
-    op.execute(
-        f"""
-        DELETE FROM {schema}webhooks
-        WHERE bank_id IS NOT NULL
-          AND bank_id NOT IN (SELECT bank_id FROM {schema}banks)
-        """
-    )
-
-    # Add FK with ON DELETE CASCADE so that deleting a bank automatically
-    # cleans up all its pending/processing operations and webhook configs.
-    op.execute(
-        f"""
-        ALTER TABLE {schema}async_operations
-            ADD CONSTRAINT fk_async_operations_bank_id
-            FOREIGN KEY (bank_id) REFERENCES {schema}banks(bank_id)
-            ON DELETE CASCADE
-        """
-    )
-
-    op.execute(
-        f"""
-        ALTER TABLE {schema}webhooks
-            ADD CONSTRAINT fk_webhooks_bank_id
-            FOREIGN KEY (bank_id) REFERENCES {schema}banks(bank_id)
-            ON DELETE CASCADE
-        """
-    )
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-    op.execute(f"ALTER TABLE {schema}async_operations DROP CONSTRAINT IF EXISTS fk_async_operations_bank_id")
-    op.execute(f"ALTER TABLE {schema}webhooks DROP CONSTRAINT IF EXISTS fk_webhooks_bank_id")
@@ -1,38 +0,0 @@
-"""chunk_fk_cascade_delete
-
-Revision ID: f6g7h8i9j0k1
-Revises: e5f6g7h8i9j0
-Create Date: 2026-03-16 00:00:00.000000
-
-"""
-
-from collections.abc import Sequence
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "f6g7h8i9j0k1"
-down_revision: str | Sequence[str] | None = "e5f6g7h8i9j0"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def upgrade() -> None:
-    """Change memory_units.chunk_id FK from SET NULL to CASCADE.
-
-    When a document is deleted the CASCADE reaches chunks first; with SET NULL
-    the memory_units rows survived with chunk_id = NULL, leaving ghost records.
-    Switching to CASCADE ensures they are removed together with their chunk.
-    """
-    op.drop_constraint("memory_units_chunk_fkey", "memory_units", type_="foreignkey")
-    op.create_foreign_key(
-        "memory_units_chunk_fkey", "memory_units", "chunks", ["chunk_id"], ["chunk_id"], ondelete="CASCADE"
-    )
-
-
-def downgrade() -> None:
-    """Revert to SET NULL behaviour."""
-    op.drop_constraint("memory_units_chunk_fkey", "memory_units", type_="foreignkey")
-    op.create_foreign_key(
-        "memory_units_chunk_fkey", "memory_units", "chunks", ["chunk_id"], ["chunk_id"], ondelete="SET NULL"
-    )
@@ -1,71 +0,0 @@
-"""backsweep_orphan_memory_units
-
-Two-pass cleanup of memory_units rows that were never removed by earlier bugs:
-
-Pass 1 — any fact_type, bank gone:
-  memory_units whose bank_id no longer exists in banks.  These accumulate when
-  a bank is deleted without a proper cascade (no FK from memory_units to banks
-  exists in the schema).
-
-Pass 2 — observations only, all sources gone:
-  observation rows whose bank still exists but every source_memory_id points
-  to a deleted memory unit.  These were left behind before PR #580 fixed the
-  chunk FK cascade and before delete_document() called
-  _delete_stale_observations_for_memories.
-
-Revision ID: g7h8i9j0k1l2
-Revises: f6g7h8i9j0k1
-Create Date: 2026-03-16
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "g7h8i9j0k1l2"
-down_revision: str | Sequence[str] | None = "f6g7h8i9j0k1"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def _get_schema_prefix() -> str:
-    schema = context.config.get_main_option("target_schema")
-    return f'"{schema}".' if schema else ""
-
-
-def upgrade() -> None:
-    schema = _get_schema_prefix()
-    mu = f"{schema}memory_units"
-    banks = f"{schema}banks"
-
-    # Pass 1: delete all memory_units (any fact_type) whose bank no longer exists.
-    # There is no FK from memory_units to banks, so these never cascade away.
-    op.execute(
-        f"""
-        DELETE FROM {mu}
-        WHERE NOT EXISTS (
-            SELECT 1 FROM {banks} b WHERE b.bank_id = {mu}.bank_id
-        )
-        """
-    )
-
-    # Pass 2: delete orphaned observations whose bank still exists but every
-    # source_memory_id refers to a now-deleted memory unit (or the array is
-    # empty).  Observations with at least one surviving source are left alone.
-    op.execute(
-        f"""
-        DELETE FROM {mu} orphan
-        WHERE orphan.fact_type = 'observation'
-          AND NOT EXISTS (
-              SELECT 1
-              FROM {mu} src
-              WHERE src.id = ANY(orphan.source_memory_ids)
-                AND src.bank_id = orphan.bank_id
-          )
-        """
-    )
-
-
-def downgrade() -> None:
-    # Deleted rows cannot be restored.
-    pass
@@ -1,144 +0,0 @@
-"""
-MLX implementation of jina-reranker-v3 for Apple Silicon.
-
-This file is adapted from the official model repository:
-  https://huggingface.co/jinaai/jina-reranker-v3-mlx/blob/main/rerank.py
-
-License: CC BY-NC 4.0 (contact Jina AI for commercial usage)
-
-Changes from upstream:
- Removed the __main__ example block
- Type annotations added to public methods
- top_n parameter added to rerank() (upstream only exposed it implicitly)
-"""
-
-import numpy as np
-
-
-class _MLPProjector:
-    def __init__(self):
-        import mlx.nn as nn
-
-        self.linear1 = nn.Linear(1024, 512, bias=False)
-        self.linear2 = nn.Linear(512, 512, bias=False)
-
-    def __call__(self, x):
-        import mlx.nn as nn
-
-        x = self.linear1(x)
-        x = nn.relu(x)
-        x = self.linear2(x)
-        return x
-
-
-def _load_projector(projector_path: str) -> _MLPProjector:
-    import mlx.core as mx
-    from safetensors import safe_open
-
-    projector = _MLPProjector()
-    with safe_open(projector_path, framework="numpy") as f:
-        projector.linear1.weight = mx.array(f.get_tensor("linear1.weight"))
-        projector.linear2.weight = mx.array(f.get_tensor("linear2.weight"))
-    return projector
-
-
-def _sanitize(text: str, special_tokens: dict[str, str]) -> str:
-    for token in special_tokens.values():
-        text = text.replace(token, "")
-    return text
-
-
-def _format_prompt(query: str, docs: list[str], special_tokens: dict[str, str]) -> str:
-    query = _sanitize(query, special_tokens)
-    docs = [_sanitize(d, special_tokens) for d in docs]
-
-    doc_token = special_tokens["doc_embed_token"]
-    query_token = special_tokens["query_embed_token"]
-
-    prefix = (
-        "<|im_start|>system\n"
-        "You are a search relevance expert who can determine a ranking of the passages based on how relevant they are to the query. "
-        "If the query is a question, how relevant a passage is depends on how well it answers the question. "
-        "If not, try to analyze the intent of the query and assess how well each passage satisfies the intent. "
-        "If an instruction is provided, you should follow the instruction when determining the ranking."
-        "<|im_end|>\n<|im_start|>user\n"
-    )
-    suffix = "<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
-
-    body = (
-        f"I will provide you with {len(docs)} passages, each indicated by a numerical identifier. "
-        f"Rank the passages based on their relevance to query: {query}\n"
-    )
-    body += "\n".join(f'<passage id="{i}">\n{doc}{doc_token}\n</passage>' for i, doc in enumerate(docs))
-    body += f"\n<query>\n{query}{query_token}\n</query>"
-    return prefix + body + suffix
-
-
-class MLXReranker:
-    """
-    MLX-accelerated jina-reranker-v3 for Apple Silicon.
-
-    Loads the model from a local directory (use huggingface_hub.snapshot_download
-    to fetch jinaai/jina-reranker-v3-mlx if you don't have it already).
-    """
-
-    _SPECIAL_TOKENS = {
-        "query_embed_token": "<|rerank_token|>",
-        "doc_embed_token": "<|embed_token|>",
-    }
-    _DOC_TOKEN_ID = 151670
-    _QUERY_TOKEN_ID = 151671
-
-    def __init__(self, model_path: str, projector_path: str):
-        from mlx_lm import load
-
-        self.model, self.tokenizer = load(model_path)
-        self.model.eval()
-        self.projector = _load_projector(projector_path)
-
-    def rerank(self, query: str, documents: list[str], top_n: int | None = None) -> list[dict]:
-        """
-        Rank documents by relevance to a query.
-
-        Returns a list of dicts with keys: document, relevance_score, index.
-        Sorted by descending relevance_score.
-        """
-        import mlx.core as mx
-
-        prompt = _format_prompt(query, documents, self._SPECIAL_TOKENS)
-        input_ids = self.tokenizer.encode(prompt)
-        hidden_states = self.model.model([input_ids])[0]  # [seq_len, hidden_size]
-
-        input_ids_np = np.array(input_ids)
-        query_positions = np.where(input_ids_np == self._QUERY_TOKEN_ID)[0]
-        doc_positions = np.where(input_ids_np == self._DOC_TOKEN_ID)[0]
-
-        if len(query_positions) == 0:
-            raise ValueError("Query embed token not found in prompt")
-        if len(doc_positions) == 0:
-            raise ValueError("Document embed tokens not found in prompt")
-
-        query_hidden = mx.expand_dims(hidden_states[int(query_positions[0])], axis=0)
-        doc_hidden = mx.stack([hidden_states[int(p)] for p in doc_positions])
-
-        query_emb = self.projector(query_hidden)  # [1, 512]
-        doc_emb = self.projector(doc_hidden)  # [num_docs, 512]
-
-        query_exp = mx.broadcast_to(mx.expand_dims(query_emb, 0), (1, len(documents), 512))
-        doc_exp = mx.expand_dims(doc_emb, 0)
-
-        scores = mx.sum(doc_exp * query_exp, axis=-1) / (
-            mx.sqrt(mx.sum(doc_exp * doc_exp, axis=-1)) * mx.sqrt(mx.sum(query_exp * query_exp, axis=-1))
-        )  # [1, num_docs]
-        scores_np = np.array(scores[0])
-
-        order = np.argsort(scores_np)[::-1]
-        n = min(top_n, len(documents)) if top_n is not None else len(documents)
-        return [
-            {
-                "document": documents[order[i]],
-                "relevance_score": float(scores_np[order[i]]),
-                "index": int(order[i]),
-            }
-            for i in range(n)
-        ]
@@ -1,390 +0,0 @@
-"""
-Tags filtering utilities for retrieval.
-
-Provides SQL building functions for filtering memories by tags.
-Supports four matching modes via TagsMatch enum:
- "any": OR matching, includes untagged memories (default, backward compatible)
- "all": AND matching, includes untagged memories
- "any_strict": OR matching, excludes untagged memories
- "all_strict": AND matching, excludes untagged memories
-
-OR matching (any/any_strict): Memory matches if ANY of its tags overlap with request tags
-AND matching (all/all_strict): Memory matches if ALL request tags are present in its tags
-"""
-
-from __future__ import annotations
-
-from typing import Annotated, Literal
-
-from pydantic import BaseModel, ConfigDict, Field
-
-TagsMatch = Literal["any", "all", "any_strict", "all_strict"]
-
-
-def _parse_tags_match(match: TagsMatch) -> tuple[str, bool]:
-    """
-    Parse TagsMatch into operator and include_untagged flag.
-
-    Returns:
-        Tuple of (operator, include_untagged)
-        - operator: "&&" for any/any_strict, "@>" for all/all_strict
-        - include_untagged: True for any/all, False for any_strict/all_strict
-    """
-    if match == "any":
-        return "&&", True
-    elif match == "all":
-        return "@>", True
-    elif match == "any_strict":
-        return "&&", False
-    elif match == "all_strict":
-        return "@>", False
-    else:
-        # Default to "any" behavior
-        return "&&", True
-
-
-def build_tags_where_clause(
-    tags: list[str] | None,
-    param_offset: int = 1,
-    table_alias: str = "",
-    match: TagsMatch = "any",
-) -> tuple[str, list, int]:
-    """
-    Build a SQL WHERE clause for filtering by tags.
-
-    Supports four matching modes:
-    - "any" (default): OR matching, includes untagged memories
-    - "all": AND matching, includes untagged memories
-    - "any_strict": OR matching, excludes untagged memories
-    - "all_strict": AND matching, excludes untagged memories
-
-    Args:
-        tags: List of tags to filter by. If None or empty, returns empty clause (no filtering).
-        param_offset: Starting parameter number for SQL placeholders (default 1).
-        table_alias: Optional table alias prefix (e.g., "mu." for "memory_units mu").
-        match: Matching mode. Defaults to "any".
-
-    Returns:
-        Tuple of (sql_clause, params, next_param_offset):
-        - sql_clause: SQL WHERE clause string
-        - params: List of parameter values to bind
-        - next_param_offset: Next available parameter number
-
-    Example:
-        >>> clause, params, next_offset = build_tags_where_clause(['user_a'], 3, 'mu.', 'any_strict')
-        >>> print(clause)  # "AND mu.tags IS NOT NULL AND mu.tags != '{}' AND mu.tags && $3"
-    """
-    if not tags:
-        return "", [], param_offset
-
-    column = f"{table_alias}tags" if table_alias else "tags"
-    operator, include_untagged = _parse_tags_match(match)
-
-    if include_untagged:
-        # Include untagged memories (NULL or empty array) OR matching tags
-        clause = f"AND ({column} IS NULL OR {column} = '{{}}' OR {column} {operator} ${param_offset})"
-    else:
-        # Strict: only memories with matching tags (exclude NULL and empty)
-        clause = f"AND {column} IS NOT NULL AND {column} != '{{}}' AND {column} {operator} ${param_offset}"
-
-    return clause, [tags], param_offset + 1
-
-
-def build_tags_where_clause_simple(
-    tags: list[str] | None,
-    param_num: int,
-    table_alias: str = "",
-    match: TagsMatch = "any",
-) -> str:
-    """
-    Build a simple SQL WHERE clause for tags filtering.
-
-    This is a convenience version that returns just the clause string,
-    assuming the caller will add the tags array to their params list.
-
-    Args:
-        tags: List of tags to filter by. If None or empty, returns empty string.
-        param_num: Parameter number to use in the clause.
-        table_alias: Optional table alias prefix.
-        match: Matching mode. Defaults to "any".
-
-    Returns:
-        SQL clause string or empty string.
-    """
-    if not tags:
-        return ""
-
-    column = f"{table_alias}tags" if table_alias else "tags"
-    operator, include_untagged = _parse_tags_match(match)
-
-    if include_untagged:
-        # Include untagged memories (NULL or empty array) OR matching tags
-        return f"AND ({column} IS NULL OR {column} = '{{}}' OR {column} {operator} ${param_num})"
-    else:
-        # Strict: only memories with matching tags (exclude NULL and empty)
-        return f"AND {column} IS NOT NULL AND {column} != '{{}}' AND {column} {operator} ${param_num}"
-
-
-def filter_results_by_tags(
-    results: list,
-    tags: list[str] | None,
-    match: TagsMatch = "any",
-) -> list:
-    """
-    Filter retrieval results by tags in Python (for post-processing).
-
-    Used when SQL filtering isn't possible (e.g., graph traversal results).
-
-    Args:
-        results: List of RetrievalResult objects with a 'tags' attribute.
-        tags: List of tags to filter by. If None or empty, returns all results.
-        match: Matching mode. Defaults to "any".
-
-    Returns:
-        Filtered list of results.
-    """
-    if not tags:
-        return results
-
-    _, include_untagged = _parse_tags_match(match)
-    is_any_match = match in ("any", "any_strict")
-
-    tags_set = set(tags)
-    filtered = []
-
-    for result in results:
-        result_tags = getattr(result, "tags", None)
-
-        # Check if untagged
-        is_untagged = result_tags is None or len(result_tags) == 0
-
-        if is_untagged:
-            if include_untagged:
-                filtered.append(result)
-            # else: skip untagged
-        else:
-            result_tags_set = set(result_tags)
-            if is_any_match:
-                # Any overlap
-                if result_tags_set & tags_set:
-                    filtered.append(result)
-            else:
-                # All tags must be present
-                if tags_set <= result_tags_set:
-                    filtered.append(result)
-
-    return filtered
-
-
-# =============================================================================
-# Compound tag group models (recursive boolean expressions)
-# =============================================================================
-
-
-class TagGroupLeaf(BaseModel):
-    """A leaf tag filter: matches memories by tag list and match mode."""
-
-    tags: list[str]
-    match: TagsMatch = "any_strict"
-
-
-class TagGroupAnd(BaseModel):
-    """Compound AND group: all child filters must match."""
-
-    model_config = ConfigDict(populate_by_name=True)
-    filters: list[TagGroup] = Field(alias="and")
-
-
-class TagGroupOr(BaseModel):
-    """Compound OR group: at least one child filter must match."""
-
-    model_config = ConfigDict(populate_by_name=True)
-    filters: list[TagGroup] = Field(alias="or")
-
-
-class TagGroupNot(BaseModel):
-    """Compound NOT group: child filter must NOT match."""
-
-    model_config = ConfigDict(populate_by_name=True)
-    filter: TagGroup = Field(alias="not")
-
-
-# TagGroup is a discriminated union; Pydantic will try left-to-right.
-# TagGroupLeaf is identified by the presence of 'tags'.
-# TagGroupAnd / TagGroupOr / TagGroupNot are compound (no 'tags' key).
-TagGroup = Annotated[
-    TagGroupLeaf | TagGroupAnd | TagGroupOr | TagGroupNot,
-    Field(union_mode="left_to_right"),
-]
-
-# Rebuild forward-reference models so recursive TagGroup is resolved.
-TagGroupAnd.model_rebuild()
-TagGroupOr.model_rebuild()
-TagGroupNot.model_rebuild()
-
-
-# =============================================================================
-# SQL builder for compound tag groups
-# =============================================================================
-
-
-def _build_group_clause(
-    group: TagGroup,
-    param_offset: int,
-    table_alias: str,
-) -> tuple[str, list, int]:
-    """
-    Recursively build an inner SQL clause (no leading AND/OR) for a single TagGroup.
-
-    Returns:
-        (inner_clause, params, next_param_offset)
-    """
-    if isinstance(group, TagGroupLeaf):
-        column = f"{table_alias}tags" if table_alias else "tags"
-        operator, include_untagged = _parse_tags_match(group.match)
-        if include_untagged:
-            clause = f"({column} IS NULL OR {column} = '{{}}' OR {column} {operator} ${param_offset})"
-        else:
-            clause = f"({column} IS NOT NULL AND {column} != '{{}}' AND {column} {operator} ${param_offset})"
-        return clause, [group.tags], param_offset + 1
-
-    elif isinstance(group, TagGroupAnd):
-        parts = []
-        params: list = []
-        offset = param_offset
-        for child in group.filters:
-            child_clause, child_params, offset = _build_group_clause(child, offset, table_alias)
-            parts.append(child_clause)
-            params.extend(child_params)
-        inner = " AND ".join(parts)
-        return f"({inner})", params, offset
-
-    elif isinstance(group, TagGroupOr):
-        parts = []
-        params = []
-        offset = param_offset
-        for child in group.filters:
-            child_clause, child_params, offset = _build_group_clause(child, offset, table_alias)
-            parts.append(child_clause)
-            params.extend(child_params)
-        inner = " OR ".join(parts)
-        return f"({inner})", params, offset
-
-    elif isinstance(group, TagGroupNot):
-        child_clause, child_params, next_offset = _build_group_clause(group.filter, param_offset, table_alias)
-        return f"NOT {child_clause}", child_params, next_offset
-
-    else:
-        # Should never happen with proper Pydantic validation
-        return "", [], param_offset
-
-
-def build_tag_groups_where_clause(
-    tag_groups: list[TagGroup] | None,
-    param_offset: int,
-    table_alias: str = "",
-) -> tuple[str, list, int]:
-    """
-    Build a SQL WHERE clause for compound tag group filtering.
-
-    Top-level groups are AND-ed together. Each group is a recursive boolean
-    expression (leaf, and, or, not).
-
-    Args:
-        tag_groups: List of TagGroup objects. If None or empty, returns empty clause.
-        param_offset: Starting parameter number for SQL placeholders.
-        table_alias: Optional table alias prefix (e.g., "mu." for "memory_units mu").
-
-    Returns:
-        Tuple of (sql_clause, params, next_param_offset):
-        - sql_clause: SQL WHERE clause string starting with "AND" (or empty string)
-        - params: List of parameter values to bind (one per leaf node)
-        - next_param_offset: Next available parameter number
-
-    Example:
-        >>> groups = [TagGroupLeaf(tags=["user:alice"], match="all_strict")]
-        >>> clause, params, next_offset = build_tag_groups_where_clause(groups, 3)
-        >>> print(clause)  # "AND (tags IS NOT NULL AND tags != '{}' AND tags @> $3)"
-    """
-    if not tag_groups:
-        return "", [], param_offset
-
-    all_params: list = []
-    all_clauses: list[str] = []
-    offset = param_offset
-
-    for group in tag_groups:
-        inner_clause, group_params, offset = _build_group_clause(group, offset, table_alias)
-        all_clauses.append(inner_clause)
-        all_params.extend(group_params)
-
-    combined = " AND ".join(all_clauses)
-    return f"AND {combined}", all_params, offset
-
-
-# =============================================================================
-# Python-side filter for compound tag groups (post-retrieval filtering)
-# =============================================================================
-
-
-def _match_group(result: object, group: TagGroup) -> bool:
-    """
-    Recursively evaluate a TagGroup against a retrieval result.
-
-    Args:
-        result: Any object with a 'tags' attribute (list[str] or None).
-        group: The TagGroup to evaluate.
-
-    Returns:
-        True if the result matches the group, False otherwise.
-    """
-    if isinstance(group, TagGroupLeaf):
-        result_tags = getattr(result, "tags", None)
-        is_untagged = result_tags is None or len(result_tags) == 0
-        _, include_untagged = _parse_tags_match(group.match)
-        is_any_match = group.match in ("any", "any_strict")
-        tags_set = set(group.tags)
-
-        if is_untagged:
-            return include_untagged
-        else:
-            result_tags_set = set(result_tags)
-            if is_any_match:
-                return bool(result_tags_set & tags_set)
-            else:
-                return tags_set <= result_tags_set
-
-    elif isinstance(group, TagGroupAnd):
-        return all(_match_group(result, child) for child in group.filters)
-
-    elif isinstance(group, TagGroupOr):
-        return any(_match_group(result, child) for child in group.filters)
-
-    elif isinstance(group, TagGroupNot):
-        return not _match_group(result, group.filter)
-
-    else:
-        return True
-
-
-def filter_results_by_tag_groups(
-    results: list,
-    tag_groups: list[TagGroup] | None,
-) -> list:
-    """
-    Filter retrieval results by compound tag groups in Python (for post-processing).
-
-    Used when SQL filtering isn't possible (e.g., graph traversal results).
-    Top-level groups are AND-ed together.
-
-    Args:
-        results: List of RetrievalResult objects with a 'tags' attribute.
-        tag_groups: List of TagGroup objects. If None or empty, returns all results.
-
-    Returns:
-        Filtered list of results where ALL top-level groups match.
-    """
-    if not tag_groups:
-        return results
-
-    return [r for r in results if all(_match_group(r, group) for group in tag_groups)]
@@ -1,205 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "hindsight-api-slim"
-version = "0.4.19"
-description = "Hindsight: Agent Memory That Works Like Human Memory"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = [
-    "asyncpg>=0.29.0",
-    "python-dotenv>=1.0.0",
-    "openai>=1.0.0",
-    "pydantic>=2.0.0",
-    "rich>=13.0.0",
-    "langchain-text-splitters>=0.3.0",
-    "fastapi[standard]>=0.120.3",
-    "uvicorn>=0.38.0",
-    "wsproto>=1.0.0",
-    "sqlalchemy>=2.0.44",
-    "alembic>=1.17.1",
-    "pgvector>=0.4.1",
-    "greenlet>=3.2.4",
-    "psycopg2-binary>=2.9.11",
-    "tiktoken>=0.12.0",
-    "httpx>=0.27.0",
-    "PyJWT[crypto]>=2.8.0",
-    "fastmcp>=2.14.0", # CVE-2025-66416
-    "python-dateutil>=2.8.0",
-    "opentelemetry-api>=1.20.0",
-    "opentelemetry-sdk>=1.20.0",
-    "opentelemetry-instrumentation-fastapi>=0.41b0",
-    "opentelemetry-exporter-prometheus>=0.41b0",
-    "opentelemetry-exporter-otlp-proto-http>=1.20.0",
-    "opentelemetry-semantic-conventions>=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",
-    "litellm>=1.0.0",
-    "markitdown[pdf,docx,pptx,xlsx,xls]>=0.1.4", # File to markdown conversion
-    "obstore>=0.4.0", # S3/GCS/Azure object storage client (Rust-backed)
-    "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.11", # Serialization injection + SSRF vulnerability fix
-    "langsmith>=0.6.3", # SSRF via tracing header injection fix
-    "protobuf>=6.33.5", # JSON recursion depth bypass fix
-    "pillow>=12.1.1", # Out-of-bounds write in PSD image loading fix
-    "cryptography>=46.0.5", # Subgroup attack 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; sys_platform == 'darwin'",
-]
-
-[project.optional-dependencies]
-local-ml = [
-    # Local ML models for embeddings/reranking
-    "sentence-transformers>=3.3.0",
-    "transformers>=4.53.0", # Security fixes for ReDoS vulnerabilities
-    "torch>=2.6.0", # CVE fix for remote code execution
-    "einops>=0.8.2",
-    "flashrank>=0.2.0",
-    # Apple Silicon local inference
-    "mlx>=0.31.0",
-    "mlx-lm>=0.31.1",
-    "safetensors>=0.6.2",
-]
-embedded-db = [
-    "pg0-embedded>=0.11.0",
-]
-all = [
-    "hindsight-api-slim[local-ml,embedded-db]",
-]
-test = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-    "pytest-timeout>=2.4.0",
-    "pytest-xdist>=3.0.0",
-    "filelock>=3.20.1",  # TOCTOU race condition fix
-    "testcontainers>=4.0.0",
-]
-
-[project.scripts]
-hindsight-api = "hindsight_api.main:main"
-hindsight-worker = "hindsight_api.worker.main:main"
-hindsight-local-mcp = "hindsight_api.mcp_local:main"
-hindsight-admin = "hindsight_api.admin.cli:main"
-
-[tool.hatch.build.targets.wheel]
-packages = ["hindsight_api"]
-
-[tool.hatch.build.targets.wheel.sources]
-"hindsight_api" = "hindsight_api"
-
-[tool.hatch.build.targets.sdist]
-include = [
-    "hindsight_api/**/*",
-]
-
-[tool.hatch.build]
-include = [
-    "hindsight_api/**/*.py",
-    "hindsight_api/alembic/**/*",
-]
-
-[tool.pytest.ini_options]
-log_cli = true
-log_cli_level = "INFO"
-log_cli_format = "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
-log_cli_date_format = "%Y-%m-%d %H:%M:%S"
-addopts = "--timeout 300 -n 8 --dist loadgroup --durations=10 -v"
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
-log_auto_indent = true
-filterwarnings = [
-    "ignore:The @wait_container_is_ready decorator is deprecated:DeprecationWarning",
-    "ignore::RuntimeWarning:asyncio",
-]
-
-[dependency-groups]
-dev = [
-    "pytest>=9.0.0",
-    "pytest-asyncio>=1.3.0",
-    "pytest-timeout>=2.4.0",
-    "pytest-xdist>=3.8.0",
-    "python-dotenv>=1.2.1",
-    "filelock>=3.20.1",  # TOCTOU race condition fix
-    "ruff>=0.8.0",
-    "ty>=0.0.1",
-    "testcontainers>=4.0.0",
-]
-
-[tool.ruff]
-line-length = 120
-target-version = "py311"
-exclude = [
-    "tests/",
-    "**/tests/",
-]
-
-[tool.ruff.lint]
-select = [
-    "E",      # pycodestyle errors
-    "W",      # pycodestyle warnings
-    "F",      # Pyflakes
-    "I",      # isort
-]
-ignore = [
-    "E501",   # line too long (handled by formatter)
-    "E402",   # module import not at top of file
-    "F401",   # unused import (too noisy during development)
-    "F841",   # unused variable (too noisy during development)
-    "F811",   # redefined while unused
-    "F821",   # undefined name (forward references in type hints)
-]
-
-[tool.ruff.lint.isort]
-known-third-party = ["alembic"]
-
-[tool.ruff.format]
-quote-style = "double"
-indent-style = "space"
-
-[tool.uv]
-# Use explicit index for PyTorch to prevent the pytorch index from serving
-# non-pytorch packages (e.g. markupsafe) with incompatible wheels
-[[tool.uv.index]]
-name = "pytorch-cpu"
-url = "https://download.pytorch.org/whl/cpu"
-explicit = true
-
-[tool.uv.sources]
-# Route torch to the CPU-only PyTorch index; everything else uses PyPI
-torch = { index = "pytorch-cpu" }
-
-[tool.ty]
-# Type checking configuration
-# ty is an extremely fast Python type checker from Astral (same team as ruff/uv)
-
-[tool.ty.environment]
-python-version = "3.11"
-
-[tool.ty.src]
-exclude = [
-    "tests/",
-    "hindsight_api/alembic/",
-]
-
-[tool.ty.rules]
-# Disable noisy rules while keeping important ones
-invalid-argument-type = "ignore"    # False positives with **kwargs patterns
-invalid-return-type = "ignore"      # Often intentional in async code
-invalid-parameter-default = "ignore" # Optional params with None default
-possibly-missing-attribute = "ignore" # Common with Optional types
-invalid-raise = "ignore"            # False positives with exception tracking
-call-non-callable = "ignore"        # False positives with Optional types
-invalid-key = "ignore"              # Pydantic ConfigDict not understood
-invalid-method-override = "ignore"  # Intentional signature differences
-unresolved-reference = "ignore"     # Forward references not always resolved
@@ -1,476 +0,0 @@
-"""Tests for consolidation failure handling: adaptive batch splitting, consolidation_failed_at,
-and the recovery API.
-
-These tests use a mock LLM to simulate LLM failures deterministically, without making real
-API calls. All tests insert memories directly into the database to bypass retain's LLM calls
-and focus exclusively on the consolidation code paths.
-"""
-
-import uuid
-from unittest.mock import MagicMock
-
-import pytest
-import pytest_asyncio
-
-from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
-from hindsight_api.engine.memory_engine import MemoryEngine
-from hindsight_api.engine.providers.mock_llm import MockLLM
-from hindsight_api.engine.task_backend import SyncTaskBackend
-
-
-@pytest_asyncio.fixture(scope="function")
-async def memory_no_llm_verify(pg0_db_url, embeddings, cross_encoder, query_analyzer):
-    """MemoryEngine with mock LLM.
-
-    Migrations are already applied by the session-scoped pg0_db_url fixture, so
-    run_migrations=False avoids advisory-lock serialization overhead per test.
-    """
-    mem = MemoryEngine(
-        db_url=pg0_db_url,
-        memory_llm_provider="mock",
-        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,
-    )
-    await mem.initialize()
-    yield mem
-    try:
-        if mem._pool and not mem._pool._closing:
-            await mem.close()
-    except Exception:
-        pass
-
-
-@pytest.fixture(autouse=True)
-def enable_observations():
-    """Enable observations for all tests in this module."""
-    from hindsight_api.config import _get_raw_config
-
-    config = _get_raw_config()
-    original = config.enable_observations
-    config.enable_observations = True
-    yield
-    config.enable_observations = original
-
-
-def _make_failing_mock_llm(*, fail_first_n: int = 999) -> MockLLM:
-    """Return a MockLLM that raises ValueError for the first `fail_first_n` consolidation calls."""
-    mock_llm = MockLLM(provider="mock", api_key="", base_url="", model="mock-model")
-    call_count = 0
-
-    def callback(messages, scope):
-        nonlocal call_count
-        if scope == "consolidation":
-            call_count += 1
-            if call_count <= fail_first_n:
-                raise ValueError(f"Simulated LLM failure (call {call_count})")
-        # Return empty response — no creates/updates/deletes
-        from hindsight_api.engine.consolidation.consolidator import _ConsolidationBatchResponse
-
-        return _ConsolidationBatchResponse()
-
-    mock_llm.set_response_callback(callback)
-    return mock_llm
-
-
-def _make_always_success_mock_llm() -> MockLLM:
-    """Return a MockLLM that always succeeds with an empty consolidation response."""
-    mock_llm = MockLLM(provider="mock", api_key="", base_url="", model="mock-model")
-
-    def callback(messages, scope):
-        from hindsight_api.engine.consolidation.consolidator import _ConsolidationBatchResponse
-
-        return _ConsolidationBatchResponse()
-
-    mock_llm.set_response_callback(callback)
-    return mock_llm
-
-
-def _inject_mock_llm(memory: MemoryEngine, mock_llm: MockLLM) -> None:
-    """Replace memory._consolidation_llm_config with a wrapper that returns mock_llm from with_config."""
-    wrapper = MagicMock()
-    wrapper.with_config.return_value = mock_llm
-    memory._consolidation_llm_config = wrapper
-
-
-async def _insert_memories(conn, bank_id: str, texts: list[str]) -> list[uuid.UUID]:
-    """Insert experience memories directly, bypassing LLM-based retain."""
-    ids = []
-    for text in texts:
-        mem_id = uuid.uuid4()
-        await conn.execute(
-            """
-            INSERT INTO memory_units (id, bank_id, text, fact_type, created_at)
-            VALUES ($1, $2, $3, 'experience', now())
-            """,
-            mem_id,
-            bank_id,
-            text,
-        )
-        ids.append(mem_id)
-    return ids
-
-
-class TestAdaptiveBatchSplitting:
-    """Verify that a failing batch is halved and retried until batch_size=1 succeeds."""
-
-    @pytest.mark.asyncio
-    async def test_splitting_recovers_all_memories(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """When a batch of 2 fails, both are retried individually and succeed."""
-        bank_id = f"test-split-recovery-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            mem_ids = await _insert_memories(
-                conn,
-                bank_id,
-                [
-                    "Alice runs marathons every spring.",
-                    "Alice trained for six months for her last race.",
-                ],
-            )
-
-        # Exhaust all 3 retries for batch=2 (calls 1-3 fail), then each batch=1 succeeds (calls 4-5)
-        mock_llm = _make_failing_mock_llm(fail_first_n=3)
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        assert result["status"] == "completed"
-        assert result["memories_processed"] == 2
-        assert result["memories_failed"] == 0
-
-        # Both memories must have consolidated_at set and consolidation_failed_at NULL
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            rows = await conn.fetch(
-                """
-                SELECT id, consolidated_at, consolidation_failed_at
-                FROM memory_units
-                WHERE bank_id = $1 AND fact_type = 'experience'
-                """,
-                bank_id,
-            )
-        assert len(rows) == 2
-        for row in rows:
-            assert row["consolidated_at"] is not None, f"Memory {row['id']} should have consolidated_at set"
-            assert row["consolidation_failed_at"] is None, (
-                f"Memory {row['id']} should NOT have consolidation_failed_at set"
-            )
-
-        # LLM called 5 times: 3 retries failed (batch=2) + 1 succeeded (batch=1) + 1 succeeded (batch=1)
-        consolidation_calls = [c for c in mock_llm.get_mock_calls() if c["scope"] == "consolidation"]
-        assert len(consolidation_calls) == 5
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_splitting_with_larger_batch(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """A batch of 4 that always fails at size>1 resolves to 4 individual calls."""
-        bank_id = f"test-split-large-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            await _insert_memories(
-                conn,
-                bank_id,
-                [
-                    "Bob plays chess competitively.",
-                    "Bob won a regional chess tournament.",
-                    "Bob practices tactics every morning.",
-                    "Bob coaches youth chess on weekends.",
-                ],
-            )
-
-        # Exhaust all 3 retries for batch=4 (calls 1-3 fail), then both batch=2 halves succeed
-        # (calls 4-5). This verifies that halving once is sufficient when batch=2 works.
-        mock_llm = _make_failing_mock_llm(fail_first_n=3)
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        assert result["memories_processed"] == 4
-        assert result["memories_failed"] == 0
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            rows = await conn.fetch(
-                "SELECT consolidated_at, consolidation_failed_at FROM memory_units "
-                "WHERE bank_id = $1 AND fact_type = 'experience'",
-                bank_id,
-            )
-        assert all(r["consolidated_at"] is not None for r in rows)
-        assert all(r["consolidation_failed_at"] is None for r in rows)
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-
-class TestConsolidationFailedAt:
-    """Verify that consolidation_failed_at is set — and consolidated_at is NOT — when all retries fail."""
-
-    @pytest.mark.asyncio
-    async def test_single_memory_permanent_failure(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """A single memory that exhausts all LLM retries gets consolidation_failed_at, not consolidated_at."""
-        bank_id = f"test-perm-fail-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            (mem_id,) = await _insert_memories(conn, bank_id, ["Carol enjoys painting watercolors."])
-
-        # Always fail
-        mock_llm = _make_failing_mock_llm(fail_first_n=999)
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        assert result["memories_failed"] == 1
-        assert result["memories_processed"] == 1
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            row = await conn.fetchrow(
-                "SELECT consolidated_at, consolidation_failed_at FROM memory_units WHERE id = $1",
-                mem_id,
-            )
-
-        assert row["consolidated_at"] is None, "consolidated_at must NOT be set for a permanently failed memory"
-        assert row["consolidation_failed_at"] is not None, "consolidation_failed_at must be set"
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_failed_memory_excluded_from_next_run(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """A memory marked consolidation_failed_at is not re-processed on the next consolidation run."""
-        bank_id = f"test-excluded-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            (mem_id,) = await _insert_memories(conn, bank_id, ["Dave collects vinyl records."])
-            # Manually stamp consolidation_failed_at to simulate a prior failed run
-            await conn.execute(
-                "UPDATE memory_units SET consolidation_failed_at = NOW() WHERE id = $1",
-                mem_id,
-            )
-
-        # Even with a healthy LLM, the memory should be skipped
-        mock_llm = _make_always_success_mock_llm()
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        # No unconsolidated memories to pick up (consolidation_failed_at ≠ NULL, consolidated_at = NULL
-        # but the SELECT filters on consolidated_at IS NULL AND fact_type IN ('experience','world'))
-        assert result["status"] in ("no_new_memories", "completed")
-        if result["status"] == "completed":
-            assert result["memories_processed"] == 0
-
-        # Memory still has consolidation_failed_at set and consolidated_at NULL
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            row = await conn.fetchrow(
-                "SELECT consolidated_at, consolidation_failed_at FROM memory_units WHERE id = $1",
-                mem_id,
-            )
-        assert row["consolidated_at"] is None
-        assert row["consolidation_failed_at"] is not None
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_partial_batch_failure(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """In a batch of 2, if only the first individual retry fails, the second still succeeds."""
-        bank_id = f"test-partial-fail-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            mem_ids = await _insert_memories(
-                conn,
-                bank_id,
-                [
-                    "Eve speaks three languages fluently.",
-                    "Eve learned Japanese in two years.",
-                ],
-            )
-
-        # Exhaust 3 retries for batch=2 (calls 1-3), exhaust 3 retries for first batch=1 (calls 4-6),
-        # second batch=1 succeeds (call 7)
-        mock_llm = _make_failing_mock_llm(fail_first_n=6)
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        assert result["memories_processed"] == 2
-        assert result["memories_failed"] == 1
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            rows = {
-                str(r["id"]): r
-                for r in await conn.fetch(
-                    "SELECT id, consolidated_at, consolidation_failed_at FROM memory_units "
-                    "WHERE bank_id = $1 AND fact_type = 'experience'",
-                    bank_id,
-                )
-            }
-
-        # One should have failed, one should have succeeded
-        failed = [r for r in rows.values() if r["consolidation_failed_at"] is not None]
-        succeeded = [r for r in rows.values() if r["consolidated_at"] is not None]
-        assert len(failed) == 1
-        assert len(succeeded) == 1
-        # They must be different memories
-        assert str(failed[0]["id"]) != str(succeeded[0]["id"])
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-
-class TestRecoverConsolidation:
-    """Verify the retry_failed_consolidation() method and the /consolidation/recover endpoint."""
-
-    @pytest.mark.asyncio
-    async def test_recover_resets_failed_memories(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """retry_failed_consolidation resets consolidation_failed_at and consolidated_at."""
-        bank_id = f"test-recover-reset-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            ids = await _insert_memories(
-                conn,
-                bank_id,
-                [
-                    "Frank is a competitive cyclist.",
-                    "Frank completed the Tour de France route.",
-                ],
-            )
-            # Mark both as failed
-            for mem_id in ids:
-                await conn.execute(
-                    "UPDATE memory_units SET consolidation_failed_at = NOW() WHERE id = $1",
-                    mem_id,
-                )
-
-        result = await memory_no_llm_verify.retry_failed_consolidation(
-            bank_id, request_context=request_context
-        )
-
-        assert result["retried_count"] == 2
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            rows = await conn.fetch(
-                "SELECT consolidated_at, consolidation_failed_at FROM memory_units "
-                "WHERE bank_id = $1 AND fact_type = 'experience'",
-                bank_id,
-            )
-        assert all(r["consolidation_failed_at"] is None for r in rows), "consolidation_failed_at must be cleared"
-        assert all(r["consolidated_at"] is None for r in rows), "consolidated_at must also be cleared"
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_recover_returns_zero_when_none_failed(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """retry_failed_consolidation returns 0 when no memories have failed."""
-        bank_id = f"test-recover-zero-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        result = await memory_no_llm_verify.retry_failed_consolidation(
-            bank_id, request_context=request_context
-        )
-
-        assert result["retried_count"] == 0
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_recover_then_consolidate_succeeds(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """After recovery, the memory is picked up by the next consolidation run."""
-        bank_id = f"test-recover-consolidate-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            (mem_id,) = await _insert_memories(conn, bank_id, ["Grace is an expert rock climber."])
-            await conn.execute(
-                "UPDATE memory_units SET consolidation_failed_at = NOW() WHERE id = $1", mem_id
-            )
-
-        # Recover
-        recover_result = await memory_no_llm_verify.retry_failed_consolidation(
-            bank_id, request_context=request_context
-        )
-        assert recover_result["retried_count"] == 1
-
-        # Now consolidate with a healthy LLM
-        mock_llm = _make_always_success_mock_llm()
-        _inject_mock_llm(memory_no_llm_verify, mock_llm)
-
-        run_result = await run_consolidation_job(
-            memory_engine=memory_no_llm_verify,
-            bank_id=bank_id,
-            request_context=request_context,
-        )
-
-        assert run_result["memories_processed"] == 1
-        assert run_result["memories_failed"] == 0
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            row = await conn.fetchrow(
-                "SELECT consolidated_at, consolidation_failed_at FROM memory_units WHERE id = $1",
-                mem_id,
-            )
-        assert row["consolidated_at"] is not None, "Memory should be consolidated after recovery"
-        assert row["consolidation_failed_at"] is None
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
-
-    @pytest.mark.asyncio
-    async def test_recover_endpoint_via_http(self, memory_no_llm_verify: MemoryEngine, request_context):
-        """The POST /consolidation/recover endpoint returns the correct retried_count."""
-        import httpx
-
-        from hindsight_api.api.http import create_app
-
-        bank_id = f"test-recover-http-{uuid.uuid4().hex[:8]}"
-        await memory_no_llm_verify.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        async with memory_no_llm_verify._pool.acquire() as conn:
-            ids = await _insert_memories(
-                conn,
-                bank_id,
-                ["Henry is a professional chef.", "Henry trained at Le Cordon Bleu."],
-            )
-            for mem_id in ids:
-                await conn.execute(
-                    "UPDATE memory_units SET consolidation_failed_at = NOW() WHERE id = $1", mem_id
-                )
-
-        app = create_app(memory_no_llm_verify, initialize_memory=False)
-        transport = httpx.ASGITransport(app=app)
-        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
-            response = await client.post(f"/v1/default/banks/{bank_id}/consolidation/recover")
-
-        assert response.status_code == 200
-        body = response.json()
-        assert body["retried_count"] == 2
-
-        await memory_no_llm_verify.delete_bank(bank_id, request_context=request_context)
@@ -1,70 +0,0 @@
-"""
-Tests for EntityResolver edge cases.
-"""
-
-import uuid
-from datetime import datetime, timezone
-
-import asyncpg
-import pytest
-
-from hindsight_api.engine.entity_resolver import EntityResolver
-from hindsight_api.pg0 import resolve_database_url
-
-
-@pytest.mark.asyncio
-async def test_resolve_entities_batch_handles_unicode_lower_conflicts(pg0_db_url):
-    """
-    Existing entities with PostgreSQL/Python lowercase mismatches should resolve
-    to the conflicted row instead of leaving a missing entity_id.
-    """
-    resolved_url = await resolve_database_url(pg0_db_url)
-    pool = await asyncpg.create_pool(resolved_url, min_size=1, max_size=2, command_timeout=30)
-    bank_id = f"test-entity-resolver-{uuid.uuid4().hex[:8]}"
-    event_date = datetime(2024, 1, 15, tzinfo=timezone.utc)
-    resolver = EntityResolver(pool=pool, entity_lookup="full")
-
-    try:
-        async with pool.acquire() as conn:
-            existing_entity_id = await conn.fetchval(
-                """
-                INSERT INTO entities (bank_id, canonical_name, first_seen, last_seen, mention_count)
-                VALUES ($1, $2, $3, $3, 1)
-                RETURNING id
-                """,
-                bank_id,
-                "İstanbul",
-                event_date,
-            )
-
-            resolved_ids = await resolver.resolve_entities_batch(
-                bank_id=bank_id,
-                entities_data=[
-                    {
-                        "text": "istanbul",
-                        "nearby_entities": [],
-                        "event_date": event_date,
-                    }
-                ],
-                context="unicode case mismatch",
-                unit_event_date=event_date,
-                conn=conn,
-            )
-
-            entity_rows = await conn.fetch(
-                """
-                SELECT id, canonical_name
-                FROM entities
-                WHERE bank_id = $1
-                ORDER BY canonical_name
-                """,
-                bank_id,
-            )
-
-        assert resolved_ids == [existing_entity_id]
-        assert len(entity_rows) == 1
-        assert entity_rows[0]["id"] == existing_entity_id
-        assert entity_rows[0]["canonical_name"] == "İstanbul"
-    finally:
-        await pool.execute("DELETE FROM entities WHERE bank_id = $1", bank_id)
-        await pool.close()
@@ -1,193 +0,0 @@
-"""
-Tests for per-bank HNSW index lifecycle and UNION ALL retrieval.
-
-Covers:
- _hnsw_index_name deterministic naming
- Per-bank HNSW indexes created on bank creation (retain_async / ensure_bank_exists)
- Per-bank HNSW indexes dropped on bank deletion
- retrieve_semantic_bm25_combined groups results correctly by fact_type and source
-"""
-import uuid
-from datetime import datetime, timezone
-
-import pytest
-
-from hindsight_api.engine.retain.bank_utils import _HNSW_FACT_TYPES, _hnsw_index_name
-
-
-# ---------------------------------------------------------------------------
-# Unit tests — no DB required
-# ---------------------------------------------------------------------------
-
-
-class TestHnswIndexName:
-    def test_deterministic(self):
-        uid = "550e8400-e29b-41d4-a716-446655440000"
-        assert _hnsw_index_name("world", uid) == _hnsw_index_name("world", uid)
-
-    def test_strips_dashes(self):
-        uid = "550e8400-e29b-41d4-a716-446655440000"
-        name = _hnsw_index_name("world", uid)
-        # uid16 should be hex chars only
-        assert "-" not in name
-
-    def test_uses_first_16_hex_chars(self):
-        uid = "550e8400-e29b-41d4-a716-446655440000"
-        uid16 = uid.replace("-", "")[:16]  # "550e8400e29b41d4"
-        assert name_ends_with(name=_hnsw_index_name("world", uid), suffix=uid16)
-
-    def test_suffix_per_fact_type(self):
-        uid = "550e8400-e29b-41d4-a716-446655440000"
-        names = {ft: _hnsw_index_name(ft, uid) for ft in _HNSW_FACT_TYPES}
-        # All three names must be distinct
-        assert len(set(names.values())) == 3
-
-    def test_all_fact_types_covered(self):
-        assert set(_HNSW_FACT_TYPES) == {"world", "experience", "observation"}
-
-    def test_fits_pg_identifier_limit(self):
-        # PostgreSQL max identifier length is 63 chars
-        uid = "f" * 32  # simulated UUID without dashes
-        for ft in _HNSW_FACT_TYPES:
-            assert len(_hnsw_index_name(ft, uid)) <= 63
-
-
-def name_ends_with(name: str, suffix: str) -> bool:
-    return name.endswith(suffix)
-
-
-# ---------------------------------------------------------------------------
-# Integration tests — require DB (memory fixture)
-# ---------------------------------------------------------------------------
-
-
-async def _get_bank_hnsw_indexes(pool, bank_id: str) -> list[str]:
-    """Return index names for memory_units that match the per-bank pattern."""
-    async with pool.acquire() as conn:
-        rows = await conn.fetch(
-            """
-            SELECT indexname
-            FROM pg_indexes
-            WHERE tablename = 'memory_units'
-              AND indexname LIKE 'idx_mu_emb_%'
-              AND indexdef LIKE $1
-            ORDER BY indexname
-            """,
-            f"%bank_id = '{bank_id}'%",
-        )
-    return [row["indexname"] for row in rows]
-
-
-@pytest.mark.asyncio
-async def test_retain_creates_per_bank_hnsw_indexes(memory, request_context):
-    """retain_async on a new bank must create 3 per-(bank, fact_type) HNSW indexes."""
-    bank_id = f"test_hnsw_create_{uuid.uuid4().hex[:8]}"
-    try:
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Alice is a software engineer.",
-            request_context=request_context,
-        )
-        indexes = await _get_bank_hnsw_indexes(memory._pool, bank_id)
-        assert len(indexes) == 3, f"Expected 3 per-bank HNSW indexes, got: {indexes}"
-        for ft_short in _HNSW_FACT_TYPES.values():
-            assert any(ft_short in idx for idx in indexes), (
-                f"Missing index for fact_type short '{ft_short}' in {indexes}"
-            )
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_delete_bank_drops_hnsw_indexes(memory, request_context):
-    """delete_bank must drop all per-bank HNSW indexes."""
-    bank_id = f"test_hnsw_drop_{uuid.uuid4().hex[:8]}"
-
-    await memory.retain_async(
-        bank_id=bank_id,
-        content="Bob is a data scientist.",
-        request_context=request_context,
-    )
-    # Verify indexes exist before deletion
-    indexes_before = await _get_bank_hnsw_indexes(memory._pool, bank_id)
-    assert len(indexes_before) == 3
-
-    await memory.delete_bank(bank_id, request_context=request_context)
-
-    indexes_after = await _get_bank_hnsw_indexes(memory._pool, bank_id)
-    assert indexes_after == [], f"Indexes should be dropped after bank deletion, got: {indexes_after}"
-
-
-@pytest.mark.asyncio
-async def test_retain_idempotent_bank_creation(memory, request_context):
-    """Retaining into the same bank twice must not error and still have exactly 3 indexes."""
-    bank_id = f"test_hnsw_idem_{uuid.uuid4().hex[:8]}"
-    try:
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Carol is a product manager.",
-            request_context=request_context,
-        )
-        await memory.retain_async(
-            bank_id=bank_id,
-            content="Carol joined the company in 2022.",
-            request_context=request_context,
-        )
-        indexes = await _get_bank_hnsw_indexes(memory._pool, bank_id)
-        assert len(indexes) == 3
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
-@pytest.mark.asyncio
-async def test_retrieve_semantic_bm25_grouped_by_fact_type(memory, request_context):
-    """
-    retrieve_semantic_bm25_combined must return a dict keyed by fact_type with
-    (semantic_list, bm25_list) tuples.  All returned facts must belong to their
-    declared fact_type.
-    """
-    from hindsight_api.engine.search.retrieval import retrieve_semantic_bm25_combined
-
-    bank_id = f"test_retrieval_{uuid.uuid4().hex[:8]}"
-    try:
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=(
-                "Alice is a software engineer at TechCorp. "
-                "She visited Paris in 2023 for a conference."
-            ),
-            context="background",
-            event_date=datetime(2023, 6, 1, tzinfo=timezone.utc),
-            request_context=request_context,
-        )
-
-        query_emb = memory.embeddings.encode(["software engineer Alice"])
-        query_emb_str = str(query_emb[0])
-
-        fact_types = ["world", "experience"]
-        async with memory._pool.acquire() as conn:
-            results = await retrieve_semantic_bm25_combined(
-                conn=conn,
-                query_emb_str=query_emb_str,
-                query_text="software engineer Alice",
-                bank_id=bank_id,
-                fact_types=fact_types,
-                limit=5,
-            )
-
-        # Must return an entry for every requested fact_type
-        assert set(results.keys()) == set(fact_types)
-
-        for ft, (sem, bm25) in results.items():
-            # Semantic and BM25 lists must be lists
-            assert isinstance(sem, list)
-            assert isinstance(bm25, list)
-            # All semantic results must declare the correct fact_type
-            for r in sem:
-                assert r.fact_type == ft, f"Semantic result has wrong fact_type: {r.fact_type}"
-            # All BM25 results must declare the correct fact_type
-            for r in bm25:
-                assert r.fact_type == ft, f"BM25 result has wrong fact_type: {r.fact_type}"
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
@@ -1,154 +0,0 @@
-"""Tests for migration g7h8i9j0k1l2 (backsweep orphaned memory_units).
-
-Uses a dedicated pg0 instance (port 5562) so the test can control exactly
-which migrations have run before inserting the orphan seed data.
-"""
-
-import asyncio
-import uuid
-from pathlib import Path
-
-import pytest
-from alembic import command
-from alembic.config import Config
-from sqlalchemy import create_engine, text
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-_SCRIPT_LOCATION = str(Path(__file__).parent.parent / "hindsight_api" / "alembic")
-
-
-def _alembic_cfg(db_url: str) -> Config:
-    cfg = Config()
-    cfg.set_main_option("script_location", _SCRIPT_LOCATION)
-    cfg.set_main_option("sqlalchemy.url", db_url)
-    cfg.set_main_option("prepend_sys_path", ".")
-    cfg.set_main_option("path_separator", "os")
-    return cfg
-
-
-def _upgrade(db_url: str, revision: str) -> None:
-    command.upgrade(_alembic_cfg(db_url), revision)
-
-
-# ---------------------------------------------------------------------------
-# Fixture: fresh database at the revision just before the backsweep
-# ---------------------------------------------------------------------------
-
-@pytest.fixture(scope="module")
-def pre_backsweep_db_url():
-    """
-    Spin up a dedicated pg0 instance and run all migrations up to (but not
-    including) the backsweep revision so each test can seed orphan data and
-    then apply the backsweep itself.
-    """
-    from hindsight_api.pg0 import EmbeddedPostgres
-
-    pg0 = EmbeddedPostgres(name="hindsight-backsweep-test", port=5562)
-    loop = asyncio.new_event_loop()
-    try:
-        url = loop.run_until_complete(pg0.ensure_running())
-    finally:
-        loop.close()
-
-    # Migrate up to the revision just before the backsweep.
-    _upgrade(url, "f6g7h8i9j0k1")
-    return url
-
-
-# ---------------------------------------------------------------------------
-# The test
-# ---------------------------------------------------------------------------
-
-def test_backsweep_removes_orphans_and_preserves_legit_rows(pre_backsweep_db_url):
-    """
-    Seed four kinds of rows then apply the backsweep migration and verify:
-
-    Rows that MUST be deleted
-    ─────────────────────────
-    A. Any fact_type, bank_id missing from banks
-       → Pass 1 deletes these regardless of fact_type or source links.
-
-    B. observation, bank exists, but ALL source_memory_ids are gone
-       → Pass 2 deletes these.
-
-    Rows that MUST survive
-    ──────────────────────
-    C. observation, bank exists, at least ONE source_memory_id still live
-       → Pass 2 must not touch these.
-
-    D. Non-observation (world), bank exists, no sources (not relevant)
-       → Pass 1 must not touch these (bank exists).
-    """
-    db_url = pre_backsweep_db_url
-    engine = create_engine(db_url)
-
-    alive_bank = f"bank_{uuid.uuid4().hex[:8]}"
-    ghost_bank = f"bank_{uuid.uuid4().hex[:8]}"  # never inserted into banks
-
-    # UUIDs for memory units
-    id_pass1_world = uuid.uuid4()       # A: world unit, ghost bank
-    id_pass1_obs = uuid.uuid4()         # A: observation, ghost bank
-    id_pass2_obs = uuid.uuid4()         # B: observation, all sources gone
-    id_keep_obs = uuid.uuid4()          # C: observation with one live source
-    id_keep_world = uuid.uuid4()        # D: world unit, alive bank
-    id_live_source = uuid.uuid4()       # live source for C
-
-    with engine.connect() as conn:
-        # --- banks ---
-        conn.execute(text("INSERT INTO banks (bank_id) VALUES (:b)"), {"b": alive_bank})
-
-        # --- seed memory_units ---
-        def insert_mu(uid, bank, fact_type, sources=None):
-            src_arr = "{" + ",".join(str(s) for s in (sources or [])) + "}"
-            conn.execute(
-                text(
-                    """
-                    INSERT INTO memory_units
-                        (id, bank_id, text, fact_type, source_memory_ids)
-                    VALUES
-                        (:id, :bank, :text, :ft, CAST(:src AS uuid[]))
-                    """
-                ),
-                {"id": uid, "bank": bank, "text": "test", "ft": fact_type, "src": src_arr},
-            )
-
-        # A: ghost-bank rows (Pass 1 targets)
-        insert_mu(id_pass1_world, ghost_bank, "world")
-        insert_mu(id_pass1_obs, ghost_bank, "observation", sources=[uuid.uuid4()])
-
-        # B: observation with all-dead sources (Pass 2 target)
-        insert_mu(id_pass2_obs, alive_bank, "observation", sources=[uuid.uuid4(), uuid.uuid4()])
-
-        # C: observation with one live source (must survive)
-        insert_mu(id_live_source, alive_bank, "world")
-        insert_mu(id_keep_obs, alive_bank, "observation", sources=[id_live_source, uuid.uuid4()])
-
-        # D: world unit in alive bank (must survive)
-        insert_mu(id_keep_world, alive_bank, "world")
-
-        conn.commit()
-
-    # --- apply the backsweep ---
-    _upgrade(db_url, "g7h8i9j0k1l2")
-
-    # --- verify ---
-    with engine.connect() as conn:
-        def exists(uid):
-            return conn.execute(
-                text("SELECT 1 FROM memory_units WHERE id = :id"), {"id": uid}
-            ).fetchone() is not None
-
-        # Must be gone
-        assert not exists(id_pass1_world), "Pass 1: world unit with ghost bank should be deleted"
-        assert not exists(id_pass1_obs), "Pass 1: observation with ghost bank should be deleted"
-        assert not exists(id_pass2_obs), "Pass 2: observation with all-dead sources should be deleted"
-
-        # Must survive
-        assert exists(id_keep_obs), "observation with a live source must not be deleted"
-        assert exists(id_keep_world), "world unit in alive bank must not be deleted"
-        assert exists(id_live_source), "live source memory unit must not be deleted"
-
-    engine.dispose()
@@ -1,311 +0,0 @@
-"""Tests for operation cancellation when a bank is deleted.
-
-Covers:
- CASCADE DELETE: deleting a bank removes async_operations and webhooks rows
- _check_op_alive: returns True when op exists, False when deleted
- _mark_operation_completed / _mark_operation_failed: graceful no-op when row is gone
- Consolidation checkpoint: stops early after a batch commit if op was deleted
- Retain checkpoint: stops between sub-batches if op was deleted
-"""
-
-import uuid
-from unittest.mock import AsyncMock, patch
-
-import pytest
-import pytest_asyncio
-
-from hindsight_api.engine.memory_engine import MemoryEngine
-
-
-pytestmark = pytest.mark.xdist_group("op_cancellation_tests")
-
-_BANK_PREFIX = "test-op-cancel"
-
-
-@pytest_asyncio.fixture
-async def pool(pg0_db_url):
-    import asyncpg
-    from hindsight_api.pg0 import resolve_database_url
-
-    resolved_url = await resolve_database_url(pg0_db_url)
-    p = await asyncpg.create_pool(resolved_url, min_size=1, max_size=5, command_timeout=30)
-    yield p
-    await p.close()
-
-
-@pytest_asyncio.fixture(autouse=True)
-async def cleanup(pool):
-    """Remove test rows before and after each test."""
-    await pool.execute(f"DELETE FROM banks WHERE bank_id LIKE '{_BANK_PREFIX}%'")
-    yield
-    await pool.execute(f"DELETE FROM banks WHERE bank_id LIKE '{_BANK_PREFIX}%'")
-
-
-async def _insert_bank(pool, bank_id: str):
-    await pool.execute(
-        "INSERT INTO banks (bank_id, name) VALUES ($1, $2) ON CONFLICT DO NOTHING",
-        bank_id,
-        bank_id,
-    )
-
-
-async def _insert_op(pool, bank_id: str, op_id: uuid.UUID | None = None) -> uuid.UUID:
-    op_id = op_id or uuid.uuid4()
-    await pool.execute(
-        """
-        INSERT INTO async_operations (operation_id, bank_id, operation_type, status)
-        VALUES ($1, $2, 'consolidation', 'processing')
-        """,
-        op_id,
-        bank_id,
-    )
-    return op_id
-
-
-# ---------------------------------------------------------------------------
-# CASCADE DELETE tests
-# ---------------------------------------------------------------------------
-
-
-class TestCascadeDeleteOnBankDeletion:
-    @pytest.mark.asyncio
-    async def test_bank_deletion_cascades_to_async_operations(self, pool):
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await _insert_bank(pool, bank_id)
-        op_id = await _insert_op(pool, bank_id)
-
-        # Verify op exists
-        row = await pool.fetchrow("SELECT operation_id FROM async_operations WHERE operation_id = $1", op_id)
-        assert row is not None
-
-        # Delete the bank — should cascade to async_operations
-        await pool.execute("DELETE FROM banks WHERE bank_id = $1", bank_id)
-
-        row = await pool.fetchrow("SELECT operation_id FROM async_operations WHERE operation_id = $1", op_id)
-        assert row is None, "async_operations row should be deleted by CASCADE"
-
-    @pytest.mark.asyncio
-    async def test_bank_deletion_cascades_to_webhooks(self, pool):
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await _insert_bank(pool, bank_id)
-        webhook_id = uuid.uuid4()
-        await pool.execute(
-            """
-            INSERT INTO webhooks (id, bank_id, url, event_types)
-            VALUES ($1, $2, 'https://example.com/hook', '{}')
-            """,
-            webhook_id,
-            bank_id,
-        )
-
-        row = await pool.fetchrow("SELECT id FROM webhooks WHERE id = $1", webhook_id)
-        assert row is not None
-
-        await pool.execute("DELETE FROM banks WHERE bank_id = $1", bank_id)
-
-        row = await pool.fetchrow("SELECT id FROM webhooks WHERE id = $1", webhook_id)
-        assert row is None, "webhooks row should be deleted by CASCADE"
-
-
-# ---------------------------------------------------------------------------
-# _check_op_alive tests
-# ---------------------------------------------------------------------------
-
-
-class TestCheckOpAlive:
-    @pytest.mark.asyncio
-    async def test_returns_true_when_op_exists(self, memory: MemoryEngine, request_context):
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        op_id = uuid.uuid4()
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO async_operations (operation_id, bank_id, operation_type, status)
-                VALUES ($1, $2, 'consolidation', 'processing')
-                """,
-                op_id,
-                bank_id,
-            )
-
-        assert await memory._check_op_alive(str(op_id)) is True
-
-    @pytest.mark.asyncio
-    async def test_returns_false_when_op_deleted(self, memory: MemoryEngine, request_context):
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        op_id = uuid.uuid4()
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO async_operations (operation_id, bank_id, operation_type, status)
-                VALUES ($1, $2, 'consolidation', 'processing')
-                """,
-                op_id,
-                bank_id,
-            )
-            await conn.execute("DELETE FROM async_operations WHERE operation_id = $1", op_id)
-
-        assert await memory._check_op_alive(str(op_id)) is False
-
-    @pytest.mark.asyncio
-    async def test_returns_false_after_bank_cascade_delete(self, memory: MemoryEngine, request_context):
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        op_id = uuid.uuid4()
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO async_operations (operation_id, bank_id, operation_type, status)
-                VALUES ($1, $2, 'consolidation', 'processing')
-                """,
-                op_id,
-                bank_id,
-            )
-
-        # Delete the bank — cascades to the op row
-        await memory.delete_bank(bank_id=bank_id, request_context=request_context)
-
-        assert await memory._check_op_alive(str(op_id)) is False
-
-
-# ---------------------------------------------------------------------------
-# _mark_operation_completed / _mark_operation_failed graceful no-op
-# ---------------------------------------------------------------------------
-
-
-class TestMarkOperationGracefulOnMissingRow:
-    @pytest.mark.asyncio
-    async def test_mark_completed_does_not_raise_when_row_missing(self, memory: MemoryEngine):
-        # Row never existed — should log and return cleanly
-        missing_id = str(uuid.uuid4())
-        await memory._mark_operation_completed(missing_id)  # no exception
-
-    @pytest.mark.asyncio
-    async def test_mark_failed_does_not_raise_when_row_missing(self, memory: MemoryEngine):
-        missing_id = str(uuid.uuid4())
-        await memory._mark_operation_failed(missing_id, "some error", "traceback here")  # no exception
-
-    @pytest.mark.asyncio
-    async def test_mark_completed_and_fire_webhook_does_not_raise_when_row_missing(
-        self, memory: MemoryEngine
-    ):
-        missing_id = str(uuid.uuid4())
-        await memory._mark_operation_completed_and_fire_webhook(
-            operation_id=missing_id,
-            bank_id="nonexistent-bank",
-            status="completed",
-            result=None,
-        )  # no exception
-
-
-# ---------------------------------------------------------------------------
-# Consolidation checkpoint
-# ---------------------------------------------------------------------------
-
-
-class TestConsolidationCheckpoint:
-    @pytest.mark.asyncio
-    async def test_consolidation_stops_early_when_op_cancelled(self, memory: MemoryEngine, request_context):
-        """Consolidation returns 'cancelled' status after the first batch if _check_op_alive is False."""
-        from hindsight_api.config import _get_raw_config
-        from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
-
-        config = _get_raw_config()
-        original = config.enable_observations
-        config.enable_observations = True
-
-        try:
-            bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-            await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-            # Insert a few unconsolidated memories directly so we control the batch without LLM
-            async with memory._pool.acquire() as conn:
-                for i in range(3):
-                    await conn.execute(
-                        """
-                        INSERT INTO memory_units
-                            (id, bank_id, text, fact_type, created_at, updated_at)
-                        VALUES (gen_random_uuid(), $1, $2, 'experience', NOW(), NOW())
-                        """,
-                        bank_id,
-                        f"Test memory {i} for cancellation test",
-                    )
-
-            op_id = str(uuid.uuid4())
-            call_count = 0
-
-            async def _fake_check(operation_id: str) -> bool:
-                nonlocal call_count
-                call_count += 1
-                # Return False on the very first checkpoint call
-                return False
-
-            with patch.object(memory, "_check_op_alive", side_effect=_fake_check):
-                result = await run_consolidation_job(
-                    memory_engine=memory,
-                    bank_id=bank_id,
-                    request_context=request_context,
-                    operation_id=op_id,
-                )
-
-            assert result["status"] == "cancelled"
-            assert call_count >= 1
-        finally:
-            config.enable_observations = original
-
-
-# ---------------------------------------------------------------------------
-# Retain checkpoint
-# ---------------------------------------------------------------------------
-
-
-class TestRetainCheckpoint:
-    @pytest.mark.asyncio
-    async def test_retain_stops_between_sub_batches_when_cancelled(
-        self, memory: MemoryEngine, request_context
-    ):
-        """retain_batch_async returns partial results if _check_op_alive is False between sub-batches."""
-        from hindsight_api.config import _get_raw_config
-
-        bank_id = f"{_BANK_PREFIX}-{uuid.uuid4().hex[:8]}"
-        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
-
-        # Force sub-batch splitting by temporarily lowering the token threshold
-        config = _get_raw_config()
-        original_tokens = config.retain_batch_tokens
-        # Set threshold very low so each item becomes its own sub-batch
-        config.retain_batch_tokens = 1
-
-        try:
-            op_id = str(uuid.uuid4())
-            check_calls = 0
-
-            async def _fake_check(operation_id: str) -> bool:
-                nonlocal check_calls
-                check_calls += 1
-                # Cancel after the first sub-batch completes
-                return check_calls <= 1
-
-            contents = [
-                {"content": f"Memory item {i} about something interesting."} for i in range(4)
-            ]
-
-            with patch.object(memory, "_check_op_alive", side_effect=_fake_check):
-                result = await memory.retain_batch_async(
-                    bank_id=bank_id,
-                    contents=contents,
-                    request_context=request_context,
-                    operation_id=op_id,
-                )
-
-            # Should have stopped early: fewer results than total items
-            assert len(result) < len(contents), (
-                f"Expected early stop but got {len(result)}/{len(contents)} results"
-            )
-            assert check_calls >= 1
-        finally:
-            config.retain_batch_tokens = original_tokens
@@ -46,4 +46,4 @@ __all__ = [
    "RemoteTEICrossEncoder",
    "LLMConfig",
 ]
-__version__ = "0.4.19"
+__version__ = "0.4.17"
@@ -34,7 +34,7 @@ def upgrade() -> None:
    # Create file_storage table (minimal: just key + data)
    op.execute(
        f"""
-        CREATE TABLE IF NOT EXISTS {schema}file_storage (
+        CREATE TABLE {schema}file_storage (
            storage_key TEXT PRIMARY KEY,
            data BYTEA NOT NULL
        )
@@ -35,7 +35,7 @@ def upgrade() -> None:

    # Add GIN index for JSONB containment queries (@> operator)
    op.execute(f"""
-        CREATE INDEX IF NOT EXISTS idx_async_operations_result_metadata
+        CREATE INDEX idx_async_operations_result_metadata
        ON {schema}async_operations
        USING gin(result_metadata)
    """)
@@ -10,7 +10,7 @@ import json
 import logging
 import uuid
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Literal

 from fastapi import Depends, FastAPI, File, Form, Header, HTTPException, Query, UploadFile
@@ -34,7 +34,7 @@ def _parse_metadata(metadata: Any) -> dict[str, Any]:

 from typing import Callable

-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator

 from hindsight_api import MemoryEngine

@@ -73,13 +73,15 @@ def FieldWithDefault(default_factory: Callable, **kwargs) -> Any:
 from hindsight_api.config import get_config
 from hindsight_api.engine.memory_engine import Budget, _current_schema, _get_tiktoken_encoding, fq_table
 from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES, MemoryFact, TokenUsage
-from hindsight_api.engine.search.tags import TagGroup, TagsMatch
+from hindsight_api.engine.search.tags import TagsMatch
 from hindsight_api.extensions import HttpExtension, OperationValidationError, load_extension
 from hindsight_api.metrics import create_metrics_collector, get_metrics_collector, initialize_metrics
 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."""
@@ -163,17 +165,6 @@ class RecallRequest(BaseModel):
        description="How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), "
        "'any_strict' (OR, excludes untagged), 'all_strict' (AND, excludes untagged).",
    )
-    tag_groups: list[TagGroup] | None = Field(
-        default=None,
-        description="Compound tag filter using boolean groups. Groups in the list are AND-ed. "
-        "Each group is a leaf {tags, match} or compound {and: [...]}, {or: [...]}, {not: ...}.",
-    )
-
-    @model_validator(mode="after")
-    def validate_tags_exclusive(self) -> "RecallRequest":
-        if self.tags is not None and self.tag_groups is not None:
-            raise ValueError("'tags' and 'tag_groups' are mutually exclusive. Use 'tag_groups' for compound filtering.")
-        return self


 class RecallResult(BaseModel):
@@ -425,11 +416,6 @@ class MemoryItem(BaseModel):
            "A list of tag lists runs one pass per inner list, giving full control over which combinations to use."
        ),
    )
-    strategy: str | None = Field(
-        default=None,
-        description="Named retain strategy for this item. Overrides the bank's default strategy for this item only. "
-        "Strategies are defined in the bank config under 'retain_strategies'.",
-    )

    @field_validator("timestamp", mode="before")
    @classmethod
@@ -496,11 +482,6 @@ class FileRetainMetadata(BaseModel):
        description="Parser or ordered fallback chain for this file (overrides request-level parser). "
        "E.g. 'iris' or ['iris', 'markitdown'].",
    )
-    strategy: str | None = Field(
-        default=None,
-        description="Named retain strategy for this file. Overrides the bank's default strategy. "
-        "Strategies are defined in the bank config under 'retain_strategies'.",
-    )


 class FileRetainRequest(BaseModel):
@@ -554,11 +535,7 @@ class RetainResponse(BaseModel):
    )
    operation_id: str | None = Field(
        default=None,
-        description="Operation ID for tracking async operations. Use GET /v1/default/banks/{bank_id}/operations to list operations. Only present when async=true. When items use different per-item strategies, use operation_ids instead.",
-    )
-    operation_ids: list[str] | None = Field(
-        default=None,
-        description="Operation IDs when items were submitted as multiple strategy groups (async=true with mixed per-item strategies). operation_id is set to the first entry for backward compatibility.",
+        description="Operation ID for tracking async operations. Use GET /v1/default/banks/{bank_id}/operations to list operations. Only present when async=true.",
    )
    usage: TokenUsage | None = Field(
        default=None,
@@ -664,36 +641,6 @@ class ReflectRequest(BaseModel):
        description="How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), "
        "'any_strict' (OR, excludes untagged), 'all_strict' (AND, excludes untagged).",
    )
-    tag_groups: list[TagGroup] | None = Field(
-        default=None,
-        description="Compound tag filter using boolean groups. Groups in the list are AND-ed. "
-        "Each group is a leaf {tags, match} or compound {and: [...]}, {or: [...]}, {not: ...}.",
-    )
-    fact_types: list[Literal["world", "experience", "observation"]] | None = Field(
-        default=None,
-        description="Filter which fact types are retrieved during reflect. None means all types (world, experience, observation).",
-    )
-    exclude_mental_models: bool = Field(
-        default=False,
-        description="If true, exclude all mental models from the reflect loop (skip search_mental_models tool).",
-    )
-    exclude_mental_model_ids: list[str] | None = Field(
-        default=None,
-        description="Exclude specific mental models by ID from the reflect loop.",
-    )
-
-    @field_validator("fact_types")
-    @classmethod
-    def validate_reflect_fact_types(cls, v: list[str] | None) -> list[str] | None:
-        if v is not None and len(v) == 0:
-            raise ValueError("fact_types must not be empty. Use null to include all fact types.")
-        return v
-
-    @model_validator(mode="after")
-    def validate_tags_exclusive(self) -> "ReflectRequest":
-        if self.tags is not None and self.tag_groups is not None:
-            raise ValueError("'tags' and 'tag_groups' are mutually exclusive. Use 'tag_groups' for compound filtering.")
-        return self


 class ReflectFact(BaseModel):
@@ -1347,14 +1294,6 @@ class ClearMemoryObservationsResponse(BaseModel):
    deleted_count: int


-class RecoverConsolidationResponse(BaseModel):
-    """Response model for recovering failed consolidation."""
-
-    model_config = ConfigDict(json_schema_extra={"example": {"retried_count": 42}})
-
-    retried_count: int
-
-
 class BankStatsResponse(BaseModel):
    """Response model for bank statistics endpoint."""

@@ -1454,25 +1393,6 @@ class MentalModelTrigger(BaseModel):
        default=False,
        description="If true, refresh this mental model after observations consolidation (real-time mode)",
    )
-    fact_types: list[Literal["world", "experience", "observation"]] | None = Field(
-        default=None,
-        description="Filter which fact types are retrieved during reflect. None means all types (world, experience, observation).",
-    )
-    exclude_mental_models: bool = Field(
-        default=False,
-        description="If true, exclude all mental models from the reflect loop (skip search_mental_models tool).",
-    )
-    exclude_mental_model_ids: list[str] | None = Field(
-        default=None,
-        description="Exclude specific mental models by ID from the reflect loop.",
-    )
-
-    @field_validator("fact_types")
-    @classmethod
-    def validate_fact_types(cls, v: list[str] | None) -> list[str] | None:
-        if v is not None and len(v) == 0:
-            raise ValueError("fact_types must not be empty. Use null to include all fact types.")
-        return v


 class MentalModelResponse(BaseModel):
@@ -2343,13 +2263,12 @@ def _register_routes(app: FastAPI):
        metrics = get_metrics_collector()

        # Validate query length to prevent expensive operations on oversized queries
-        max_query_tokens = get_config().recall_max_query_tokens
        encoding = _get_tiktoken_encoding()
        query_tokens = len(encoding.encode(request.query))
-        if query_tokens > max_query_tokens:
+        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.",
+                detail=f"Query too long: {query_tokens} tokens exceeds maximum of {MAX_QUERY_TOKENS}. Please shorten your query.",
            )

        try:
@@ -2406,7 +2325,6 @@ def _register_routes(app: FastAPI):
                    request_context=request_context,
                    tags=request.tags,
                    tags_match=request.tags_match,
-                    tag_groups=request.tag_groups,
                )

            # Convert core MemoryFact objects to API RecallResult objects (excluding internal metrics)
@@ -2542,10 +2460,6 @@ def _register_routes(app: FastAPI):
                    request_context=request_context,
                    tags=request.tags,
                    tags_match=request.tags_match,
-                    tag_groups=request.tag_groups,
-                    fact_types=request.fact_types,
-                    exclude_mental_models=request.exclude_mental_models,
-                    exclude_mental_model_ids=request.exclude_mental_model_ids,
                )

            # Build based_on (memories + mental_models + directives) if facts are requested
@@ -3951,34 +3865,6 @@ def _register_routes(app: FastAPI):
            logger.error(f"Error in DELETE /v1/default/banks/{bank_id}/observations: {error_detail}")
            raise HTTPException(status_code=500, detail=str(e))

-    @app.post(
-        "/v1/default/banks/{bank_id}/consolidation/recover",
-        response_model=RecoverConsolidationResponse,
-        summary="Recover failed consolidation",
-        description=(
-            "Reset all memories that were permanently marked as failed during consolidation "
-            "(after exhausting all LLM retries and adaptive batch splitting) so they are "
-            "picked up again on the next consolidation run. Does not delete any observations."
-        ),
-        operation_id="recover_consolidation",
-        tags=["Banks"],
-    )
-    async def api_recover_consolidation(bank_id: str, request_context: RequestContext = Depends(get_request_context)):
-        """Reset consolidation-failed memories for recovery."""
-        try:
-            result = await app.state.memory.retry_failed_consolidation(bank_id, request_context=request_context)
-            return RecoverConsolidationResponse(retried_count=result["retried_count"])
-        except OperationValidationError as e:
-            raise HTTPException(status_code=e.status_code, detail=e.reason)
-        except (AuthenticationError, HTTPException):
-            raise
-        except Exception as e:
-            import traceback
-
-            error_detail = f"{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-            logger.error(f"Error in POST /v1/default/banks/{bank_id}/consolidation/recover: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
    @app.delete(
        "/v1/default/banks/{bank_id}/memories/{memory_id}/observations",
        response_model=ClearMemoryObservationsResponse,
@@ -4206,13 +4092,9 @@ def _register_routes(app: FastAPI):
        try:
            pool = await app.state.memory._get_pool()
            from hindsight_api.engine.memory_engine import fq_table
-            from hindsight_api.engine.retain import bank_utils
-
-            # Ensure the bank row exists before inserting into webhooks (FK constraint).
-            await bank_utils.get_bank_profile(pool, bank_id)

            webhook_id = uuid.uuid4()
-            now = datetime.now(timezone.utc).isoformat()
+            now = datetime.utcnow().isoformat() + "Z"
            row = await pool.fetchrow(
                f"""
                INSERT INTO {fq_table("webhooks")}
@@ -4532,13 +4414,10 @@ def _register_routes(app: FastAPI):
        metrics = get_metrics_collector()

        try:
-            # Group items by strategy
-            strategy_groups: dict[str | None, list[dict]] = {}
+            # Prepare contents for processing
+            contents = []
            for item in request.items:
-                effective = item.strategy
-                if effective not in strategy_groups:
-                    strategy_groups[effective] = []
-                content_dict: dict = {"content": item.content}
+                content_dict = {"content": item.content}
                if item.timestamp == "unset":
                    content_dict["event_date"] = None
                elif item.timestamp:
@@ -4555,30 +4434,20 @@ def _register_routes(app: FastAPI):
                    content_dict["tags"] = item.tags
                if item.observation_scopes is not None:
                    content_dict["observation_scopes"] = item.observation_scopes
-                strategy_groups[effective].append(content_dict)
+                contents.append(content_dict)

            if request.async_:
-                # Async processing: one submit per strategy group
-                all_operation_ids = []
-                total_items_count = 0
-                for group_strategy, contents in strategy_groups.items():
-                    result = await app.state.memory.submit_async_retain(
-                        bank_id,
-                        contents,
-                        document_tags=request.document_tags,
-                        strategy=group_strategy,
-                        request_context=request_context,
-                    )
-                    all_operation_ids.append(result["operation_id"])
-                    total_items_count += result["items_count"]
+                # Async processing: queue task and return immediately
+                result = await app.state.memory.submit_async_retain(
+                    bank_id, contents, document_tags=request.document_tags, request_context=request_context
+                )
                return RetainResponse.model_validate(
                    {
                        "success": True,
                        "bank_id": bank_id,
-                        "items_count": total_items_count,
+                        "items_count": result["items_count"],
                        "async": True,
-                        "operation_id": all_operation_ids[0] if all_operation_ids else None,
-                        "operation_ids": all_operation_ids if len(all_operation_ids) > 1 else None,
+                        "operation_id": result["operation_id"],
                    }
                )
            else:
@@ -4597,41 +4466,24 @@ def _register_routes(app: FastAPI):
                        ),
                    )

-                # Synchronous processing: one batch per strategy group, aggregate results
-                total_items_count = 0
-                total_usage = TokenUsage(input_tokens=0, output_tokens=0, total_tokens=0)
+                # Synchronous processing: wait for completion (record metrics)
                with metrics.record_operation("retain", bank_id=bank_id, source="api"):
-                    for group_strategy, contents in strategy_groups.items():
-                        result, usage = await app.state.memory.retain_batch_async(
+                    result, usage = await app.state.memory.retain_batch_async(
+                        bank_id=bank_id,
+                        contents=contents,
+                        document_tags=request.document_tags,
+                        request_context=request_context,
+                        return_usage=True,
+                        outbox_callback=app.state.memory._build_retain_outbox_callback(
                            bank_id=bank_id,
                            contents=contents,
-                            document_tags=request.document_tags,
-                            strategy=group_strategy,
-                            request_context=request_context,
-                            return_usage=True,
-                            outbox_callback=app.state.memory._build_retain_outbox_callback(
-                                bank_id=bank_id,
-                                contents=contents,
-                                operation_id=None,
-                                schema=_current_schema.get(),
-                            ),
-                        )
-                        total_items_count += len(contents)
-                        if usage:
-                            total_usage = TokenUsage(
-                                input_tokens=total_usage.input_tokens + usage.input_tokens,
-                                output_tokens=total_usage.output_tokens + usage.output_tokens,
-                                total_tokens=total_usage.total_tokens + usage.total_tokens,
-                            )
+                            operation_id=None,
+                            schema=_current_schema.get(),
+                        ),
+                    )

                return RetainResponse.model_validate(
-                    {
-                        "success": True,
-                        "bank_id": bank_id,
-                        "items_count": total_items_count,
-                        "async": False,
-                        "usage": total_usage,
-                    }
+                    {"success": True, "bank_id": bank_id, "items_count": len(contents), "async": False, "usage": usage}
                )
        except OperationValidationError as e:
            raise HTTPException(status_code=e.status_code, detail=e.reason)
@@ -4794,7 +4646,6 @@ def _register_routes(app: FastAPI):
                    "tags": file_meta.tags or [],
                    "timestamp": file_meta.timestamp,
                    "parser": parser_chain,
-                    "strategy": file_meta.strategy,
                }
                file_items.append(item)

@@ -381,15 +381,6 @@ class MCPMiddleware:
            # Clear root_path since we're passing directly to the app
            new_scope["root_path"] = ""

-            # Ensure Accept header includes required MIME types for MCP SDK.
-            # Some clients (e.g., Claude Code) don't send Accept, causing
-            # the SDK to reject with 406 Not Acceptable.
-            accept_header = self._get_header(new_scope, "accept")
-            if not accept_header or "text/event-stream" not in accept_header:
-                headers = [(k, v) for k, v in new_scope.get("headers", []) if k.lower() != b"accept"]
-                headers.append((b"accept", b"application/json, text/event-stream"))
-                new_scope["headers"] = headers
-
            # Wrap send to rewrite the SSE endpoint URL to include bank_id if using path-based routing.
            # Only rewrite SSE (text/event-stream) responses to avoid corrupting tool results
            # that might contain the literal string "data: /messages".
@@ -193,7 +193,6 @@ ENV_EMBEDDINGS_LITELLM_MODEL = "HINDSIGHT_API_EMBEDDINGS_LITELLM_MODEL"
 ENV_RERANKER_LITELLM_API_BASE = "HINDSIGHT_API_RERANKER_LITELLM_API_BASE"
 ENV_RERANKER_LITELLM_API_KEY = "HINDSIGHT_API_RERANKER_LITELLM_API_KEY"
 ENV_RERANKER_LITELLM_MODEL = "HINDSIGHT_API_RERANKER_LITELLM_MODEL"
-ENV_RERANKER_LITELLM_MAX_TOKENS_PER_DOC = "HINDSIGHT_API_RERANKER_LITELLM_MAX_TOKENS_PER_DOC"

 # LiteLLM SDK configuration (direct API access, no proxy needed)
 ENV_EMBEDDINGS_LITELLM_SDK_API_KEY = "HINDSIGHT_API_EMBEDDINGS_LITELLM_SDK_API_KEY"
@@ -212,9 +211,6 @@ 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_LOCAL_TRUST_REMOTE_CODE = "HINDSIGHT_API_RERANKER_LOCAL_TRUST_REMOTE_CODE"
-ENV_RERANKER_LOCAL_FP16 = "HINDSIGHT_API_RERANKER_LOCAL_FP16"
-ENV_RERANKER_LOCAL_BUCKET_BATCHING = "HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING"
-ENV_RERANKER_LOCAL_BATCH_SIZE = "HINDSIGHT_API_RERANKER_LOCAL_BATCH_SIZE"
 ENV_RERANKER_TEI_URL = "HINDSIGHT_API_RERANKER_TEI_URL"
 ENV_RERANKER_TEI_BATCH_SIZE = "HINDSIGHT_API_RERANKER_TEI_BATCH_SIZE"
 ENV_RERANKER_TEI_MAX_CONCURRENT = "HINDSIGHT_API_RERANKER_TEI_MAX_CONCURRENT"
@@ -242,7 +238,6 @@ ENV_GRAPH_RETRIEVER = "HINDSIGHT_API_GRAPH_RETRIEVER"
 ENV_MPFP_TOP_K_NEIGHBORS = "HINDSIGHT_API_MPFP_TOP_K_NEIGHBORS"
 ENV_RECALL_MAX_CONCURRENT = "HINDSIGHT_API_RECALL_MAX_CONCURRENT"
 ENV_RECALL_CONNECTION_BUDGET = "HINDSIGHT_API_RECALL_CONNECTION_BUDGET"
-ENV_RECALL_MAX_QUERY_TOKENS = "HINDSIGHT_API_RECALL_MAX_QUERY_TOKENS"
 ENV_MENTAL_MODEL_REFRESH_CONCURRENCY = "HINDSIGHT_API_MENTAL_MODEL_REFRESH_CONCURRENCY"

 # OpenTelemetry tracing configuration
@@ -267,7 +262,6 @@ ENV_RETAIN_EXTRACT_CAUSAL_LINKS = "HINDSIGHT_API_RETAIN_EXTRACT_CAUSAL_LINKS"
 ENV_RETAIN_EXTRACTION_MODE = "HINDSIGHT_API_RETAIN_EXTRACTION_MODE"
 ENV_RETAIN_MISSION = "HINDSIGHT_API_RETAIN_MISSION"
 ENV_RETAIN_CUSTOM_INSTRUCTIONS = "HINDSIGHT_API_RETAIN_CUSTOM_INSTRUCTIONS"
-ENV_RETAIN_DEFAULT_STRATEGY = "HINDSIGHT_API_RETAIN_DEFAULT_STRATEGY"
 ENV_RETAIN_BATCH_TOKENS = "HINDSIGHT_API_RETAIN_BATCH_TOKENS"
 ENV_RETAIN_ENTITY_LOOKUP = "HINDSIGHT_API_RETAIN_ENTITY_LOOKUP"
 ENV_RETAIN_BATCH_ENABLED = "HINDSIGHT_API_RETAIN_BATCH_ENABLED"
@@ -356,7 +350,6 @@ PROVIDER_DEFAULT_MODELS = {
    "anthropic": "claude-haiku-4-5-20251001",
    "gemini": "gemini-2.5-flash",
    "groq": "openai/gpt-oss-120b",
-    "minimax": "MiniMax-M2.7",
    "ollama": "gemma3:12b",
    "lmstudio": "local-model",
    "vertexai": "google/gemini-2.5-flash-lite",
@@ -393,9 +386,6 @@ DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4  # Limit concurrent CPU-bound rerankin
 DEFAULT_RERANKER_LOCAL_TRUST_REMOTE_CODE = (
    False  # Security: disabled by default, required for some models like jina-reranker-v2
 )
-DEFAULT_RERANKER_LOCAL_FP16 = False  # FP16 inference: opt-in, faster on MPS/CUDA (not CPU)
-DEFAULT_RERANKER_LOCAL_BUCKET_BATCHING = False  # Length-sorted bucket batching: opt-in, 36-54% speedup
-DEFAULT_RERANKER_LOCAL_BATCH_SIZE = 32  # Batch size for local reranker predict() calls
 DEFAULT_RERANKER_TEI_BATCH_SIZE = 128
 DEFAULT_RERANKER_TEI_MAX_CONCURRENT = 8
 DEFAULT_RERANKER_MAX_CANDIDATES = 300
@@ -417,7 +407,6 @@ DEFAULT_TEXT_SEARCH_EXTENSION = "native"  # Options: "native", "vchord", "pg_tex
 DEFAULT_LITELLM_API_BASE = "http://localhost:4000"
 DEFAULT_EMBEDDINGS_LITELLM_MODEL = "text-embedding-3-small"
 DEFAULT_RERANKER_LITELLM_MODEL = "cohere/rerank-english-v3.0"
-DEFAULT_RERANKER_LITELLM_MAX_TOKENS_PER_DOC: int | None = None

 # LiteLLM SDK defaults
 DEFAULT_EMBEDDINGS_LITELLM_SDK_MODEL = "cohere/embed-english-v3.0"
@@ -436,7 +425,6 @@ DEFAULT_GRAPH_RETRIEVER = "link_expansion"  # Options: "link_expansion", "mpfp",
 DEFAULT_MPFP_TOP_K_NEIGHBORS = 20  # Fan-out limit per node in MPFP graph traversal
 DEFAULT_RECALL_MAX_CONCURRENT = 32  # Max concurrent recall operations per worker
 DEFAULT_RECALL_CONNECTION_BUDGET = 4  # Max concurrent DB connections per recall operation
-DEFAULT_RECALL_MAX_QUERY_TOKENS = 500  # Maximum tokens allowed in recall query
 DEFAULT_MENTAL_MODEL_REFRESH_CONCURRENCY = 8  # Max concurrent mental model refreshes

 # Retain settings
@@ -444,11 +432,9 @@ DEFAULT_RETAIN_MAX_COMPLETION_TOKENS = 64000  # Max tokens for fact extraction L
 DEFAULT_RETAIN_CHUNK_SIZE = 3000  # Max chars per chunk for fact extraction
 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", "verbatim", "chunks")  # Allowed extraction modes
+RETAIN_EXTRACTION_MODES = ("concise", "verbose", "custom")  # Allowed extraction modes
 DEFAULT_RETAIN_MISSION = None  # Declarative spec of what to retain (injected into any extraction mode)
 DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS = None  # Custom extraction guidelines (only used when mode="custom")
-DEFAULT_RETAIN_DEFAULT_STRATEGY = None  # Default strategy name (None = no strategy override)
-DEFAULT_RETAIN_STRATEGIES: dict | None = None  # Named retain strategies (dict of name → config overrides)
 DEFAULT_RETAIN_BATCH_TOKENS = 10_000  # ~40KB of text  # Max chars per sub-batch for async retain auto-splitting
 DEFAULT_RETAIN_ENTITY_LOOKUP = "trigram"  # "full" or "trigram"
 DEFAULT_RETAIN_BATCH_ENABLED = False  # Use LLM Batch API for fact extraction (only when async=True)
@@ -677,9 +663,6 @@ class HindsightConfig:
    reranker_local_force_cpu: bool
    reranker_local_max_concurrent: int
    reranker_local_trust_remote_code: bool
-    reranker_local_fp16: bool
-    reranker_local_bucket_batching: bool
-    reranker_local_batch_size: int
    reranker_tei_url: str | None
    reranker_tei_batch_size: int
    reranker_tei_max_concurrent: int
@@ -690,7 +673,6 @@ class HindsightConfig:
    reranker_litellm_api_base: str
    reranker_litellm_api_key: str | None
    reranker_litellm_model: str
-    reranker_litellm_max_tokens_per_doc: int | None
    reranker_litellm_sdk_api_key: str | None
    reranker_litellm_sdk_model: str
    reranker_litellm_sdk_api_base: str | None
@@ -712,7 +694,6 @@ class HindsightConfig:
    mpfp_top_k_neighbors: int
    recall_max_concurrent: int
    recall_connection_budget: int
-    recall_max_query_tokens: int
    mental_model_refresh_concurrency: int

    # Retain settings
@@ -722,8 +703,6 @@ class HindsightConfig:
    retain_extraction_mode: str
    retain_mission: str | None
    retain_custom_instructions: str | None
-    retain_default_strategy: str | None
-    retain_strategies: dict | None
    retain_batch_tokens: int
    retain_batch_enabled: bool
    retain_batch_poll_interval_seconds: int
@@ -854,8 +833,6 @@ class HindsightConfig:
        "retain_extraction_mode",
        "retain_mission",
        "retain_custom_instructions",
-        "retain_default_strategy",
-        "retain_strategies",
        # Entity labels (controlled vocabulary for entity classification)
        "entity_labels",
        "entities_allow_free_form",
@@ -1108,15 +1085,6 @@ class HindsightConfig:
                ENV_RERANKER_LOCAL_TRUST_REMOTE_CODE, str(DEFAULT_RERANKER_LOCAL_TRUST_REMOTE_CODE)
            ).lower()
            in ("true", "1"),
-            reranker_local_fp16=os.getenv(ENV_RERANKER_LOCAL_FP16, str(DEFAULT_RERANKER_LOCAL_FP16)).lower()
-            in ("true", "1"),
-            reranker_local_bucket_batching=os.getenv(
-                ENV_RERANKER_LOCAL_BUCKET_BATCHING, str(DEFAULT_RERANKER_LOCAL_BUCKET_BATCHING)
-            ).lower()
-            in ("true", "1"),
-            reranker_local_batch_size=int(
-                os.getenv(ENV_RERANKER_LOCAL_BATCH_SIZE, str(DEFAULT_RERANKER_LOCAL_BATCH_SIZE))
-            ),
            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(
@@ -1132,9 +1100,6 @@ class HindsightConfig:
            or os.getenv(ENV_LITELLM_API_BASE, DEFAULT_LITELLM_API_BASE),
            reranker_litellm_api_key=os.getenv(ENV_RERANKER_LITELLM_API_KEY) or os.getenv(ENV_LITELLM_API_KEY),
            reranker_litellm_model=os.getenv(ENV_RERANKER_LITELLM_MODEL, DEFAULT_RERANKER_LITELLM_MODEL),
-            reranker_litellm_max_tokens_per_doc=int(v)
-            if (v := os.getenv(ENV_RERANKER_LITELLM_MAX_TOKENS_PER_DOC))
-            else DEFAULT_RERANKER_LITELLM_MAX_TOKENS_PER_DOC,
            # LiteLLM SDK reranker (direct API access)
            reranker_litellm_sdk_api_key=os.getenv(ENV_RERANKER_LITELLM_SDK_API_KEY),
            reranker_litellm_sdk_model=os.getenv(ENV_RERANKER_LITELLM_SDK_MODEL, DEFAULT_RERANKER_LITELLM_SDK_MODEL),
@@ -1161,7 +1126,6 @@ class HindsightConfig:
            recall_connection_budget=int(
                os.getenv(ENV_RECALL_CONNECTION_BUDGET, str(DEFAULT_RECALL_CONNECTION_BUDGET))
            ),
-            recall_max_query_tokens=int(os.getenv(ENV_RECALL_MAX_QUERY_TOKENS, str(DEFAULT_RECALL_MAX_QUERY_TOKENS))),
            mental_model_refresh_concurrency=int(
                os.getenv(ENV_MENTAL_MODEL_REFRESH_CONCURRENCY, str(DEFAULT_MENTAL_MODEL_REFRESH_CONCURRENCY))
            ),
@@ -1182,8 +1146,6 @@ class HindsightConfig:
            ),
            retain_mission=os.getenv(ENV_RETAIN_MISSION) or DEFAULT_RETAIN_MISSION,
            retain_custom_instructions=os.getenv(ENV_RETAIN_CUSTOM_INSTRUCTIONS) or DEFAULT_RETAIN_CUSTOM_INSTRUCTIONS,
-            retain_default_strategy=os.getenv(ENV_RETAIN_DEFAULT_STRATEGY) or DEFAULT_RETAIN_DEFAULT_STRATEGY,
-            retain_strategies=DEFAULT_RETAIN_STRATEGIES,
            retain_batch_tokens=int(os.getenv(ENV_RETAIN_BATCH_TOKENS, str(DEFAULT_RETAIN_BATCH_TOKENS))),
            retain_entity_lookup=os.getenv(ENV_RETAIN_ENTITY_LOOKUP, DEFAULT_RETAIN_ENTITY_LOOKUP),
            retain_batch_enabled=os.getenv(ENV_RETAIN_BATCH_ENABLED, str(DEFAULT_RETAIN_BATCH_ENABLED)).lower()
@@ -10,7 +10,7 @@ multiple API servers.

 import json
 import logging
-from dataclasses import asdict, replace
+from dataclasses import asdict
 from typing import Any

 import asyncpg
@@ -239,14 +239,6 @@ class ConfigResolver:
                logger.warning(f"Failed to check permissions for bank {bank_id}: {e}")
                # Continue without permission check (fail open for backward compatibility)

-        # Validate retain_strategies: reject empty string keys
-        if "retain_strategies" in normalized_updates and normalized_updates["retain_strategies"]:
-            empty_keys = [k for k in normalized_updates["retain_strategies"] if not str(k).strip()]
-            if empty_keys:
-                raise ValueError(
-                    "Strategy names must not be empty strings. Remove entries with empty names before saving."
-                )
-
        # Merge with existing config (JSONB || operator)
        async with self.pool.acquire() as conn:
            await conn.execute(
@@ -281,35 +273,3 @@ class ConfigResolver:
            )

        logger.info(f"Reset bank config for {bank_id} to defaults")
-
-
-def apply_strategy(config: HindsightConfig, strategy_name: str) -> HindsightConfig:
-    """
-    Apply a named retain strategy's overrides on top of a resolved config.
-
-    A strategy is a named set of hierarchical field overrides stored in
-    config.retain_strategies. Any field in _HIERARCHICAL_FIELDS can be
-    overridden, including retain_extraction_mode, retain_chunk_size,
-    entity_labels, entities_allow_free_form, etc.
-
-    Unknown strategy names log a warning and return config unchanged.
-    Unknown or non-hierarchical fields in the strategy are silently ignored.
-    """
-    strategies = config.retain_strategies or {}
-    if strategy_name not in strategies:
-        logger.warning(f"Unknown retain strategy '{strategy_name}', using resolved config as-is")
-        return config
-
-    overrides = strategies[strategy_name]
-    if not isinstance(overrides, dict):
-        logger.warning(f"Retain strategy '{strategy_name}' is not a dict, skipping")
-        return config
-
-    configurable = HindsightConfig.get_configurable_fields()
-    filtered = {k: v for k, v in overrides.items() if k in configurable}
-
-    if not filtered:
-        return config
-
-    logger.debug(f"Applying retain strategy '{strategy_name}': {list(filtered.keys())}")
-    return replace(config, **filtered)
@@ -80,7 +80,6 @@ class _BatchLLMResult:
    deletes: list[_DeleteAction] = field(default_factory=list)
    obs_count: int = 0
    prompt_chars: int = 0
-    failed: bool = False


@dataclass
@@ -162,7 +161,6 @@ async def run_consolidation_job(
    memory_engine: "MemoryEngine",
    bank_id: str,
    request_context: "RequestContext",
-    operation_id: str | None = None,
 ) -> dict[str, Any]:
    """
    Run consolidation job for a bank.
@@ -220,7 +218,6 @@ async def run_consolidation_job(
            FROM {fq_table("memory_units")}
            WHERE bank_id = $1
              AND consolidated_at IS NULL
-              AND consolidation_failed_at IS NULL
              AND fact_type IN ('experience', 'world')
            """,
            bank_id,
@@ -242,7 +239,6 @@ async def run_consolidation_job(
        "observations_deleted": 0,
        "actions_executed": 0,
        "skipped": 0,
-        "memories_failed": 0,
    }

    # Track all unique tags from consolidated memories for mental model refresh filtering
@@ -260,7 +256,6 @@ async def run_consolidation_job(
                FROM {fq_table("memory_units")}
                WHERE bank_id = $1
                  AND consolidated_at IS NULL
-                  AND consolidation_failed_at IS NULL
                  AND fact_type IN ('experience', 'world')
                ORDER BY created_at ASC
                LIMIT $2
@@ -302,148 +297,94 @@ async def run_consolidation_job(
                if memory_tags:
                    consolidated_tags.update(memory_tags)

-            # Process llm_batch with adaptive splitting: on LLM failure, halve the sub-batch
-            # and retry, down to batch_size=1. Only if a single-memory batch still fails is
-            # the memory marked with consolidation_failed_at and excluded from future runs
-            # until explicitly retried via the API.
-            all_results: list[dict[str, Any]] = []
-            all_deleted = 0
-            succeeded_ids: list[Any] = []
-            failed_ids: list[Any] = []
+            async with pool.acquire() as conn:
+                # Determine observation_scopes for this batch. All memories in a batch share
+                # the same tags (enforced by tag_groups), so we only check the first memory.
+                # asyncpg returns JSONB columns as raw JSON strings, so parse if needed.
+                _obs_raw = llm_batch[0].get("observation_scopes") if llm_batch else None
+                _obs_parsed = json.loads(_obs_raw) if isinstance(_obs_raw, str) else _obs_raw

-            pending: list[list[dict[str, Any]]] = [llm_batch]
-            while pending:
-                sub_batch = pending.pop(0)
+                # Resolve the scope spec into a concrete list[list[str]] (or None for combined).
+                if _obs_parsed == "per_tag":
+                    _memory_tags = llm_batch[0].get("tags") or []
+                    obs_tags_list = [[tag] for tag in _memory_tags] if _memory_tags else None
+                elif _obs_parsed == "all_combinations":
+                    _memory_tags = llm_batch[0].get("tags") or []
+                    obs_tags_list = (
+                        [
+                            list(combo)
+                            for r in range(1, len(_memory_tags) + 1)
+                            for combo in combinations(_memory_tags, r)
+                        ]
+                        if _memory_tags
+                        else None
+                    )
+                elif _obs_parsed == "combined" or _obs_parsed is None:
+                    obs_tags_list = None  # single combined pass (default behaviour)
+                else:
+                    # explicit list[list[str]]
+                    obs_tags_list = _obs_parsed

-                async with pool.acquire() as conn:
-                    # Determine observation_scopes for this sub-batch. All memories share
-                    # the same tags (enforced by tag_groups), so we only check the first memory.
-                    # asyncpg returns JSONB columns as raw JSON strings, so parse if needed.
-                    _obs_raw = sub_batch[0].get("observation_scopes") if sub_batch else None
-                    _obs_parsed = json.loads(_obs_raw) if isinstance(_obs_raw, str) else _obs_raw
-
-                    # Resolve the scope spec into a concrete list[list[str]] (or None for combined).
-                    if _obs_parsed == "per_tag":
-                        _memory_tags = sub_batch[0].get("tags") or []
-                        obs_tags_list = [[tag] for tag in _memory_tags] if _memory_tags else None
-                    elif _obs_parsed == "all_combinations":
-                        _memory_tags = sub_batch[0].get("tags") or []
-                        obs_tags_list = (
-                            [
-                                list(combo)
-                                for r in range(1, len(_memory_tags) + 1)
-                                for combo in combinations(_memory_tags, r)
-                            ]
-                            if _memory_tags
-                            else None
-                        )
-                    elif _obs_parsed == "combined" or _obs_parsed is None:
-                        obs_tags_list = None  # single combined pass (default behaviour)
-                    else:
-                        # explicit list[list[str]]
-                        obs_tags_list = _obs_parsed
-
-                    sub_deleted: int = 0
-                    sub_llm_failed = False
-                    if obs_tags_list:
-                        # Multi-pass: run one observation consolidation pass per tag set
-                        sub_results: list[dict[str, Any]] = []
-                        for obs_tags in obs_tags_list:
-                            pass_results, pass_deleted, pass_failed = await _process_memory_batch(
-                                conn=conn,
-                                memory_engine=memory_engine,
-                                llm_config=llm_config,
-                                bank_id=bank_id,
-                                memories=sub_batch,
-                                request_context=request_context,
-                                perf=perf,
-                                config=config,
-                                obs_tags_override=obs_tags,
-                            )
-                            sub_deleted += pass_deleted
-                            sub_llm_failed = sub_llm_failed or pass_failed
-                            # Merge results: prefer non-skipped actions
-                            if not sub_results:
-                                sub_results = pass_results
-                            else:
-                                for i, (existing, new) in enumerate(zip(sub_results, pass_results)):
-                                    if existing.get("action") == "skipped" and new.get("action") != "skipped":
-                                        sub_results[i] = new
-                                    elif existing.get("action") != "skipped" and new.get("action") != "skipped":
-                                        # Both did something — combine into "multiple"
-                                        existing_created = existing.get(
-                                            "created", 1 if existing.get("action") == "created" else 0
-                                        )
-                                        existing_updated = existing.get(
-                                            "updated", 1 if existing.get("action") == "updated" else 0
-                                        )
-                                        new_created = new.get("created", 1 if new.get("action") == "created" else 0)
-                                        new_updated = new.get("updated", 1 if new.get("action") == "updated" else 0)
-                                        total = existing_created + existing_updated + new_created + new_updated
-                                        sub_results[i] = {
-                                            "action": "multiple",
-                                            "created": existing_created + new_created,
-                                            "updated": existing_updated + new_updated,
-                                            "merged": 0,
-                                            "total_actions": total,
-                                        }
-                    else:
-                        # Normal single pass using the memory's own tags
-                        sub_results, sub_deleted, sub_llm_failed = await _process_memory_batch(
+                batch_deleted: int = 0
+                if obs_tags_list:
+                    # Multi-pass: run one observation consolidation pass per tag set
+                    results = []
+                    for obs_tags in obs_tags_list:
+                        pass_results, pass_deleted = await _process_memory_batch(
                            conn=conn,
                            memory_engine=memory_engine,
                            llm_config=llm_config,
                            bank_id=bank_id,
-                            memories=sub_batch,
+                            memories=llm_batch,
                            request_context=request_context,
                            perf=perf,
                            config=config,
+                            obs_tags_override=obs_tags,
                        )
-
-                all_deleted += sub_deleted
-
-                if sub_llm_failed and len(sub_batch) > 1:
-                    # Split and retry with smaller batches
-                    mid = len(sub_batch) // 2
-                    logger.warning(
-                        f"[CONSOLIDATION] bank={bank_id} LLM failed for sub-batch of {len(sub_batch)},"
-                        f" splitting into {mid}/{len(sub_batch) - mid}"
-                    )
-                    pending[0:0] = [sub_batch[:mid], sub_batch[mid:]]
-                elif sub_llm_failed:
-                    # batch_size=1 and still failing — mark as permanently failed for now
-                    failed_ids.append(sub_batch[0]["id"])
-                    all_results.append({"action": "failed"})
-                    logger.warning(
-                        f"[CONSOLIDATION] bank={bank_id} LLM failed for single memory"
-                        f" {sub_batch[0]['id']}, marking consolidation_failed_at"
-                    )
+                        batch_deleted += pass_deleted
+                        # Merge results: prefer non-skipped actions
+                        if not results:
+                            results = pass_results
+                        else:
+                            for i, (existing, new) in enumerate(zip(results, pass_results)):
+                                if existing.get("action") == "skipped" and new.get("action") != "skipped":
+                                    results[i] = new
+                                elif existing.get("action") != "skipped" and new.get("action") != "skipped":
+                                    # Both did something — combine into "multiple"
+                                    existing_created = existing.get(
+                                        "created", 1 if existing.get("action") == "created" else 0
+                                    )
+                                    existing_updated = existing.get(
+                                        "updated", 1 if existing.get("action") == "updated" else 0
+                                    )
+                                    new_created = new.get("created", 1 if new.get("action") == "created" else 0)
+                                    new_updated = new.get("updated", 1 if new.get("action") == "updated" else 0)
+                                    total = existing_created + existing_updated + new_created + new_updated
+                                    results[i] = {
+                                        "action": "multiple",
+                                        "created": existing_created + new_created,
+                                        "updated": existing_updated + new_updated,
+                                        "merged": 0,
+                                        "total_actions": total,
+                                    }
                else:
-                    succeeded_ids.extend(m["id"] for m in sub_batch)
-                    all_results.extend(sub_results)
-
-            # Commit consolidated_at / consolidation_failed_at in a single DB round-trip
-            async with pool.acquire() as conn:
-                if succeeded_ids:
-                    await conn.executemany(
-                        f"UPDATE {fq_table('memory_units')} SET consolidated_at = NOW() WHERE id = $1",
-                        [(mem_id,) for mem_id in succeeded_ids],
-                    )
-                if failed_ids:
-                    await conn.executemany(
-                        f"UPDATE {fq_table('memory_units')} SET consolidation_failed_at = NOW() WHERE id = $1",
-                        [(mem_id,) for mem_id in failed_ids],
+                    # Normal single pass using the memory's own tags
+                    results, batch_deleted = await _process_memory_batch(
+                        conn=conn,
+                        memory_engine=memory_engine,
+                        llm_config=llm_config,
+                        bank_id=bank_id,
+                        memories=llm_batch,
+                        request_context=request_context,
+                        perf=perf,
+                        config=config,
                    )
+                stats["observations_deleted"] += batch_deleted

-            stats["observations_deleted"] += all_deleted
-            results = all_results
-
-            # Checkpoint: abort if the operation (and thus the bank) was deleted mid-run.
-            if operation_id and not await memory_engine._check_op_alive(operation_id):
-                logger.info(
-                    f"[CONSOLIDATION] bank={bank_id} operation {operation_id} cancelled (bank deleted), stopping early"
+                await conn.executemany(
+                    f"UPDATE {fq_table('memory_units')} SET consolidated_at = NOW() WHERE id = $1",
+                    [(m["id"],) for m in llm_batch],
                )
-                return {"status": "cancelled", "bank_id": bank_id, **stats}

            for result in results:
                stats["memories_processed"] += 1
@@ -464,8 +405,6 @@ async def run_consolidation_job(
                    stats["actions_executed"] += result.get("total_actions", 0)
                elif action == "skipped":
                    stats["skipped"] += 1
-                elif action == "failed":
-                    stats["memories_failed"] += 1

            # Per-LLM-batch log
            llm_batch_time = time.time() - llm_batch_start
@@ -478,7 +417,6 @@ async def run_consolidation_job(
            batch_created = stats["observations_created"] - snap_stats["observations_created"]
            batch_updated = stats["observations_updated"] - snap_stats["observations_updated"]
            batch_skipped = stats["skipped"] - snap_stats["skipped"]
-            batch_failed = stats["memories_failed"] - snap_stats["memories_failed"]
            llm_calls_made = perf.llm_calls - snap_llm_calls
            logger.info(
                f"[CONSOLIDATION] bank={bank_id} llm_batch #{llm_batch_num}"
@@ -486,8 +424,7 @@ async def run_consolidation_job(
                f" | {stats['memories_processed']}/{total_count} processed"
                f" | {', '.join(timing_parts)}"
                f" | created={batch_created} updated={batch_updated} skipped={batch_skipped}"
-                + (f" failed={batch_failed}" if batch_failed else "")
-                + f" | input_tokens=~{input_tokens}"
+                f" | input_tokens=~{input_tokens}"
                f" | avg={llm_batch_time / len(llm_batch):.3f}s/memory"
            )

@@ -639,7 +576,7 @@ async def _process_memory_batch(
    perf: ConsolidationPerfLog | None = None,
    config: Any = None,
    obs_tags_override: list[str] | None = None,
-) -> tuple[list[dict[str, Any]], int, bool]:
+) -> tuple[list[dict[str, Any]], int]:
    """
    Process a batch of memories in a single LLM call.

@@ -802,7 +739,7 @@ async def _process_memory_batch(
        else:
            results.append({"action": "skipped", "reason": "no_durable_knowledge"})

-    return results, deleted_count, llm_result.failed
+    return results, deleted_count


 def _min_date(dates: "Any") -> "datetime | None":
@@ -1136,7 +1073,7 @@ async def _consolidate_batch_with_llm(
    logger.error(
        f"[CONSOLIDATION] LLM batch call failed after {max_attempts} attempts, skipping batch. Last error: {last_exc}"
    )
-    return _BatchLLMResult(obs_count=len(union_observations), prompt_chars=len(prompt), failed=True)
+    return _BatchLLMResult(obs_count=len(union_observations), prompt_chars=len(prompt))


 async def _create_observation_directly(
@@ -20,10 +20,8 @@ from ..config import (
    DEFAULT_RERANKER_COHERE_MODEL,
    DEFAULT_RERANKER_FLASHRANK_CACHE_DIR,
    DEFAULT_RERANKER_FLASHRANK_MODEL,
-    DEFAULT_RERANKER_LITELLM_MAX_TOKENS_PER_DOC,
    DEFAULT_RERANKER_LITELLM_MODEL,
    DEFAULT_RERANKER_LITELLM_SDK_MODEL,
-    DEFAULT_RERANKER_LOCAL_BATCH_SIZE,
    DEFAULT_RERANKER_LOCAL_FORCE_CPU,
    DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT,
    DEFAULT_RERANKER_LOCAL_MODEL,
@@ -112,9 +110,6 @@ class LocalSTCrossEncoder(CrossEncoderModel):
        max_concurrent: int = 4,
        force_cpu: bool = False,
        trust_remote_code: bool = False,
-        fp16: bool = False,
-        bucket_batching: bool = False,
-        batch_size: int = DEFAULT_RERANKER_LOCAL_BATCH_SIZE,
    ):
        """
        Initialize local SentenceTransformers cross-encoder.
@@ -129,20 +124,10 @@ class LocalSTCrossEncoder(CrossEncoderModel):
            trust_remote_code: Allow loading models with custom code (security risk).
                              Required for some models like jina-reranker-v2-base-multilingual.
                              Default: False (disabled for security)
-            fp16: Use FP16 (half precision) inference. Faster on MPS and CUDA,
-                  may be slower on CPU. Default: False (opt-in via env var).
-            bucket_batching: Sort pairs by token length before batching to reduce
-                            padding waste. 36-54% speedup, quality-identical.
-                            Default: False (opt-in via env var).
-            batch_size: Batch size for predict() calls. Optimal values vary by
-                       hardware and model (MPS: 32, CUDA: 128+). Default: 32.
        """
        self.model_name = model_name or DEFAULT_RERANKER_LOCAL_MODEL
        self.force_cpu = force_cpu
        self.trust_remote_code = trust_remote_code
-        self.fp16 = fp16
-        self.bucket_batching = bucket_batching
-        self.batch_size = batch_size
        self._model = None
        LocalSTCrossEncoder._max_concurrent = max_concurrent

@@ -190,24 +175,6 @@ class LocalSTCrossEncoder(CrossEncoderModel):
            except Exception as e:
                logger.warning(f"Failed to detect GPU/MPS, falling back to CPU: {e}")

-        # Patch transformers 5.x compatibility for models using XLM-RoBERTa
-        # (e.g., jina-reranker-v2-base-multilingual). transformers 5.x removed
-        # create_position_ids_from_input_ids as a module-level function; the custom
-        # code in these models still references it. This monkey-patch restores it.
-        try:
-            import transformers.models.xlm_roberta.modeling_xlm_roberta as xlm_module
-            from transformers.models.xlm_roberta.modeling_xlm_roberta import XLMRobertaEmbeddings
-
-            if not hasattr(xlm_module, "create_position_ids_from_input_ids"):
-                setattr(
-                    xlm_module,
-                    "create_position_ids_from_input_ids",
-                    XLMRobertaEmbeddings.create_position_ids_from_input_ids,
-                )
-                logger.info("Reranker: applied transformers 5.x compatibility patch for XLM-RoBERTa")
-        except Exception:
-            pass
-
        # 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")
@@ -232,12 +199,6 @@ class LocalSTCrossEncoder(CrossEncoderModel):
                # Restore original logging level
                transformers_logger.setLevel(original_level)

-        # FP16 inference: convert model weights to half precision.
-        # Empirically validated: 27-36% faster on MPS, quality-identical (20/20 overlap).
-        if self.fp16 and device != "cpu":
-            self._model.model.half()
-            logger.info("Reranker: FP16 inference enabled")
-
        # Initialize shared executor (limited workers naturally limits concurrency)
        if LocalSTCrossEncoder._executor is None:
            LocalSTCrossEncoder._executor = ThreadPoolExecutor(
@@ -249,32 +210,8 @@ class LocalSTCrossEncoder(CrossEncoderModel):
            logger.info("Reranker: local provider initialized (using existing executor)")

    def _predict_sync(self, pairs: list[tuple[str, str]]) -> list[float]:
-        """Synchronous prediction wrapper for thread pool execution.
-
-        Supports two optimizations (controlled via .env):
-        - bucket_batching: sort pairs by token length to reduce padding waste (36-54% speedup)
-        - batch_size: explicit batch size for predict() calls (MPS optimal: 32)
-        """
-        import numpy as np
-
-        if self.bucket_batching and len(pairs) > 1:
-            # Sort pairs by approximate token length to create homogeneous batches.
-            # This eliminates padding waste — short pairs aren't padded to the length
-            # of the longest pair in the batch. Quality-identical by construction.
-            lengths = [len(pairs[i][0]) + len(pairs[i][1]) for i in range(len(pairs))]
-            sorted_indices = sorted(range(len(pairs)), key=lambda i: lengths[i])
-            sorted_pairs = [pairs[i] for i in sorted_indices]
-
-            sorted_scores = self._model.predict(sorted_pairs, batch_size=self.batch_size, show_progress_bar=False)
-            sorted_scores = sorted_scores.tolist() if hasattr(sorted_scores, "tolist") else list(sorted_scores)
-
-            # Restore original order
-            scores = [0.0] * len(pairs)
-            for new_pos, orig_idx in enumerate(sorted_indices):
-                scores[orig_idx] = sorted_scores[new_pos]
-            return scores
-
-        scores = self._model.predict(pairs, batch_size=self.batch_size, show_progress_bar=False)
+        """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]:
@@ -883,17 +820,6 @@ class FlashRankCrossEncoder(CrossEncoderModel):
        return await loop.run_in_executor(FlashRankCrossEncoder._executor, self._predict_sync, pairs)


-def _truncate_to_tokens(text: str, max_tokens: int) -> str:
-    """Truncate text to at most max_tokens using the shared tiktoken encoder."""
-    from .memory_engine import _get_tiktoken_encoding
-
-    enc = _get_tiktoken_encoding()
-    tokens = enc.encode(text)
-    if len(tokens) <= max_tokens:
-        return text
-    return enc.decode(tokens[:max_tokens])
-
-
 class LiteLLMCrossEncoder(CrossEncoderModel):
    """
    LiteLLM cross-encoder implementation using LiteLLM proxy's /rerank endpoint.
@@ -917,7 +843,6 @@ class LiteLLMCrossEncoder(CrossEncoderModel):
        api_key: str | None = None,
        model: str = DEFAULT_RERANKER_LITELLM_MODEL,
        timeout: float = 60.0,
-        max_tokens_per_doc: int | None = DEFAULT_RERANKER_LITELLM_MAX_TOKENS_PER_DOC,
    ):
        """
        Initialize LiteLLM cross-encoder client.
@@ -928,15 +853,11 @@ class LiteLLMCrossEncoder(CrossEncoderModel):
            model: Reranking model name (default: cohere/rerank-english-v3.0)
                   Use provider prefix (e.g., cohere/, together_ai/, voyage/)
            timeout: Request timeout in seconds (default: 60.0)
-            max_tokens_per_doc: If set, truncate each document to this many tokens before
-                                sending to the reranker (uses tiktoken cl100k_base encoding).
-                                Useful for models with small context windows (e.g. 1024 tokens).
        """
        self.api_base = api_base.rstrip("/")
        self.api_key = api_key
        self.model = model
        self.timeout = timeout
-        self.max_tokens_per_doc = max_tokens_per_doc
        self._async_client: httpx.AsyncClient | None = None

    @property
@@ -984,8 +905,6 @@ class LiteLLMCrossEncoder(CrossEncoderModel):

        for query, indexed_texts in query_groups.items():
            texts = [text for _, text in indexed_texts]
-            if self.max_tokens_per_doc is not None:
-                texts = [_truncate_to_tokens(t, self.max_tokens_per_doc) for t in texts]
            indices = [idx for idx, _ in indexed_texts]

            # LiteLLM /rerank follows Cohere API format
@@ -1031,7 +950,6 @@ class LiteLLMSDKCrossEncoder(CrossEncoderModel):
        model: str = DEFAULT_RERANKER_LITELLM_SDK_MODEL,
        api_base: str | None = None,
        timeout: float = 60.0,
-        max_tokens_per_doc: int | None = DEFAULT_RERANKER_LITELLM_MAX_TOKENS_PER_DOC,
    ):
        """
        Initialize LiteLLM SDK cross-encoder client.
@@ -1041,15 +959,11 @@ class LiteLLMSDKCrossEncoder(CrossEncoderModel):
            model: Model name with provider prefix (e.g., "deepinfra/Qwen3-reranker-8B")
            api_base: Custom base URL for API (optional)
            timeout: Request timeout in seconds (default: 60.0)
-            max_tokens_per_doc: If set, truncate each document to this many tokens before
-                                sending to the reranker (uses tiktoken cl100k_base encoding).
-                                Useful for models with small context windows (e.g. 1024 tokens).
        """
        self.api_key = api_key
        self.model = model
        self.api_base = api_base
        self.timeout = timeout
-        self.max_tokens_per_doc = max_tokens_per_doc
        self._initialized = False
        self._litellm = None  # Will be set during initialization

@@ -1103,8 +1017,6 @@ class LiteLLMSDKCrossEncoder(CrossEncoderModel):

        for query, indexed_texts in query_groups.items():
            texts = [text for _, text in indexed_texts]
-            if self.max_tokens_per_doc is not None:
-                texts = [_truncate_to_tokens(t, self.max_tokens_per_doc) for t in texts]
            indices = [idx for idx, _ in indexed_texts]

            # Build kwargs for rerank call
@@ -1138,97 +1050,6 @@ class LiteLLMSDKCrossEncoder(CrossEncoderModel):
        return all_scores


-class JinaMLXCrossEncoder(CrossEncoderModel):
-    """
-    Jina Reranker v3 MLX implementation for Apple Silicon.
-
-    Uses jinaai/jina-reranker-v3-mlx — a 0.6B parameter multilingual listwise reranker
-    optimized for Apple Silicon via the MLX framework. No transformers/PyTorch dependency.
-
-    The model is downloaded automatically from HuggingFace Hub on first use.
-    Requires: mlx>=0.31.0, mlx-lm>=0.31.1, safetensors>=0.6.2
-    """
-
-    HF_REPO_ID = "jinaai/jina-reranker-v3-mlx"
-
-    def __init__(self, model_path: str | None = None):
-        """
-        Args:
-            model_path: Local path to the downloaded model directory.
-                        If None, the model is downloaded from HuggingFace Hub.
-        """
-        self.model_path = model_path
-        self._reranker = None
-
-    @property
-    def provider_name(self) -> str:
-        return "jina-mlx"
-
-    async def initialize(self) -> None:
-        if self._reranker is not None:
-            return
-
-        try:
-            import mlx.core  # noqa: F401
-            import mlx_lm  # noqa: F401
-        except ImportError:
-            raise ImportError(
-                "mlx and mlx-lm are required for JinaMLXCrossEncoder. "
-                "Install with: pip install mlx>=0.31.0 mlx-lm>=0.31.1 safetensors>=0.6.2"
-            )
-
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, self._load_model)
-
-    def _load_model(self) -> None:
-        """Download (if needed) and load the MLX reranker. Runs in a thread."""
-        import os
-
-        from huggingface_hub import snapshot_download
-
-        from .jina_mlx_reranker import MLXReranker
-
-        model_path = self.model_path
-        if model_path is None:
-            logger.info(f"Reranker: downloading {self.HF_REPO_ID} from HuggingFace Hub...")
-            model_path = snapshot_download(repo_id=self.HF_REPO_ID)
-
-        logger.info(f"Reranker: loading jina-reranker-v3-mlx from {model_path}")
-        self._reranker = MLXReranker(
-            model_path=model_path,
-            projector_path=os.path.join(model_path, "projector.safetensors"),
-        )
-        logger.info("Reranker: jina-mlx provider initialized")
-
-    def _predict_sync(self, pairs: list[tuple[str, str]]) -> list[float]:
-        """Score pairs grouped by query. Runs in a thread."""
-        if not pairs:
-            return []
-
-        query_groups: dict[str, list[tuple[int, str]]] = {}
-        for idx, (query, doc) in enumerate(pairs):
-            query_groups.setdefault(query, []).append((idx, doc))
-
-        all_scores = [0.0] * len(pairs)
-
-        for query, indexed_docs in query_groups.items():
-            docs = [doc for _, doc in indexed_docs]
-            indices = [idx for idx, _ in indexed_docs]
-            results = self._reranker.rerank(query, docs)
-            for result in results:
-                original_idx = result["index"]
-                all_scores[indices[original_idx]] = result["relevance_score"]
-
-        return all_scores
-
-    async def predict(self, pairs: list[tuple[str, str]]) -> list[float]:
-        if self._reranker is None:
-            raise RuntimeError("Reranker not initialized. Call initialize() first.")
-
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._predict_sync, pairs)
-
-
 def create_cross_encoder_from_env() -> CrossEncoderModel:
    """
    Create a CrossEncoderModel instance based on configuration.
@@ -1258,9 +1079,6 @@ def create_cross_encoder_from_env() -> CrossEncoderModel:
            max_concurrent=config.reranker_local_max_concurrent,
            force_cpu=config.reranker_local_force_cpu,
            trust_remote_code=config.reranker_local_trust_remote_code,
-            fp16=config.reranker_local_fp16,
-            bucket_batching=config.reranker_local_bucket_batching,
-            batch_size=config.reranker_local_batch_size,
        )
    elif provider == "cohere":
        api_key = config.reranker_cohere_api_key
@@ -1280,7 +1098,6 @@ def create_cross_encoder_from_env() -> CrossEncoderModel:
            api_base=config.reranker_litellm_api_base,
            api_key=config.reranker_litellm_api_key,
            model=config.reranker_litellm_model,
-            max_tokens_per_doc=config.reranker_litellm_max_tokens_per_doc,
        )
    elif provider == "litellm-sdk":
        api_key = config.reranker_litellm_sdk_api_key
@@ -1292,7 +1109,6 @@ def create_cross_encoder_from_env() -> CrossEncoderModel:
            api_key=api_key,
            model=config.reranker_litellm_sdk_model,
            api_base=config.reranker_litellm_sdk_api_base,
-            max_tokens_per_doc=config.reranker_litellm_max_tokens_per_doc,
        )
    elif provider == "zeroentropy":
        api_key = config.reranker_zeroentropy_api_key
@@ -1306,9 +1122,7 @@ def create_cross_encoder_from_env() -> CrossEncoderModel:
        )
    elif provider == "rrf":
        return RRFPassthroughCrossEncoder()
-    elif provider == "jina-mlx":
-        return JinaMLXCrossEncoder()
    else:
        raise ValueError(
-            f"Unknown reranker provider: {provider}. Supported: 'local', 'tei', 'cohere', 'zeroentropy', 'flashrank', 'litellm', 'litellm-sdk', 'rrf', 'jina-mlx'"
+            f"Unknown reranker provider: {provider}. Supported: 'local', 'tei', 'cohere', 'zeroentropy', 'flashrank', 'litellm', 'litellm-sdk', 'rrf'"
        )
@@ -477,42 +477,19 @@ class EntityResolver:
            id_by_name: dict[str, str] = {row["name_lower"]: row["id"] for row in inserted_rows}

            # Fallback SELECT for names that conflicted (another worker won the race).
-            #
-            # IMPORTANT: we must let PostgreSQL do the lowercasing on BOTH sides of the
-            # comparison.  Python's str.lower() and PostgreSQL's LOWER() differ for some
-            # Unicode characters — most notably Turkish İ (U+0130):
-            #   Python:     'İstanbul'.lower()  == 'i\u0307stanbul'  (i + combining dot, 2 chars)
-            #   PostgreSQL: LOWER('İstanbul')   == 'istanbul'         (plain i, 1 char)
-            # Passing a Python-lowercased name to "LOWER(canonical_name) = ANY($2::text[])"
-            # would fail to match the stored entity, leaving entity_id as None and causing
-            # a NOT NULL constraint violation on unit_entities.entity_id.
-            #
-            # Fix: pass the original (mixed-case) input names and use
-            # "LOWER(canonical_name) = ANY(SELECT LOWER(n) FROM unnest($2) AS n)" so
-            # PostgreSQL lowercases both sides identically.  The query also returns the
-            # original input_name so we can index id_by_name by Python's lower() of that
-            # name, which is what the assignment loop below uses as its lookup key.
-            missing_original = [g.name for name_lower, g in sorted_groups if name_lower not in id_by_name]
-            if missing_original:
+            missing = [n for n, _ in sorted_groups if n not in id_by_name]
+            if missing:
                existing_rows = await conn.fetch(
                    f"""
-                    SELECT e.id, LOWER(e.canonical_name) AS name_lower, inputs.input_name
-                    FROM {fq_table("entities")} e
-                    JOIN (
-                        SELECT LOWER(n) AS input_name_lower, n AS input_name
-                        FROM unnest($2::text[]) AS n
-                    ) AS inputs ON LOWER(e.canonical_name) = inputs.input_name_lower
-                    WHERE e.bank_id = $1
+                    SELECT id, LOWER(canonical_name) AS name_lower
+                    FROM {fq_table("entities")}
+                    WHERE bank_id = $1 AND LOWER(canonical_name) = ANY($2::text[])
                    """,
                    bank_id,
-                    missing_original,
+                    missing,
                )
                for row in existing_rows:
                    id_by_name[row["name_lower"]] = row["id"]
-                    # Also index by Python's lower() of the original input name so the
-                    # assignment loop (which uses Python-lowercased keys) finds it even
-                    # when Python and PostgreSQL produce different lowercase strings.
-                    id_by_name[row["input_name"].lower()] = row["id"]

            # Assign entity IDs back and queue one stat per original mention so that
            # flush_pending_stats() increments mention_count by the true mention count,
@@ -227,7 +227,7 @@ def create_llm_provider(
            reasoning_effort=reasoning_effort,
        )

-    elif provider_lower in ("openai", "groq", "ollama", "lmstudio", "minimax"):
+    elif provider_lower in ("openai", "groq", "ollama", "lmstudio"):
        return OpenAICompatibleLLM(
            provider=provider,
            api_key=api_key,
@@ -296,7 +296,6 @@ class LLMProvider:
            "openai-codex",
            "claude-code",
            "mock",
-            "minimax",
        ]
        if self.provider not in valid_providers:
            raise ValueError(f"Invalid LLM provider: {self.provider}. Must be one of: {', '.join(valid_providers)}")
@@ -309,8 +308,6 @@ class LLMProvider:
                self.base_url = "http://localhost:11434/v1"
            elif self.provider == "lmstudio":
                self.base_url = "http://localhost:1234/v1"
-            elif self.provider == "minimax":
-                self.base_url = "https://api.minimax.io/v1"

        # Prepare Vertex AI config (if applicable)
        vertexai_project_id = None
@@ -633,7 +630,7 @@ class LLMProvider:
            # Reduce Claude Agent SDK logging verbosity
            import logging as sdk_logging

-            from claude_agent_sdk import query  # noqa: F401  # type: ignore[unresolved-import]
+            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)
@@ -51,9 +51,13 @@ def get_current_schema() -> str:
    return schema


+# Initialize tiktoken encoder once at module level for efficiency
+_tiktoken_encoder = tiktoken.get_encoding("cl100k_base")  # GPT-4/GPT-3.5-turbo encoding
+
+
 def count_tokens(text: str) -> int:
    """Count tokens in text using tiktoken (cl100k_base encoding for GPT-4/3.5)."""
-    return len(_get_tiktoken_encoding().encode(text))
+    return len(_tiktoken_encoder.encode(text))


 def fq_table(table_name: str) -> str:
@@ -184,7 +188,7 @@ from .retain import bank_utils, embedding_utils
 from .retain.types import RetainContentDict
 from .search import think_utils
 from .search.reranking import CrossEncoderReranker, apply_combined_scoring
-from .search.tags import TagGroup, TagsMatch, build_tags_where_clause
+from .search.tags import TagsMatch, build_tags_where_clause
 from .task_backend import BrokerTaskBackend, SyncTaskBackend, TaskBackend


@@ -204,6 +208,8 @@ def utcnow():
 # Logger for memory system
 logger = logging.getLogger(__name__)

+import tiktoken
+
 from .db_utils import acquire_with_retry

 # Cache tiktoken encoding for token budget filtering (module-level singleton)
@@ -561,7 +567,6 @@ class MemoryEngine(MemoryEngineInterface):
        contents = task_dict.get("contents", [])
        document_tags = task_dict.get("document_tags")
        operation_id = task_dict.get("operation_id")  # For batch API crash recovery
-        strategy = task_dict.get("strategy")

        logger.info(
            f"[BATCH_RETAIN_TASK] Starting background batch retain for bank_id={bank_id}, {len(contents)} items, operation_id={operation_id}"
@@ -585,7 +590,6 @@ class MemoryEngine(MemoryEngineInterface):
            document_tags=document_tags,
            request_context=context,
            operation_id=operation_id,
-            strategy=strategy,
            outbox_callback=self._build_retain_outbox_callback(
                bank_id=bank_id,
                contents=contents,
@@ -714,8 +718,6 @@ class MemoryEngine(MemoryEngineInterface):
        retain_task_payload: dict[str, Any] = {"contents": retain_contents}
        if document_tags:
            retain_task_payload["document_tags"] = document_tags
-        if task_dict.get("strategy"):
-            retain_task_payload["strategy"] = task_dict["strategy"]

        # Pass tenant/api_key context through to retain task
        if task_dict.get("_tenant_id"):
@@ -818,7 +820,6 @@ class MemoryEngine(MemoryEngineInterface):
            memory_engine=self,
            bank_id=bank_id,
            request_context=internal_context,
-            operation_id=task_dict.get("operation_id"),
        )

        logger.info(f"[CONSOLIDATION] bank={bank_id} completed: {result.get('memories_processed', 0)} processed")
@@ -868,23 +869,14 @@ class MemoryEngine(MemoryEngineInterface):
        tags = mental_model.get("tags")
        tags_match = "all_strict" if tags else "any"

-        # Read reflect options from trigger (if stored)
-        trigger_data = mental_model.get("trigger") or {}
-        fact_types = trigger_data.get("fact_types")
-        exclude_mental_models = trigger_data.get("exclude_mental_models", False)
-        stored_exclude_ids: list[str] = trigger_data.get("exclude_mental_model_ids") or []
-
        # Run reflect to generate new content, excluding the mental model being refreshed
-        # Always add self to excluded IDs to prevent circular reference
        reflect_result = await self.reflect_async(
            bank_id=bank_id,
            query=source_query,
            request_context=internal_context,
            tags=tags,
            tags_match=tags_match,
-            fact_types=fact_types,
-            exclude_mental_models=exclude_mental_models,
-            exclude_mental_model_ids=list({*stored_exclude_ids, mental_model_id}),
+            exclude_mental_model_ids=[mental_model_id],
        )

        generated_content = reflect_result.text or "No content generated"
@@ -1257,24 +1249,6 @@ class MemoryEngine(MemoryEngineInterface):
        except Exception as e:
            logger.error(f"Failed to delete async operation record {operation_id}: {e}")

-    async def _check_op_alive(self, operation_id: str) -> bool:
-        """Return False if the operation row no longer exists (e.g. bank was deleted via CASCADE).
-
-        Long-running operations should call this at natural checkpoints (e.g. after each
-        committed batch) to detect bank deletion early and abort cleanly.
-        """
-        try:
-            pool = await self._get_pool()
-            async with acquire_with_retry(pool) as conn:
-                row = await conn.fetchrow(
-                    f"SELECT operation_id FROM {fq_table('async_operations')} WHERE operation_id = $1",
-                    uuid.UUID(operation_id),
-                )
-                return row is not None
-        except Exception as e:
-            logger.error(f"Failed to check operation liveness {operation_id}: {e}")
-            return True  # Assume alive on DB error to avoid false-positive aborts
-
    async def _mark_operation_failed(self, operation_id: str, error_message: str, error_traceback: str):
        """Helper to mark an operation as failed in the database.

@@ -1290,19 +1264,15 @@ class MemoryEngine(MemoryEngineInterface):
            async with acquire_with_retry(pool) as conn:
                async with conn.transaction():
                    # Mark this operation as failed
-                    row = await conn.fetchrow(
+                    await conn.execute(
                        f"""
                        UPDATE {fq_table("async_operations")}
                        SET status = 'failed', error_message = $2, updated_at = NOW()
                        WHERE operation_id = $1
-                        RETURNING operation_id
                        """,
                        uuid.UUID(operation_id),
                        truncated_error,
                    )
-                    if row is None:
-                        logger.info(f"Operation {operation_id} no longer exists (bank deleted), skipping mark-failed")
-                        return
                    logger.info(f"Marked async operation as failed: {operation_id}")

                    # Check if this is a child operation and update parent if all siblings are done
@@ -1322,20 +1292,14 @@ class MemoryEngine(MemoryEngineInterface):
            async with acquire_with_retry(pool) as conn:
                async with conn.transaction():
                    # Mark this operation as completed
-                    row = await conn.fetchrow(
+                    await conn.execute(
                        f"""
                        UPDATE {fq_table("async_operations")}
                        SET status = 'completed', updated_at = NOW(), completed_at = NOW()
                        WHERE operation_id = $1
-                        RETURNING operation_id
                        """,
                        uuid.UUID(operation_id),
                    )
-                    if row is None:
-                        logger.info(
-                            f"Operation {operation_id} no longer exists (bank deleted), skipping mark-completed"
-                        )
-                        return
                    logger.info(f"Marked async operation as completed: {operation_id}")

                    # Check if this is a child operation and update parent if all siblings are done
@@ -1365,20 +1329,14 @@ class MemoryEngine(MemoryEngineInterface):
            pool = await self._get_pool()
            async with acquire_with_retry(pool) as conn:
                async with conn.transaction():
-                    row = await conn.fetchrow(
+                    await conn.execute(
                        f"""
                        UPDATE {fq_table("async_operations")}
                        SET status = 'completed', updated_at = NOW(), completed_at = NOW()
                        WHERE operation_id = $1
-                        RETURNING operation_id
                        """,
                        uuid.UUID(operation_id),
                    )
-                    if row is None:
-                        logger.info(
-                            f"Operation {operation_id} no longer exists (bank deleted), skipping mark-completed"
-                        )
-                        return
                    logger.info(f"Marked async operation as completed: {operation_id}")
                    await self._maybe_update_parent_operation(operation_id, conn)

@@ -1676,15 +1634,6 @@ class MemoryEngine(MemoryEngineInterface):
        # Create connection pool
        # For read-heavy workloads with many parallel think/search operations,
        # we need a larger pool. Read operations don't need strong isolation.
-        async def _init_connection(conn: asyncpg.Connection) -> None:
-            # SET (not SET LOCAL) so it persists for the connection lifetime.
-            # ef_search=200 improves HNSW recall quality for the per-fact_type
-            # semantic queries in retrieve_semantic_bm25_combined().
-            try:
-                await conn.execute("SET hnsw.ef_search = 200")
-            except Exception:
-                logger.debug("Could not set hnsw.ef_search — extension may not support it")
-
        self._pool = await asyncpg.create_pool(
            self.db_url,
            min_size=self._pool_min_size,
@@ -1692,7 +1641,6 @@ class MemoryEngine(MemoryEngineInterface):
            command_timeout=self._db_command_timeout,
            statement_cache_size=0,  # Disable prepared statement cache
            timeout=self._db_acquire_timeout,  # Connection acquisition timeout (seconds)
-            init=_init_connection,
        )

        # Initialize entity resolver with pool and configured lookup strategy
@@ -1966,7 +1914,6 @@ class MemoryEngine(MemoryEngineInterface):
        return_usage: bool = False,
        operation_id: str | None = None,
        outbox_callback: "Callable[[asyncpg.Connection], Awaitable[None]] | None" = None,
-        strategy: str | None = None,
    ):
        """
        Store multiple content items as memory units in ONE batch operation.
@@ -2100,15 +2047,6 @@ class MemoryEngine(MemoryEngineInterface):
            # Process each sub-batch
            all_results = []
            for i, sub_batch in enumerate(sub_batches, 1):
-                # Checkpoint: abort if the operation was deleted (bank was deleted) between sub-batches.
-                if operation_id and not await self._check_op_alive(operation_id):
-                    logger.info(
-                        f"[BATCH_RETAIN] bank={bank_id} operation {operation_id} cancelled (bank deleted), stopping after {i - 1}/{len(sub_batches)} sub-batches"
-                    )
-                    if return_usage:
-                        return all_results, total_usage
-                    return all_results
-
                sub_batch_tokens = sum(count_tokens(item.get("content", "")) for item in sub_batch)
                logger.info(
                    f"Processing sub-batch {i}/{len(sub_batches)}: {len(sub_batch)} items, {sub_batch_tokens:,} tokens"
@@ -2124,7 +2062,6 @@ class MemoryEngine(MemoryEngineInterface):
                    confidence_score=confidence_score,
                    document_tags=document_tags,
                    operation_id=operation_id,
-                    strategy=strategy,
                    # Outbox callback runs inside the last sub-batch's transaction so the
                    # webhook delivery row is committed atomically with the final retain data.
                    outbox_callback=outbox_callback if i == len(sub_batches) else None,
@@ -2149,7 +2086,6 @@ class MemoryEngine(MemoryEngineInterface):
                confidence_score=confidence_score,
                document_tags=document_tags,
                operation_id=operation_id,
-                strategy=strategy,
                outbox_callback=outbox_callback,
            )

@@ -2202,7 +2138,6 @@ class MemoryEngine(MemoryEngineInterface):
        document_tags: list[str] | None = None,
        operation_id: str | None = None,
        outbox_callback: "Callable[[asyncpg.Connection], Awaitable[None]] | None" = None,
-        strategy: str | None = None,
    ) -> tuple[list[list[str]], "TokenUsage"]:
        """
        Internal method for batch processing without chunking logic.
@@ -2235,13 +2170,6 @@ class MemoryEngine(MemoryEngineInterface):
            # Resolve bank-specific config for this operation
            resolved_config = await self._config_resolver.resolve_full_config(bank_id, request_context)

-            # Apply strategy overrides: explicit strategy > bank default strategy
-            from hindsight_api.config_resolver import apply_strategy
-
-            effective_strategy = strategy or resolved_config.retain_default_strategy
-            if effective_strategy:
-                resolved_config = apply_strategy(resolved_config, effective_strategy)
-
            # Create parent span for retain operation
            with create_operation_span("retain", bank_id):
                return await orchestrator.retain_batch(
@@ -2324,7 +2252,6 @@ class MemoryEngine(MemoryEngineInterface):
        request_context: "RequestContext",
        tags: list[str] | None = None,
        tags_match: TagsMatch = "any",
-        tag_groups: list[TagGroup] | None = None,
        _connection_budget: int | None = None,
        _quiet: bool = False,
    ) -> RecallResultModel:
@@ -2459,7 +2386,6 @@ class MemoryEngine(MemoryEngineInterface):
                            semaphore_wait=semaphore_wait,
                            tags=tags,
                            tags_match=tags_match,
-                            tag_groups=tag_groups,
                            connection_budget=_connection_budget,
                            quiet=_quiet,
                            include_source_facts=include_source_facts,
@@ -2587,7 +2513,6 @@ class MemoryEngine(MemoryEngineInterface):
        semaphore_wait: float = 0.0,
        tags: list[str] | None = None,
        tags_match: TagsMatch = "any",
-        tag_groups: list[TagGroup] | None = None,
        connection_budget: int | None = None,
        quiet: bool = False,
        include_source_facts: bool = False,
@@ -2707,7 +2632,6 @@ class MemoryEngine(MemoryEngineInterface):
                        self.query_analyzer,
                        tags=tags,
                        tags_match=tags_match,
-                        tag_groups=tag_groups,
                    )
                    parallel_duration = time.time() - parallel_start
            finally:
@@ -3752,7 +3676,6 @@ class MemoryEngine(MemoryEngineInterface):
        pool = await self._get_pool()
        invalidated_obs = 0
        result: dict[str, int] = {}
-        bank_internal_id: str | None = None
        async with acquire_with_retry(pool) as conn:
            # Ensure connection is not in read-only mode (can happen with connection poolers)
            await conn.execute("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE")
@@ -3808,12 +3731,8 @@ class MemoryEngine(MemoryEngineInterface):
                        # Delete entities (cascades to unit_entities, entity_cooccurrences, memory_links with entity_id)
                        await conn.execute(f"DELETE FROM {fq_table('entities')} WHERE bank_id = $1", bank_id)

-                        # Delete the bank profile and retrieve internal_id for HNSW index cleanup
-                        internal_id = await conn.fetchval(
-                            f"DELETE FROM {fq_table('banks')} WHERE bank_id = $1 RETURNING internal_id", bank_id
-                        )
-                        if internal_id:
-                            bank_internal_id = str(internal_id)
+                        # Delete the bank profile itself
+                        await conn.execute(f"DELETE FROM {fq_table('banks')} WHERE bank_id = $1", bank_id)

                        result = {
                            "memory_units_deleted": units_count,
@@ -3825,12 +3744,6 @@ class MemoryEngine(MemoryEngineInterface):
                except Exception as e:
                    raise Exception(f"Failed to delete agent data: {str(e)}")

-            # Drop per-bank HNSW indexes AFTER the transaction commits to avoid
-            # AccessExclusiveLock deadlocks with concurrent bank deletions.
-            # (DROP INDEX on memory_units conflicts with RowExclusiveLock from DELETE inside tx)
-            if bank_internal_id:
-                await bank_utils.drop_bank_hnsw_indexes(conn, bank_internal_id)
-
        if invalidated_obs > 0:
            await self.submit_async_consolidation(bank_id=bank_id, request_context=request_context)

@@ -3887,58 +3800,6 @@ class MemoryEngine(MemoryEngineInterface):

                return {"deleted_count": count or 0}

-    async def retry_failed_consolidation(
-        self,
-        bank_id: str,
-        *,
-        request_context: "RequestContext",
-    ) -> dict[str, int]:
-        """
-        Reset memories that previously failed consolidation so they are retried on the next
-        consolidation run.
-
-        Clears consolidation_failed_at (and consolidated_at) for all memories in the bank
-        that were marked as permanently failed after exhausting all LLM retries and adaptive
-        batch splitting. Does not delete any observations.
-
-        Args:
-            bank_id: Bank ID
-            request_context: Request context for authentication.
-
-        Returns:
-            Dictionary with count of memories queued for retry.
-        """
-        await self._authenticate_tenant(request_context)
-        if self._operation_validator:
-            from hindsight_api.extensions import BankWriteContext
-
-            ctx = BankWriteContext(
-                bank_id=bank_id, operation="retry_failed_consolidation", request_context=request_context
-            )
-            await self._validate_operation(self._operation_validator.validate_bank_write(ctx))
-        pool = await self._get_pool()
-        async with acquire_with_retry(pool) as conn:
-            count = await conn.fetchval(
-                f"""
-                SELECT COUNT(*) FROM {fq_table("memory_units")}
-                WHERE bank_id = $1
-                  AND consolidation_failed_at IS NOT NULL
-                  AND fact_type IN ('experience', 'world')
-                """,
-                bank_id,
-            )
-            await conn.execute(
-                f"""
-                UPDATE {fq_table("memory_units")}
-                SET consolidation_failed_at = NULL, consolidated_at = NULL
-                WHERE bank_id = $1
-                  AND consolidation_failed_at IS NOT NULL
-                  AND fact_type IN ('experience', 'world')
-                """,
-                bank_id,
-            )
-            return {"retried_count": count or 0}
-
    async def clear_observations_for_memory(
        self,
        bank_id: str,
@@ -5120,10 +4981,7 @@ class MemoryEngine(MemoryEngineInterface):
        request_context: "RequestContext",
        tags: list[str] | None = None,
        tags_match: TagsMatch = "any",
-        tag_groups: list[TagGroup] | None = None,
        exclude_mental_model_ids: list[str] | None = None,
-        fact_types: list[str] | None = None,
-        exclude_mental_models: bool = False,
        _skip_span: bool = False,
    ) -> ReflectResult:
        """
@@ -5225,7 +5083,6 @@ class MemoryEngine(MemoryEngineInterface):
                    max_results=max_results,
                    tags=tags,
                    tags_match=tags_match,
-                    tag_groups=tag_groups,
                    exclude_ids=exclude_mental_model_ids,
                    pending_consolidation=pending_consolidation,
                )
@@ -5239,16 +5096,10 @@ class MemoryEngine(MemoryEngineInterface):
                max_tokens=max_tokens,
                tags=tags,
                tags_match=tags_match,
-                tag_groups=tag_groups,
                last_consolidated_at=last_consolidated_at,
                pending_consolidation=pending_consolidation,
            )

-        # Determine which tools to enable based on fact_types and exclude_mental_models
-        include_observations = fact_types is None or "observation" in fact_types
-        recall_fact_types = [ft for ft in (fact_types or ["world", "experience"]) if ft in ("world", "experience")]
-        include_recall = bool(recall_fact_types)
-
        async def recall_fn(q: str, max_tokens: int = 4096, max_chunk_tokens: int = 1000) -> dict[str, Any]:
            return await tool_recall(
                self,
@@ -5258,9 +5109,7 @@ class MemoryEngine(MemoryEngineInterface):
                max_tokens=max_tokens,
                tags=tags,
                tags_match=tags_match,
-                tag_groups=tag_groups,
                max_chunk_tokens=max_chunk_tokens,
-                fact_types=recall_fact_types if fact_types is not None else None,
            )

        async def expand_fn(memory_ids: list[str], depth: str) -> dict[str, Any]:
@@ -5283,17 +5132,15 @@ class MemoryEngine(MemoryEngineInterface):
        if directives:
            logger.info(f"[REFLECT {reflect_id}] Loaded {len(directives)} directives")

-        # Check if the bank has any mental models (skip check if all mental models are excluded)
-        has_mental_models = False
-        if not exclude_mental_models:
-            async with pool.acquire() as conn:
-                mental_model_count = await conn.fetchval(
-                    f"SELECT COUNT(*) FROM {fq_table('mental_models')} WHERE bank_id = $1",
-                    bank_id,
-                )
-            has_mental_models = mental_model_count > 0
-            if has_mental_models:
-                logger.info(f"[REFLECT {reflect_id}] Bank has {mental_model_count} mental models")
+        # Check if the bank has any mental models
+        async with pool.acquire() as conn:
+            mental_model_count = await conn.fetchval(
+                f"SELECT COUNT(*) FROM {fq_table('mental_models')} WHERE bank_id = $1",
+                bank_id,
+            )
+        has_mental_models = mental_model_count > 0
+        if has_mental_models:
+            logger.info(f"[REFLECT {reflect_id}] Bank has {mental_model_count} mental models")

        # Run the agent with parent span for reflect operation (skip if called from another operation)
        if not _skip_span:
@@ -5318,8 +5165,6 @@ class MemoryEngine(MemoryEngineInterface):
                response_schema=response_schema,
                directives=directives,
                has_mental_models=has_mental_models,
-                include_observations=include_observations,
-                include_recall=include_recall,
                budget=effective_budget,
                max_context_tokens=max_context_tokens,
            )
@@ -6451,12 +6296,6 @@ class MemoryEngine(MemoryEngineInterface):
            tags = mental_model.get("tags")
            tags_match = "all_strict" if tags else "any"

-            # Read reflect options from trigger (if stored)
-            trigger_data = mental_model.get("trigger") or {}
-            fact_types = trigger_data.get("fact_types")
-            exclude_mental_models = trigger_data.get("exclude_mental_models", False)
-            stored_exclude_ids: list[str] = trigger_data.get("exclude_mental_model_ids") or []
-
            # Run reflect with the source query, excluding the mental model being refreshed
            # Skip creating a nested "hindsight.reflect" span since we already have "hindsight.mental_model_refresh"
            reflect_result = await self.reflect_async(
@@ -6465,9 +6304,7 @@ class MemoryEngine(MemoryEngineInterface):
                request_context=request_context,
                tags=tags,
                tags_match=tags_match,
-                fact_types=fact_types,
-                exclude_mental_models=exclude_mental_models,
-                exclude_mental_model_ids=list({*stored_exclude_ids, mental_model_id}),
+                exclude_mental_model_ids=[mental_model_id],
                _skip_span=True,
            )

@@ -7473,7 +7310,6 @@ class MemoryEngine(MemoryEngineInterface):
        *,
        request_context: "RequestContext",
        document_tags: list[str] | None = None,
-        strategy: str | None = None,
    ) -> dict[str, Any]:
        """Submit a batch retain operation to run asynchronously.

@@ -7545,10 +7381,6 @@ class MemoryEngine(MemoryEngineInterface):
        parent_operation_id = uuid.uuid4()
        pool = await self._get_pool()

-        # Ensure the bank row exists before inserting async_operations (which now has a FK).
-        # Banks are created lazily on first retain, but the FK requires the row to exist first.
-        await bank_utils.get_bank_profile(pool, bank_id)
-
        # Create typed metadata for parent operation
        parent_metadata = BatchRetainParentMetadata(
            items_count=len(contents),
@@ -7582,8 +7414,6 @@ class MemoryEngine(MemoryEngineInterface):
            task_payload: dict[str, Any] = {"contents": sub_batch}
            if document_tags:
                task_payload["document_tags"] = document_tags
-            if strategy:
-                task_payload["strategy"] = strategy
            # Pass tenant_id and api_key_id through task payload
            if request_context.tenant_id:
                task_payload["_tenant_id"] = request_context.tenant_id
@@ -7698,8 +7528,6 @@ class MemoryEngine(MemoryEngineInterface):
                "document_tags": document_tags or [],
                "timestamp": item.get("timestamp"),
            }
-            if item.get("strategy"):
-                task_payload["strategy"] = item["strategy"]

            # Pass tenant_id and api_key_id through task payload
            if request_context.tenant_id:
--- a/Show More
+++ b/Show More