docs: update 0.4.15 blog cover image

.github/workflows/release.yml

@@ -387,10 +387,6 @@ jobs:
             target: aarch64-apple-darwin
             artifact_name: hindsight
             asset_name: hindsight-darwin-arm64
-          - os: ubuntu-24.04-arm
-            target: aarch64-unknown-linux-gnu
-            artifact_name: hindsight
-            asset_name: hindsight-linux-arm64
 
     steps:
     - uses: actions/checkout@v4

.github/workflows/test.yml

@@ -686,30 +686,6 @@ jobs:
         echo "=== API Server Logs ==="
         cat /tmp/api-server.log || echo "No API server log found"
 
-  build-rust-cli-arm64:
-    runs-on: ubuntu-24.04-arm
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install Rust
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: aarch64-unknown-linux-gnu
-
-    - name: Cache cargo
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.cargo/registry
-          ~/.cargo/git
-          hindsight-cli/target
-        key: linux-arm64-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-    - name: Build CLI
-      working-directory: hindsight-cli
-      run: cargo build --release --target aarch64-unknown-linux-gnu
-
   test-rust-client:
     runs-on: ubuntu-latest
     env:
@@ -1321,11 +1297,7 @@ jobs:
 
   test-doc-examples:
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [python, node, cli, go]
-    name: test-doc-examples (${{ matrix.language }})
+    needs: test-rust-cli
     env:
       HINDSIGHT_API_LLM_PROVIDER: vertexai
       HINDSIGHT_API_LLM_VERTEXAI_SERVICE_ACCOUNT_KEY: /tmp/gcp-credentials.json
@@ -1343,26 +1315,14 @@ jobs:
         PROJECT_ID=$(jq -r '.project_id' /tmp/gcp-credentials.json)
         echo "HINDSIGHT_API_LLM_VERTEXAI_PROJECT_ID=$PROJECT_ID" >> $GITHUB_ENV
 
-    - name: Install Rust
-      if: matrix.language == 'cli'
-      uses: dtolnay/rust-toolchain@stable
-
-    - name: Cache cargo
-      if: matrix.language == 'cli'
-      uses: actions/cache@v4
+    - name: Download CLI artifact
+      uses: actions/download-artifact@v4
       with:
-        path: |
-          ~/.cargo/registry
-          ~/.cargo/git
-          hindsight-cli/target
-        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        name: hindsight-cli
+        path: /usr/local/bin
 
-    - name: Build CLI
-      if: matrix.language == 'cli'
-      working-directory: hindsight-cli
-      run: |
-        cargo build --release
-        cp target/release/hindsight /usr/local/bin/hindsight
+    - name: Make CLI executable
+      run: chmod +x /usr/local/bin/hindsight
 
     - name: Install uv
       uses: astral-sh/setup-uv@v5
@@ -1376,7 +1336,6 @@ jobs:
         python-version-file: ".python-version"
 
     - name: Set up Node.js
-      if: matrix.language == 'node'
       uses: actions/setup-node@v4
       with:
         node-version: '20'
@@ -1390,12 +1349,10 @@ jobs:
         uv sync --frozen --no-install-project --index-strategy unsafe-best-match
 
     - name: Install Python client dependencies
-      if: matrix.language == 'python'
       working-directory: ./hindsight-clients/python
       run: uv sync --frozen --extra test --index-strategy unsafe-best-match
 
     - name: Install TypeScript client
-      if: matrix.language == 'node'
       run: |
         npm ci --workspace=hindsight-clients/typescript
         npm run build --workspace=hindsight-clients/typescript
@@ -1447,11 +1404,10 @@ jobs:
         done
 
     - name: Configure CLI
-      if: matrix.language == 'cli'
       run: hindsight configure --api-url http://localhost:8888
 
-    - name: Run doc examples (${{ matrix.language }})
-      run: ./scripts/test-doc-examples.sh --lang ${{ matrix.language }}
+    - name: Run all doc examples
+      run: ./scripts/test-doc-examples.sh
 
     - name: Show API server logs
       if: always()

helm/hindsight/Chart.yaml

@@ -2,8 +2,8 @@ apiVersion: v2
 name: hindsight
 description: Hindsight helm chart
 type: application
-version: 0.4.16
-appVersion: "0.4.16"
+version: 0.4.15
+appVersion: "0.4.15"
 keywords:
   - ai
   - memory

hindsight-api/hindsight_api/__init__.py

@@ -46,4 +46,4 @@ __all__ = [
     "RemoteTEICrossEncoder",
     "LLMConfig",
 ]
-__version__ = "0.4.16"
+__version__ = "0.4.15"

hindsight-api/hindsight_api/alembic/versions/a2b3c4d5e6f8_add_gin_index_source_memory_ids.py

@@ -1,54 +0,0 @@
-"""Add GIN index on source_memory_ids for observation lookup performance
-
-Without this index, queries using the array overlap operator (&&) or array
-containment (@>) on source_memory_ids require a full sequential scan over all
-observation memory_units. At ~77k observations this was measured at 45ms per
-query, becoming a bottleneck during consolidation recall (57-64s timeouts) and
-user recall (18-27s average).
-
-The GIN index reduces these queries to index scans: 45ms → 0.049ms (927x
-speedup). Recall dropped from 18-27s to ~6s, and consolidation recall
-stabilised from timeout to ~15s.
-
-Created with CONCURRENTLY so the migration does not block reads or writes.
-CONCURRENTLY requires running outside a transaction block, so the migration
-emits an explicit COMMIT before the statement and uses IF NOT EXISTS for
-idempotency.
-
-Revision ID: a2b3c4d5e6f8
-Revises: f7g8h9i0j1k2
-Create Date: 2026-03-04
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "a2b3c4d5e6f8"
-down_revision: str | Sequence[str] | None = "f7g8h9i0j1k2"
-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()
-
-    # CREATE INDEX CONCURRENTLY cannot run inside a transaction block.
-    # Commit the current Alembic transaction first.
-    op.execute("COMMIT")
-    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"
-    )
-
-
-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")

hindsight-api/hindsight_api/alembic/versions/e4f5a6b7c8d9_add_webhooks_tables.py

@@ -1,62 +0,0 @@
-"""Add webhooks table and next_retry_at to async_operations.
-
-Webhook deliveries are handled as async_operations tasks (operation_type='webhook_delivery')
-rather than a dedicated webhook_deliveries table.
-
-Revision ID: e4f5a6b7c8d9
-Revises: d2e3f4a5b6c7
-Create Date: 2026-03-04
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "e4f5a6b7c8d9"
-down_revision: str | Sequence[str] | None = "d2e3f4a5b6c7"
-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()
-
-    op.execute(
-        f"""
-        CREATE TABLE IF NOT EXISTS {schema}webhooks (
-            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-            bank_id TEXT,
-            url TEXT NOT NULL,
-            secret TEXT,
-            event_types TEXT[] NOT NULL DEFAULT '{{}}',
-            enabled BOOLEAN NOT NULL DEFAULT TRUE,
-            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-            updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-        )
-        """
-    )
-
-    # Index for bank-scoped webhook lookup
-    op.execute(f"CREATE INDEX IF NOT EXISTS idx_webhooks_bank_id ON {schema}webhooks(bank_id)")
-
-    # Add next_retry_at to async_operations for task-owned retry scheduling
-    op.execute(f"ALTER TABLE {schema}async_operations ADD COLUMN IF NOT EXISTS next_retry_at TIMESTAMPTZ NULL")
-
-    # Index for polling: status + next_retry_at
-    op.execute(
-        f"CREATE INDEX IF NOT EXISTS idx_async_operations_status_retry "
-        f"ON {schema}async_operations(status, next_retry_at)"
-    )
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_async_operations_status_retry")
-    op.execute(f"ALTER TABLE {schema}async_operations DROP COLUMN IF EXISTS next_retry_at")
-    op.execute(f"DROP INDEX IF EXISTS {schema}idx_webhooks_bank_id")
-    op.execute(f"DROP TABLE IF EXISTS {schema}webhooks")

hindsight-api/hindsight_api/alembic/versions/f7g8h9i0j1k2_add_webhook_http_config.py

@@ -1,33 +0,0 @@
-"""Add http_config JSONB column to webhooks table.
-
-Stores HTTP delivery configuration (method, timeout, headers, params) as a
-single JSONB column rather than separate columns.
-
-Revision ID: f7g8h9i0j1k2
-Revises: e4f5a6b7c8d9
-Create Date: 2026-03-04
-"""
-
-from collections.abc import Sequence
-
-from alembic import context, op
-
-revision: str = "f7g8h9i0j1k2"
-down_revision: str | Sequence[str] | None = "e4f5a6b7c8d9"
-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()
-    op.execute(f"ALTER TABLE {schema}webhooks ADD COLUMN IF NOT EXISTS http_config JSONB NOT NULL DEFAULT '{{}}'")
-
-
-def downgrade() -> None:
-    schema = _get_schema_prefix()
-    op.execute(f"ALTER TABLE {schema}webhooks DROP COLUMN IF EXISTS http_config")

hindsight-api/hindsight_api/api/http.py

@@ -71,7 +71,9 @@ 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.db_utils import acquire_with_retry
+from hindsight_api.engine.memory_engine import Budget, _get_tiktoken_encoding, fq_table
+from hindsight_api.engine.reflect.observations import Observation
 from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES, MemoryFact, TokenUsage
 from hindsight_api.engine.search.tags import TagsMatch
 from hindsight_api.extensions import HttpExtension, OperationValidationError, load_extension
@@ -757,6 +759,14 @@ class ReflectResponse(BaseModel):
     )
 
 
+class BanksResponse(BaseModel):
+    """Response model for banks list endpoint."""
+
+    model_config = ConfigDict(json_schema_extra={"example": {"banks": ["user123", "bank_alice", "bank_bob"]}})
+
+    banks: list[str]
+
+
 class DispositionTraits(BaseModel):
     """Disposition traits that influence how memories are formed and interpreted."""
 
@@ -1295,6 +1305,15 @@ class BankStatsResponse(BaseModel):
 # Mental Model models
 
 
+class ObservationEvidenceResponse(BaseModel):
+    """A single piece of evidence supporting an observation."""
+
+    memory_id: str = Field(description="ID of the memory unit this evidence comes from")
+    quote: str = Field(description="Exact quote from the memory supporting the observation")
+    relevance: str = Field(description="Brief explanation of how this quote supports the observation")
+    timestamp: str = Field(description="When the source memory was created (ISO format)")
+
+
 # =========================================================================
 # Directive Models
 # =========================================================================
@@ -1608,123 +1627,6 @@ class VersionResponse(BaseModel):
     features: FeaturesInfo = Field(description="Enabled feature flags")
 
 
-# =========================================================================
-# Webhook Models
-# =========================================================================
-
-
-from hindsight_api.webhooks.models import WebhookHttpConfig
-
-
-class CreateWebhookRequest(BaseModel):
-    """Request model for registering a webhook."""
-
-    url: str = Field(description="HTTP(S) endpoint URL to deliver events to")
-    secret: str | None = Field(default=None, description="HMAC-SHA256 signing secret (optional)")
-    event_types: list[str] = Field(
-        default=["consolidation.completed"],
-        description="List of event types to deliver. Currently supported: 'consolidation.completed'",
-    )
-    enabled: bool = Field(default=True, description="Whether this webhook is active")
-    http_config: WebhookHttpConfig = Field(
-        default_factory=WebhookHttpConfig,
-        description="HTTP delivery configuration (method, timeout, headers, params)",
-    )
-
-
-class WebhookResponse(BaseModel):
-    """Response model for a webhook."""
-
-    id: str
-    bank_id: str | None
-    url: str
-    secret: str | None = Field(default=None, description="Signing secret (redacted in responses)")
-    event_types: list[str]
-    enabled: bool
-    http_config: WebhookHttpConfig = Field(default_factory=WebhookHttpConfig)
-    created_at: str | None = None
-    updated_at: str | None = None
-
-
-class UpdateWebhookRequest(BaseModel):
-    """Request model for updating a webhook. Only provided fields are updated."""
-
-    url: str | None = Field(default=None, description="HTTP(S) endpoint URL")
-    secret: str | None = Field(
-        default=None, description="HMAC-SHA256 signing secret. Omit to keep existing; send null to clear."
-    )
-    event_types: list[str] | None = Field(default=None, description="List of event types")
-    enabled: bool | None = Field(default=None, description="Whether this webhook is active")
-    http_config: WebhookHttpConfig | None = Field(default=None, description="HTTP delivery configuration")
-
-
-class WebhookListResponse(BaseModel):
-    """Response model for listing webhooks."""
-
-    items: list[WebhookResponse]
-
-
-class WebhookDeliveryResponse(BaseModel):
-    """Response model for a webhook delivery record."""
-
-    id: str
-    webhook_id: str | None
-    url: str
-    event_type: str
-    status: str
-    attempts: int
-    next_retry_at: str | None = None
-    last_error: str | None = None
-    last_response_status: int | None = None
-    last_response_body: str | None = None
-    last_attempt_at: str | None = None
-    created_at: str | None = None
-    updated_at: str | None = None
-
-    @classmethod
-    def from_async_operation_row(cls, row: dict) -> "WebhookDeliveryResponse":
-        import json as _json
-
-        raw = row["task_payload"]
-        if isinstance(raw, str):
-            task_payload = _json.loads(raw)
-        elif isinstance(raw, dict):
-            task_payload = raw
-        else:
-            task_payload = {}
-
-        raw_meta = row.get("result_metadata")
-        if isinstance(raw_meta, str):
-            result_metadata = _json.loads(raw_meta) if raw_meta else {}
-        elif isinstance(raw_meta, dict):
-            result_metadata = raw_meta
-        else:
-            result_metadata = {}
-
-        return cls(
-            id=str(row["operation_id"]),
-            webhook_id=task_payload.get("webhook_id"),
-            url=task_payload.get("url", ""),
-            event_type=task_payload.get("event_type", ""),
-            status=row["status"],
-            attempts=row["retry_count"] + 1,
-            next_retry_at=row["next_retry_at"],
-            last_error=row["error_message"],
-            last_response_status=result_metadata.get("last_status_code"),
-            last_response_body=result_metadata.get("last_response_body"),
-            last_attempt_at=result_metadata.get("last_attempt_at"),
-            created_at=row["created_at"],
-            updated_at=row["updated_at"],
-        )
-
-
-class WebhookDeliveryListResponse(BaseModel):
-    """Response model for listing webhook deliveries."""
-
-    items: list[WebhookDeliveryResponse]
-    next_cursor: str | None = None
-
-
 def create_app(
     memory: MemoryEngine,
     initialize_memory: bool = True,
@@ -1824,6 +1726,7 @@ def create_app(
                 worker_id=worker_id,
                 executor=memory.execute_task,
                 poll_interval_ms=config.worker_poll_interval_ms,
+                max_retries=config.worker_max_retries,
                 schema=schema,
                 tenant_extension=memory._tenant_extension,
                 max_slots=config.worker_max_slots,
@@ -3853,318 +3756,6 @@ def _register_routes(app: FastAPI):
             logger.error(f"Error in POST /v1/default/banks/{bank_id}/consolidate: {error_detail}")
             raise HTTPException(status_code=500, detail=str(e))
 
-    # =========================================================================
-    # Webhook Endpoints
-    # =========================================================================
-
-    @app.post(
-        "/v1/default/banks/{bank_id}/webhooks",
-        response_model=WebhookResponse,
-        summary="Register webhook",
-        description="Register a webhook endpoint to receive event notifications for this bank.",
-        operation_id="create_webhook",
-        tags=["Webhooks"],
-        status_code=201,
-    )
-    async def api_create_webhook(
-        bank_id: str,
-        request: CreateWebhookRequest,
-        request_context: RequestContext = Depends(get_request_context),
-    ):
-        """Register a webhook for a bank."""
-        try:
-            pool = await app.state.memory._get_pool()
-            from hindsight_api.engine.memory_engine import fq_table
-
-            webhook_id = uuid.uuid4()
-            now = datetime.utcnow().isoformat() + "Z"
-            row = await pool.fetchrow(
-                f"""
-                INSERT INTO {fq_table("webhooks")}
-                (id, bank_id, url, secret, event_types, enabled, http_config, created_at, updated_at)
-                VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, NOW(), NOW())
-                RETURNING id, bank_id, url, secret, event_types, enabled,
-                          http_config::text, created_at::text, updated_at::text
-                """,
-                webhook_id,
-                bank_id,
-                request.url,
-                request.secret,
-                request.event_types,
-                request.enabled,
-                request.http_config.model_dump_json(),
-            )
-            return WebhookResponse(
-                id=str(row["id"]),
-                bank_id=row["bank_id"],
-                url=row["url"],
-                secret=None,  # Never return secret in responses
-                event_types=list(row["event_types"]) if row["event_types"] else [],
-                enabled=row["enabled"],
-                http_config=WebhookHttpConfig.model_validate_json(row["http_config"])
-                if row["http_config"]
-                else WebhookHttpConfig(),
-                created_at=row["created_at"],
-                updated_at=row["updated_at"],
-            )
-        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}/webhooks: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.get(
-        "/v1/default/banks/{bank_id}/webhooks",
-        response_model=WebhookListResponse,
-        summary="List webhooks",
-        description="List all webhooks registered for a bank.",
-        operation_id="list_webhooks",
-        tags=["Webhooks"],
-    )
-    async def api_list_webhooks(
-        bank_id: str,
-        request_context: RequestContext = Depends(get_request_context),
-    ):
-        """List webhooks for a bank."""
-        try:
-            pool = await app.state.memory._get_pool()
-            from hindsight_api.engine.memory_engine import fq_table
-
-            rows = await pool.fetch(
-                f"""
-                SELECT id, bank_id, url, secret, event_types, enabled,
-                       http_config::text, created_at::text, updated_at::text
-                FROM {fq_table("webhooks")}
-                WHERE bank_id = $1
-                ORDER BY created_at
-                """,
-                bank_id,
-            )
-            return WebhookListResponse(
-                items=[
-                    WebhookResponse(
-                        id=str(row["id"]),
-                        bank_id=row["bank_id"],
-                        url=row["url"],
-                        secret=None,  # Never return secret in responses
-                        event_types=list(row["event_types"]) if row["event_types"] else [],
-                        enabled=row["enabled"],
-                        http_config=WebhookHttpConfig.model_validate_json(row["http_config"])
-                        if row["http_config"]
-                        else WebhookHttpConfig(),
-                        created_at=row["created_at"],
-                        updated_at=row["updated_at"],
-                    )
-                    for row in rows
-                ]
-            )
-        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 GET /v1/default/banks/{bank_id}/webhooks: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.delete(
-        "/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-        response_model=DeleteResponse,
-        summary="Delete webhook",
-        description="Remove a registered webhook.",
-        operation_id="delete_webhook",
-        tags=["Webhooks"],
-    )
-    async def api_delete_webhook(
-        bank_id: str,
-        webhook_id: str,
-        request_context: RequestContext = Depends(get_request_context),
-    ):
-        """Delete a webhook."""
-        try:
-            pool = await app.state.memory._get_pool()
-            from hindsight_api.engine.memory_engine import fq_table
-
-            result = await pool.execute(
-                f"DELETE FROM {fq_table('webhooks')} WHERE id = $1 AND bank_id = $2",
-                uuid.UUID(webhook_id),
-                bank_id,
-            )
-            deleted = int(result.split()[-1]) if result else 0
-            if deleted == 0:
-                raise HTTPException(status_code=404, detail="Webhook not found")
-            return DeleteResponse(success=True)
-        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 DELETE /v1/default/banks/{bank_id}/webhooks/{webhook_id}: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.patch(
-        "/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-        response_model=WebhookResponse,
-        summary="Update webhook",
-        description="Update one or more fields of a registered webhook. Only provided fields are changed.",
-        operation_id="update_webhook",
-        tags=["Webhooks"],
-    )
-    async def api_update_webhook(
-        bank_id: str,
-        webhook_id: str,
-        request: UpdateWebhookRequest,
-        request_context: RequestContext = Depends(get_request_context),
-    ):
-        """Update a webhook's fields (PATCH semantics — only sent fields are updated)."""
-        try:
-            pool = await app.state.memory._get_pool()
-            from hindsight_api.engine.memory_engine import fq_table
-
-            set_clauses: list[str] = []
-            params: list = [uuid.UUID(webhook_id), bank_id]
-
-            fields = request.model_fields_set
-            if "url" in fields:
-                params.append(request.url)
-                set_clauses.append(f"url = ${len(params)}")
-            if "secret" in fields:
-                params.append(request.secret)
-                set_clauses.append(f"secret = ${len(params)}")
-            if "event_types" in fields:
-                params.append(request.event_types)
-                set_clauses.append(f"event_types = ${len(params)}")
-            if "enabled" in fields:
-                params.append(request.enabled)
-                set_clauses.append(f"enabled = ${len(params)}")
-            if "http_config" in fields:
-                params.append(request.http_config.model_dump_json())
-                set_clauses.append(f"http_config = ${len(params)}::jsonb")
-
-            if not set_clauses:
-                raise HTTPException(status_code=422, detail="No fields provided to update")
-
-            set_clauses.append("updated_at = NOW()")
-            row = await pool.fetchrow(
-                f"""
-                UPDATE {fq_table("webhooks")}
-                SET {", ".join(set_clauses)}
-                WHERE id = $1 AND bank_id = $2
-                RETURNING id, bank_id, url, secret, event_types, enabled,
-                          http_config::text, created_at::text, updated_at::text
-                """,
-                *params,
-            )
-            if not row:
-                raise HTTPException(status_code=404, detail="Webhook not found")
-            return WebhookResponse(
-                id=str(row["id"]),
-                bank_id=row["bank_id"],
-                url=row["url"],
-                secret=None,
-                event_types=list(row["event_types"]) if row["event_types"] else [],
-                enabled=row["enabled"],
-                http_config=WebhookHttpConfig.model_validate_json(row["http_config"])
-                if row["http_config"]
-                else WebhookHttpConfig(),
-                created_at=row["created_at"],
-                updated_at=row["updated_at"],
-            )
-        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 PATCH /v1/default/banks/{bank_id}/webhooks/{webhook_id}: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @app.get(
-        "/v1/default/banks/{bank_id}/webhooks/{webhook_id}/deliveries",
-        response_model=WebhookDeliveryListResponse,
-        summary="List webhook deliveries",
-        description="Inspect delivery history for a webhook (useful for debugging).",
-        operation_id="list_webhook_deliveries",
-        tags=["Webhooks"],
-    )
-    async def api_list_webhook_deliveries(
-        bank_id: str,
-        webhook_id: str,
-        limit: int = Query(default=50, le=200, description="Maximum number of deliveries to return"),
-        cursor: str | None = Query(default=None, description="Pagination cursor (created_at of last item)"),
-        request_context: RequestContext = Depends(get_request_context),
-    ):
-        """List deliveries for a specific webhook, newest first. Use next_cursor for pagination."""
-        try:
-            pool = await app.state.memory._get_pool()
-            from hindsight_api.engine.memory_engine import fq_table
-
-            # Verify webhook belongs to this bank
-            webhook_row = await pool.fetchrow(
-                f"SELECT id FROM {fq_table('webhooks')} WHERE id = $1 AND bank_id = $2",
-                uuid.UUID(webhook_id),
-                bank_id,
-            )
-            if not webhook_row:
-                raise HTTPException(status_code=404, detail="Webhook not found")
-
-            # Fetch limit+1 to detect if there's a next page
-            fetch_limit = limit + 1
-            if cursor:
-                rows = await pool.fetch(
-                    f"""
-                    SELECT operation_id, status, retry_count, next_retry_at::text,
-                           error_message, task_payload, result_metadata::text, created_at::text, updated_at::text
-                    FROM {fq_table("async_operations")}
-                    WHERE operation_type = 'webhook_delivery'
-                      AND bank_id = $1
-                      AND task_payload->>'webhook_id' = $2
-                      AND created_at < $3::timestamptz
-                    ORDER BY created_at DESC
-                    LIMIT $4
-                    """,
-                    bank_id,
-                    webhook_id,
-                    cursor,
-                    fetch_limit,
-                )
-            else:
-                rows = await pool.fetch(
-                    f"""
-                    SELECT operation_id, status, retry_count, next_retry_at::text,
-                           error_message, task_payload, result_metadata::text, created_at::text, updated_at::text
-                    FROM {fq_table("async_operations")}
-                    WHERE operation_type = 'webhook_delivery'
-                      AND bank_id = $1
-                      AND task_payload->>'webhook_id' = $2
-                    ORDER BY created_at DESC
-                    LIMIT $3
-                    """,
-                    bank_id,
-                    webhook_id,
-                    fetch_limit,
-                )
-
-            has_more = len(rows) > limit
-            page = rows[:limit]
-            next_cursor = page[-1]["created_at"] if has_more and page else None
-            return WebhookDeliveryListResponse(
-                items=[WebhookDeliveryResponse.from_async_operation_row(dict(row)) for row in page],
-                next_cursor=next_cursor,
-            )
-        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 GET /v1/default/banks/{bank_id}/webhooks/{webhook_id}/deliveries: {error_detail}")
-            raise HTTPException(status_code=500, detail=str(e))
-
     @app.post(
         "/v1/default/banks/{bank_id}/memories",
         response_model=RetainResponse,
@@ -4257,12 +3848,6 @@ def _register_routes(app: FastAPI):
                         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,
-                            operation_id=None,
-                            schema=_current_schema.get(),
-                        ),
                     )
 
                 return RetainResponse.model_validate(

hindsight-api/hindsight_api/config.py

@@ -294,12 +294,6 @@ ENV_CONSOLIDATION_LLM_BATCH_SIZE = "HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE"
 ENV_CONSOLIDATION_MAX_TOKENS = "HINDSIGHT_API_CONSOLIDATION_MAX_TOKENS"
 ENV_OBSERVATIONS_MISSION = "HINDSIGHT_API_OBSERVATIONS_MISSION"
 
-# Webhook configuration (global, static - server-level only)
-ENV_WEBHOOK_URL = "HINDSIGHT_API_WEBHOOK_URL"
-ENV_WEBHOOK_SECRET = "HINDSIGHT_API_WEBHOOK_SECRET"
-ENV_WEBHOOK_EVENT_TYPES = "HINDSIGHT_API_WEBHOOK_EVENT_TYPES"
-ENV_WEBHOOK_DELIVERY_POLL_INTERVAL_SECONDS = "HINDSIGHT_API_WEBHOOK_DELIVERY_POLL_INTERVAL_SECONDS"
-
 # Optimization flags
 ENV_SKIP_LLM_VERIFICATION = "HINDSIGHT_API_SKIP_LLM_VERIFICATION"
 ENV_LAZY_RERANKER = "HINDSIGHT_API_LAZY_RERANKER"
@@ -503,12 +497,6 @@ Use this tool PROACTIVELY to:
 # Default embedding dimension (used by initial migration, adjusted at runtime)
 EMBEDDING_DIMENSION = DEFAULT_EMBEDDING_DIMENSION
 
-# Webhook configuration defaults
-DEFAULT_WEBHOOK_URL = None  # None = no global webhook configured
-DEFAULT_WEBHOOK_SECRET = None  # None = no signing
-DEFAULT_WEBHOOK_EVENT_TYPES = "consolidation.completed"  # Comma-separated; default = all supported events
-DEFAULT_WEBHOOK_DELIVERY_POLL_INTERVAL_SECONDS = 30  # How often to poll for pending deliveries
-
 
 class JsonFormatter(logging.Formatter):
     """JSON formatter for structured logging.
@@ -762,12 +750,6 @@ class HindsightConfig:
     otel_service_name: str
     otel_deployment_environment: str
 
-    # Webhook configuration (static - server-level only, not per-bank)
-    webhook_url: str | None  # Global webhook URL (None = disabled)
-    webhook_secret: str | None  # HMAC signing secret (None = unsigned)
-    webhook_event_types: list[str]  # Event types to deliver globally
-    webhook_delivery_poll_interval_seconds: int  # How often the delivery worker polls
-
     # Class-level sets for configuration categorization
 
     # CREDENTIAL_FIELDS: Never exposed via API, never configurable per-tenant/bank
@@ -1205,20 +1187,6 @@ class HindsightConfig:
             otel_exporter_otlp_headers=os.getenv(ENV_OTEL_EXPORTER_OTLP_HEADERS) or None,
             otel_service_name=os.getenv(ENV_OTEL_SERVICE_NAME, DEFAULT_OTEL_SERVICE_NAME),
             otel_deployment_environment=os.getenv(ENV_OTEL_DEPLOYMENT_ENVIRONMENT, DEFAULT_OTEL_DEPLOYMENT_ENVIRONMENT),
-            # Webhook configuration (static, server-level only)
-            webhook_url=os.getenv(ENV_WEBHOOK_URL) or DEFAULT_WEBHOOK_URL,
-            webhook_secret=os.getenv(ENV_WEBHOOK_SECRET) or DEFAULT_WEBHOOK_SECRET,
-            webhook_event_types=[
-                t.strip()
-                for t in os.getenv(ENV_WEBHOOK_EVENT_TYPES, DEFAULT_WEBHOOK_EVENT_TYPES).split(",")
-                if t.strip()
-            ],
-            webhook_delivery_poll_interval_seconds=int(
-                os.getenv(
-                    ENV_WEBHOOK_DELIVERY_POLL_INTERVAL_SECONDS,
-                    str(DEFAULT_WEBHOOK_DELIVERY_POLL_INTERVAL_SECONDS),
-                )
-            ),
         )
         config.validate()
         return config

hindsight-api/hindsight_api/engine/consolidation/consolidator.py

@@ -9,10 +9,6 @@ Observations are stored in memory_units with fact_type='observation' and include
 - proof_count: Number of supporting memories
 - source_memory_ids: Array of memory UUIDs that contribute to this observation
 - history: JSONB tracking changes over time
-
-NOTE: Observations are distinct from mental models (pinned reflections).
-- Observations: auto-generated bottom-up by this engine from raw facts (memory_units table, fact_type='observation')
-- Mental models: user-defined queries stored in the mental_models table, refreshed on demand via reflect
 """
 
 import json
@@ -71,42 +67,6 @@ class _BatchLLMResult:
     prompt_chars: int = 0
 
 
-@dataclass
-class _SourceAggregation:
-    """Fields inherited by an observation from its source memories."""
-
-    event_date: datetime | None
-    occurred_start: datetime | None
-    occurred_end: datetime | None
-    mentioned_at: datetime | None
-    tags: list[str]
-
-
-def _aggregate_source_fields(source_mems: list[dict[str, Any]], tags: list[str] | None = None) -> _SourceAggregation:
-    """Compute the observation fields inherited from a set of source memories.
-
-    Temporal aggregation rules:
-    - ``event_date``    — earliest across sources (min)
-    - ``occurred_start`` — earliest across sources (min)
-    - ``occurred_end``   — latest across sources (max)
-    - ``mentioned_at``   — latest across sources (max)
-
-    Fields remain ``None`` when no source memory carries that information, so
-    observations are never stamped with an artificial timestamp.
-
-    ``tags`` defaults to those of the first source memory when not explicitly
-    provided (all memories in a consolidation batch share the same tag set).
-    """
-    effective_tags = tags if tags is not None else (source_mems[0].get("tags") or [] if source_mems else [])
-    return _SourceAggregation(
-        event_date=_min_date(m.get("event_date") for m in source_mems),
-        occurred_start=_min_date(m.get("occurred_start") for m in source_mems),
-        occurred_end=_max_date(m.get("occurred_end") for m in source_mems),
-        mentioned_at=_max_date(m.get("mentioned_at") for m in source_mems),
-        tags=effective_tags,
-    )
-
-
 class ConsolidationPerfLog:
     """Performance logging for consolidation operations."""
 
@@ -220,12 +180,11 @@ async def run_consolidation_job(
     perf.log(f"[1] Found {total_count} pending memories to consolidate")
 
     # Process each memory with individual commits for crash recovery
-    stats: dict[str, int] = {
+    stats = {
         "memories_processed": 0,
         "observations_created": 0,
         "observations_updated": 0,
         "observations_merged": 0,
-        "observations_deleted": 0,
         "actions_executed": 0,
         "skipped": 0,
     }
@@ -314,12 +273,11 @@ async def run_consolidation_job(
                     # explicit list[list[str]]
                     obs_tags_list = _obs_parsed
 
-                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(
+                        pass_results = await _process_memory_batch(
                             conn=conn,
                             memory_engine=memory_engine,
                             llm_config=llm_config,
@@ -330,7 +288,6 @@ async def run_consolidation_job(
                             config=config,
                             obs_tags_override=obs_tags,
                         )
-                        batch_deleted += pass_deleted
                         # Merge results: prefer non-skipped actions
                         if not results:
                             results = pass_results
@@ -358,7 +315,7 @@ async def run_consolidation_job(
                                     }
                 else:
                     # Normal single pass using the memory's own tags
-                    results, batch_deleted = await _process_memory_batch(
+                    results = await _process_memory_batch(
                         conn=conn,
                         memory_engine=memory_engine,
                         llm_config=llm_config,
@@ -368,7 +325,6 @@ async def run_consolidation_job(
                         perf=perf,
                         config=config,
                     )
-                stats["observations_deleted"] += batch_deleted
 
                 await conn.executemany(
                     f"UPDATE {fq_table('memory_units')} SET consolidated_at = NOW() WHERE id = $1",
@@ -565,7 +521,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]:
+) -> list[dict[str, Any]]:
     """
     Process a batch of memories in a single LLM call.
 
@@ -656,18 +612,17 @@ async def _process_memory_batch(
         source_mems = [mem_by_id[fid] for fid in create.source_fact_ids if fid in mem_by_id]
         if not source_mems:
             continue
-        agg = _aggregate_source_fields(source_mems, tags=fact_tags)
         await _execute_create_action(
             conn=conn,
             memory_engine=memory_engine,
             bank_id=bank_id,
             source_memory_ids=[m["id"] for m in source_mems],
             text=create.text,
-            source_fact_tags=agg.tags,
-            event_date=agg.event_date,
-            occurred_start=agg.occurred_start,
-            occurred_end=agg.occurred_end,
-            mentioned_at=agg.mentioned_at,
+            source_fact_tags=fact_tags,
+            event_date=_min_date(m.get("event_date") for m in source_mems),
+            occurred_start=_min_date(m.get("occurred_start") for m in source_mems),
+            occurred_end=_max_date(m.get("occurred_end") for m in source_mems),
+            mentioned_at=_max_date(m.get("mentioned_at") for m in source_mems),
             perf=perf,
         )
         for m in source_mems:
@@ -684,7 +639,6 @@ async def _process_memory_batch(
                 f"not in any source fact's recall"
             )
             continue
-        agg = _aggregate_source_fields(source_mems, tags=fact_tags)
         await _execute_update_action(
             conn=conn,
             memory_engine=memory_engine,
@@ -693,16 +647,15 @@ async def _process_memory_batch(
             observation_id=update.observation_id,
             new_text=update.text,
             observations=union_observations,
-            source_fact_tags=agg.tags,
-            source_occurred_start=agg.occurred_start,
-            source_occurred_end=agg.occurred_end,
-            source_mentioned_at=agg.mentioned_at,
+            source_fact_tags=fact_tags,
+            source_occurred_start=_min_date(m.get("occurred_start") for m in source_mems),
+            source_occurred_end=_max_date(m.get("occurred_end") for m in source_mems),
+            source_mentioned_at=_max_date(m.get("mentioned_at") for m in source_mems),
             perf=perf,
         )
         for m in source_mems:
             per_memory_updated.add(str(m["id"]))
 
-    deleted_count = 0
     for delete in llm_result.deletes:
         # Security: the observation must be present in the unioned recall
         if not any(str(obs.id) == delete.observation_id for obs in union_observations):
@@ -711,7 +664,6 @@ async def _process_memory_batch(
             )
             continue
         await _execute_delete_action(conn=conn, bank_id=bank_id, observation_id=delete.observation_id)
-        deleted_count += 1
 
     # Build per-memory result dicts for the stats tracker in the outer loop
     results: list[dict[str, Any]] = []
@@ -728,7 +680,7 @@ async def _process_memory_batch(
         else:
             results.append({"action": "skipped", "reason": "no_durable_knowledge"})
 
-    return results, deleted_count
+    return results
 
 
 def _min_date(dates: "Any") -> "datetime | None":
@@ -1077,8 +1029,8 @@ async def _create_observation_directly(
     # Create the observation as a memory_unit
     now = datetime.now(timezone.utc)
     obs_event_date = event_date or now
-    obs_occurred_start = occurred_start
-    obs_occurred_end = occurred_end
+    obs_occurred_start = occurred_start or now
+    obs_occurred_end = occurred_end or now
     obs_mentioned_at = mentioned_at or now
     obs_tags = tags or []
 

hindsight-api/hindsight_api/engine/memory_engine.py

@@ -15,19 +15,15 @@ import json
 import logging
 import time
 import uuid
-from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
-import asyncpg
-import httpx
 import tiktoken
 
 from ..config import get_config
 from ..metrics import get_metrics_collector
 from ..tracing import create_operation_span
 from ..utils import mask_network_location
-from ..worker.exceptions import RetryTaskAt
 from .db_budget import budgeted_operation
 from .operation_metadata import (
     BatchRetainChildMetadata,
@@ -187,7 +183,7 @@ from .response_models import RecallResult as RecallResultModel
 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.reranking import CrossEncoderReranker
 from .search.tags import TagsMatch, build_tags_where_clause
 from .task_backend import BrokerTaskBackend, SyncTaskBackend, TaskBackend
 
@@ -363,10 +359,6 @@ class MemoryEngine(MemoryEngineInterface):
         self._run_migrations = run_migrations
         self._retain_entity_lookup = config.retain_entity_lookup
 
-        # Webhook manager (will be created in initialize() after pool is ready)
-        self._webhook_manager = None
-        self._http_client: httpx.AsyncClient | None = None
-
         # Initialize entity resolver (will be created in initialize())
         self.entity_resolver = None
 
@@ -590,12 +582,6 @@ class MemoryEngine(MemoryEngineInterface):
             document_tags=document_tags,
             request_context=context,
             operation_id=operation_id,
-            outbox_callback=self._build_retain_outbox_callback(
-                bank_id=bank_id,
-                contents=contents,
-                operation_id=operation_id,
-                schema=_current_schema.get(),
-            ),
         )
 
         # If this retain was triggered by file conversion, update document with file metadata
@@ -792,7 +778,6 @@ class MemoryEngine(MemoryEngineInterface):
         )
 
         logger.info(f"[CONSOLIDATION] bank={bank_id} completed: {result.get('memories_processed', 0)} processed")
-        return result
 
     async def _handle_refresh_mental_model(self, task_dict: dict[str, Any]):
         """
@@ -964,18 +949,15 @@ class MemoryEngine(MemoryEngineInterface):
                 logger.error(f"Failed to check operation status {operation_id}: {e}")
                 # Continue with processing if we can't check status
 
-        consolidation_result: dict | None = None
         try:
             if task_type == "batch_retain":
                 await self._handle_batch_retain(task_dict)
             elif task_type == "file_convert_retain":
                 await self._handle_file_convert_retain(task_dict)
             elif task_type == "consolidation":
-                consolidation_result = await self._handle_consolidation(task_dict)
+                await self._handle_consolidation(task_dict)
             elif task_type == "refresh_mental_model":
                 await self._handle_refresh_mental_model(task_dict)
-            elif task_type == "webhook_delivery":
-                await self._handle_webhook_delivery(task_dict)
             else:
                 logger.error(f"Unknown task type: {task_type}")
                 # Don't retry unknown task types
@@ -985,22 +967,9 @@ class MemoryEngine(MemoryEngineInterface):
 
             # Task succeeded - mark operation as completed
             # file_convert_retain marks itself as completed in a transaction, skip double-marking
-            if operation_id and task_type not in ("file_convert_retain",):
-                if task_type == "consolidation":
-                    # Atomically mark completed AND queue webhook delivery in one transaction
-                    await self._mark_operation_completed_and_fire_webhook(
-                        operation_id=operation_id,
-                        bank_id=task_dict.get("bank_id", ""),
-                        status="completed",
-                        result=consolidation_result,
-                        schema=schema,
-                    )
-                else:
-                    await self._mark_operation_completed(operation_id)
+            if operation_id and task_type != "file_convert_retain":
+                await self._mark_operation_completed(operation_id)
 
-        except RetryTaskAt:
-            # Task-owned retry: let the poller handle scheduling
-            raise
         except Exception as e:
             logger.error(f"Task execution failed: {task_type}, error: {e}")
             import traceback
@@ -1015,193 +984,10 @@ class MemoryEngine(MemoryEngineInterface):
                 if operation_id:
                     await self._mark_operation_failed(operation_id, str(e), error_traceback)
             else:
-                if task_type == "consolidation" and operation_id:
-                    # Fire failure webhook (non-transactional — operation not yet marked failed;
-                    # poller will mark it failed after this raise)
-                    await self._fire_consolidation_webhook(
-                        bank_id=task_dict.get("bank_id", ""),
-                        operation_id=operation_id,
-                        status="failed",
-                        result=None,
-                        error_message=str(e),
-                        schema=schema,
-                    )
-                # Retryable: use RetryTaskAt if under the retry limit, else re-raise (poller marks failed)
-                retry_count = task_dict.get("_retry_count", 0)
-                if retry_count < 3:
-                    raise RetryTaskAt(retry_at=datetime.now(UTC) + timedelta(seconds=60), message=str(e))
+                # Retryable: re-raise so the worker poller handles retry/fail via _retry_or_fail,
+                # which correctly resets status='pending' and increments the DB retry_count.
                 raise
 
-    async def _fire_consolidation_webhook(
-        self,
-        bank_id: str,
-        operation_id: str,
-        status: str,
-        result: dict | None,
-        error_message: str | None = None,
-        schema: str | None = None,
-    ) -> None:
-        """Fire a consolidation webhook event. Non-fatal - logs errors but does not raise."""
-        if not self._webhook_manager:
-            return
-        try:
-            from datetime import datetime, timezone
-
-            from ..webhooks.models import ConsolidationEventData, WebhookEvent, WebhookEventType
-
-            data = ConsolidationEventData(
-                observations_created=result.get("observations_created") if result else None,
-                observations_updated=result.get("observations_updated") if result else None,
-                observations_deleted=result.get("observations_deleted") if result else None,
-                error_message=error_message,
-            )
-            event = WebhookEvent(
-                event=WebhookEventType.CONSOLIDATION_COMPLETED,
-                bank_id=bank_id,
-                operation_id=operation_id,
-                status=status,
-                timestamp=datetime.now(timezone.utc),
-                data=data,
-            )
-            await self._webhook_manager.fire_event(event, schema=schema)
-        except Exception as e:
-            logger.error(f"Failed to fire consolidation webhook for operation {operation_id}: {e}")
-
-    def _build_retain_outbox_callback(
-        self,
-        bank_id: str,
-        contents: list[dict],
-        operation_id: str | None,
-        schema: str | None = None,
-    ) -> "Callable[[asyncpg.Connection], Awaitable[None]] | None":
-        """Build a transactional outbox callback for retain.completed webhook events.
-
-        Returns a coroutine function that queues one webhook delivery row per content
-        item using the provided connection (inside the retain transaction). Returns None
-        if no webhook manager is configured.
-        """
-        webhook_manager = getattr(self, "_webhook_manager", None)
-        if not webhook_manager:
-            return None
-
-        from ..webhooks.models import RetainEventData, WebhookEvent, WebhookEventType
-
-        now = datetime.now(UTC)
-        op_id = operation_id or uuid.uuid4().hex
-        events = []
-        for content in contents:
-            doc_id = content.get("document_id")
-            tags = content.get("tags")
-            data = RetainEventData(
-                document_id=doc_id,
-                tags=tags if isinstance(tags, list) else None,
-            )
-            events.append(
-                WebhookEvent(
-                    event=WebhookEventType.RETAIN_COMPLETED,
-                    bank_id=bank_id,
-                    operation_id=op_id,
-                    status="completed",
-                    timestamp=now,
-                    data=data,
-                )
-            )
-
-        async def _callback(conn: asyncpg.Connection) -> None:
-            for event in events:
-                await webhook_manager.fire_event_with_conn(event, conn, schema=schema)
-
-        return _callback
-
-    async def _update_webhook_delivery_metadata(
-        self, operation_id: str, status_code: int | None, response_body: str | None
-    ) -> None:
-        """Persist last HTTP attempt info into async_operations.result_metadata."""
-        try:
-            pool = await self._get_pool()
-            meta = json.dumps(
-                {
-                    "last_status_code": status_code,
-                    "last_response_body": (response_body or "")[:2048],
-                    "last_attempt_at": datetime.now(UTC).isoformat(),
-                }
-            )
-            async with acquire_with_retry(pool) as conn:
-                await conn.execute(
-                    f"UPDATE {fq_table('async_operations')} SET result_metadata = $2::jsonb, updated_at = now() WHERE operation_id = $1",
-                    uuid.UUID(operation_id),
-                    meta,
-                )
-        except Exception as meta_err:
-            logger.debug(f"Failed to update webhook delivery metadata: {meta_err}")
-
-    async def _handle_webhook_delivery(self, task_dict: dict[str, Any]) -> None:
-        """Deliver a webhook event via HTTP.
-
-        Raises RetryTaskAt to schedule a retry on failure (up to MAX_ATTEMPTS).
-        Raises the original exception when retries are exhausted (poller marks failed).
-        Response status code and body are stored in result_metadata for debugging.
-        """
-        from ..webhooks.manager import MAX_ATTEMPTS, RETRY_DELAYS
-        from ..webhooks.models import WebhookHttpConfig
-
-        url = task_dict["url"]
-        secret = task_dict.get("secret")
-        event_type = task_dict["event_type"]
-        raw_payload = task_dict["payload"]
-        retry_count = task_dict.get("_retry_count", 0)
-        operation_id: str | None = task_dict.get("_operation_id")
-        http_config = WebhookHttpConfig.model_validate(task_dict.get("http_config") or {})
-
-        if isinstance(raw_payload, dict):
-            payload_bytes = json.dumps(raw_payload).encode()
-        else:
-            payload_bytes = str(raw_payload).encode()
-
-        headers: dict[str, str] = {
-            "Content-Type": "application/json",
-            "X-Hindsight-Event": event_type,
-            **http_config.headers,
-        }
-        if secret and self._webhook_manager:
-            headers["X-Hindsight-Signature"] = self._webhook_manager._sign_payload(secret, payload_bytes)
-
-        if self._http_client is None:
-            raise RuntimeError("HTTP client not initialized")
-
-        response = None
-        try:
-            request_kwargs: dict[str, Any] = {
-                "headers": headers,
-                "params": http_config.params if http_config.params else None,
-                "timeout": http_config.timeout_seconds,
-            }
-            if http_config.method.upper() == "GET":
-                response = await self._http_client.get(url, **request_kwargs)
-            else:
-                response = await self._http_client.post(url, content=payload_bytes, **request_kwargs)
-            response.raise_for_status()
-            if operation_id:
-                await self._update_webhook_delivery_metadata(operation_id, response.status_code, response.text)
-        except Exception as e:
-            status_code = response.status_code if response is not None else None
-            response_body = response.text if response is not None else None
-            if operation_id:
-                await self._update_webhook_delivery_metadata(operation_id, status_code, response_body)
-            if retry_count >= MAX_ATTEMPTS - 1:
-                logger.error(
-                    f"webhook_delivery permanently_failed url={url} attempts={retry_count + 1} "
-                    f"status_code={status_code} error={e}"
-                )
-                raise
-            delay = RETRY_DELAYS[retry_count] if retry_count < len(RETRY_DELAYS) else RETRY_DELAYS[-1]
-            retry_at = datetime.now(UTC) + timedelta(seconds=delay)
-            logger.warning(
-                f"webhook_delivery failed url={url} attempt={retry_count + 1}/{MAX_ATTEMPTS} "
-                f"status_code={status_code} retry_in={delay}s error={e}"
-            )
-            raise RetryTaskAt(retry_at=retry_at, message=str(e))
-
     async def _delete_operation_record(self, operation_id: str):
         """Helper to delete an operation record from the database."""
         try:
@@ -1272,58 +1058,6 @@ class MemoryEngine(MemoryEngineInterface):
         except Exception as e:
             logger.error(f"Failed to mark operation as completed {operation_id}: {e}")
 
-    async def _mark_operation_completed_and_fire_webhook(
-        self,
-        operation_id: str,
-        bank_id: str,
-        status: str,
-        result: dict | None,
-        schema: str | None = None,
-        error_message: str | None = None,
-    ) -> None:
-        """Mark an operation as completed and queue webhook deliveries in a single transaction.
-
-        Uses the transactional outbox pattern: the webhook delivery row is inserted in the
-        same database transaction as the status update. This guarantees at-least-once delivery
-        even if the process crashes immediately after committing.
-        """
-        from ..webhooks.models import ConsolidationEventData, WebhookEvent, WebhookEventType
-
-        try:
-            pool = await self._get_pool()
-            async with acquire_with_retry(pool) as conn:
-                async with conn.transaction():
-                    await conn.execute(
-                        f"""
-                        UPDATE {fq_table("async_operations")}
-                        SET status = 'completed', updated_at = NOW(), completed_at = NOW()
-                        WHERE operation_id = $1
-                        """,
-                        uuid.UUID(operation_id),
-                    )
-                    logger.info(f"Marked async operation as completed: {operation_id}")
-                    await self._maybe_update_parent_operation(operation_id, conn)
-
-                    # Queue webhook deliveries inside the same transaction
-                    if self._webhook_manager:
-                        data = ConsolidationEventData(
-                            observations_created=result.get("observations_created") if result else None,
-                            observations_updated=result.get("observations_updated") if result else None,
-                            observations_deleted=result.get("observations_deleted") if result else None,
-                            error_message=error_message,
-                        )
-                        event = WebhookEvent(
-                            event=WebhookEventType.CONSOLIDATION_COMPLETED,
-                            bank_id=bank_id,
-                            operation_id=operation_id,
-                            status=status,
-                            timestamp=datetime.now(UTC),
-                            data=data,
-                        )
-                        await self._webhook_manager.fire_event_with_conn(event, conn, schema=schema)
-        except Exception as e:
-            logger.error(f"Failed to mark operation completed and fire webhook {operation_id}: {e}")
-
     async def _maybe_update_parent_operation(self, child_operation_id: str, conn):
         """Check if this is a child operation and update parent status if all siblings are done.
 
@@ -1647,32 +1381,6 @@ class MemoryEngine(MemoryEngineInterface):
         else:
             logger.debug("Iris parser not registered (VECTORIZE_TOKEN or VECTORIZE_ORG_ID not set)")
 
-        # Initialize webhook manager
-        from ..webhooks import WebhookManager
-        from ..webhooks.models import WebhookConfig
-
-        webhook_global: list[WebhookConfig] = []
-        if config.webhook_url:
-            webhook_global = [
-                WebhookConfig(
-                    id="",  # No DB row for env-configured global webhook
-                    bank_id=None,
-                    url=config.webhook_url,
-                    secret=config.webhook_secret,
-                    event_types=config.webhook_event_types,
-                    enabled=True,
-                )
-            ]
-        self._webhook_manager = WebhookManager(
-            pool=self._pool,
-            global_webhooks=webhook_global,
-            tenant_extension=self._tenant_extension,
-        )
-        logger.debug("Webhook manager initialized")
-
-        # Long-lived HTTP client for webhook delivery tasks
-        self._http_client = httpx.AsyncClient(timeout=30.0)
-
         # Set executor for task backend and initialize
         self._task_backend.set_executor(self.execute_task)
         await self._task_backend.initialize()
@@ -1732,11 +1440,6 @@ class MemoryEngine(MemoryEngineInterface):
         # Shutdown task backend
         await self._task_backend.shutdown()
 
-        # Close HTTP client used for webhook delivery
-        if self._http_client is not None:
-            await self._http_client.aclose()
-            self._http_client = None
-
         # Close pool
         if self._pool is not None:
             self._pool.terminate()
@@ -1877,7 +1580,6 @@ class MemoryEngine(MemoryEngineInterface):
         document_tags: list[str] | None = None,
         return_usage: bool = False,
         operation_id: str | None = None,
-        outbox_callback: "Callable[[asyncpg.Connection], Awaitable[None]] | None" = None,
     ):
         """
         Store multiple content items as memory units in ONE batch operation.
@@ -2026,9 +1728,6 @@ class MemoryEngine(MemoryEngineInterface):
                     confidence_score=confidence_score,
                     document_tags=document_tags,
                     operation_id=operation_id,
-                    # 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,
                 )
                 all_results.extend(sub_results)
                 total_usage = total_usage + sub_usage
@@ -2050,7 +1749,6 @@ class MemoryEngine(MemoryEngineInterface):
                 confidence_score=confidence_score,
                 document_tags=document_tags,
                 operation_id=operation_id,
-                outbox_callback=outbox_callback,
             )
 
         # Call post-operation hook if validator is configured
@@ -2101,7 +1799,6 @@ class MemoryEngine(MemoryEngineInterface):
         confidence_score: float | None = None,
         document_tags: list[str] | None = None,
         operation_id: str | None = None,
-        outbox_callback: "Callable[[asyncpg.Connection], Awaitable[None]] | None" = None,
     ) -> tuple[list[list[str]], "TokenUsage"]:
         """
         Internal method for batch processing without chunking logic.
@@ -2152,7 +1849,6 @@ class MemoryEngine(MemoryEngineInterface):
                     config=resolved_config,
                     operation_id=operation_id,
                     schema=request_context.tenant_id if request_context else None,
-                    outbox_callback=outbox_callback,
                 )
 
     def recall(
@@ -2858,12 +2554,57 @@ class MemoryEngine(MemoryEngineInterface):
                     rerank_span.set_attribute("hindsight.pre_filtered_count", pre_filtered_count)
                 rerank_span.end()
 
-            # Step 4.5: Combine cross-encoder score with retrieval signals via multiplicative boosts.
-            # See apply_combined_scoring for the full rationale and formula.
+            # Step 4.5: Combine cross-encoder score with retrieval signals
+            # This preserves retrieval work (RRF, temporal, recency) instead of pure cross-encoder ranking
             if scored_results:
-                apply_combined_scoring(scored_results, now=utcnow())
+                # Normalize RRF scores to [0, 1] range using min-max normalization
+                rrf_scores = [sr.candidate.rrf_score for sr in scored_results]
+                max_rrf = max(rrf_scores) if rrf_scores else 0.0
+                min_rrf = min(rrf_scores) if rrf_scores else 0.0
+                rrf_range = max_rrf - min_rrf  # Don't force to 1.0, let fallback handle it
+
+                # Calculate recency based on occurred_start (more recent = higher score)
+                now = utcnow()
+                for sr in scored_results:
+                    # Normalize RRF score (0-1 range, 0.5 if all same)
+                    if rrf_range > 0:
+                        sr.rrf_normalized = (sr.candidate.rrf_score - min_rrf) / rrf_range
+                    else:
+                        # All RRF scores are the same, use neutral value
+                        sr.rrf_normalized = 0.5
+
+                    # Calculate recency (decay over 365 days, minimum 0.1)
+                    sr.recency = 0.5  # default for missing dates
+                    if sr.retrieval.occurred_start:
+                        occurred = sr.retrieval.occurred_start
+                        if hasattr(occurred, "tzinfo") and occurred.tzinfo is None:
+                            occurred = occurred.replace(tzinfo=UTC)
+                        days_ago = (now - occurred).total_seconds() / 86400
+                        sr.recency = max(0.1, 1.0 - (days_ago / 365))  # Linear decay over 1 year
+
+                    # Get temporal proximity if available (already 0-1)
+                    sr.temporal = (
+                        sr.retrieval.temporal_proximity if sr.retrieval.temporal_proximity is not None else 0.5
+                    )
+
+                    # Weighted combination
+                    # Cross-encoder: 60% (semantic relevance)
+                    # RRF: 20% (retrieval consensus)
+                    # Temporal proximity: 10% (time relevance for temporal queries)
+                    # Recency: 10% (prefer recent facts)
+                    sr.combined_score = (
+                        0.6 * sr.cross_encoder_score_normalized
+                        + 0.2 * sr.rrf_normalized
+                        + 0.1 * sr.temporal
+                        + 0.1 * sr.recency
+                    )
+                    sr.weight = sr.combined_score  # Update weight for final ranking
+
+                # Re-sort by combined score
                 scored_results.sort(key=lambda x: x.weight, reverse=True)
-                log_buffer.append("  [4.6] Combined scoring: ce * recency_boost(0.2) * temporal_boost(0.2)")
+                log_buffer.append(
+                    "  [4.6] Combined scoring: cross_encoder(0.6) + rrf(0.2) + temporal(0.1) + recency(0.1)"
+                )
 
             # Add reranked results to tracer AFTER combined scoring (so normalized values are included)
             if tracer:
@@ -2891,53 +2632,15 @@ class MemoryEngine(MemoryEngineInterface):
             if include_chunks and top_scored:
                 from .response_models import ChunkInfo
 
-                # Collect chunk_ids in order of fact relevance (preserving order from top_scored).
-                # Observations have no direct chunk_id — use a placeholder so their source
-                # chunks end up at the observation's rank position, not appended at the end.
-                # ordered_items: list of ('chunk', chunk_id) | ('obs', sr.id)
-                ordered_items: list[tuple[str, str]] = []
-                seen_chunk_ids: set[str] = set()
-                observation_ids_ordered: list[uuid.UUID] = []
+                # Collect chunk_ids in order of fact relevance (preserving order from top_scored)
+                # Use a list to maintain order, but track seen chunks to avoid duplicates
+                chunk_ids_ordered = []
+                seen_chunk_ids = set()
                 for sr in top_scored:
                     chunk_id = sr.retrieval.chunk_id
                     if chunk_id and chunk_id not in seen_chunk_ids:
-                        ordered_items.append(("chunk", chunk_id))
+                        chunk_ids_ordered.append(chunk_id)
                         seen_chunk_ids.add(chunk_id)
-                    elif not chunk_id and sr.retrieval.fact_type == "observation":
-                        ordered_items.append(("obs", sr.id))
-                        observation_ids_ordered.append(uuid.UUID(sr.id))
-
-                # Resolve source chunk_ids for all observations in a single query,
-                # ordered by observation rank so per-observation results stay grouped correctly.
-                obs_chunk_ids: dict[str, list[str]] = {}
-                if observation_ids_ordered:
-                    async with acquire_with_retry(pool) as obs_conn:
-                        obs_source_rows = await obs_conn.fetch(
-                            f"""
-                            SELECT obs.id AS obs_id, mu.chunk_id
-                            FROM {fq_table("memory_units")} obs
-                            JOIN {fq_table("memory_units")} mu
-                              ON mu.id = ANY(obs.source_memory_ids)
-                            WHERE obs.id = ANY($1::uuid[])
-                              AND mu.chunk_id IS NOT NULL
-                            ORDER BY array_position($1::uuid[], obs.id)
-                            """,
-                            observation_ids_ordered,
-                        )
-                    for row in obs_source_rows:
-                        obs_id = str(row["obs_id"])
-                        cid = row["chunk_id"]
-                        if cid not in seen_chunk_ids:
-                            obs_chunk_ids.setdefault(obs_id, []).append(cid)
-                            seen_chunk_ids.add(cid)
-
-                # Flatten ordered_items into chunk_ids_ordered, expanding obs placeholders
-                chunk_ids_ordered = []
-                for item_type, item_id in ordered_items:
-                    if item_type == "chunk":
-                        chunk_ids_ordered.append(item_id)
-                    else:
-                        chunk_ids_ordered.extend(obs_chunk_ids.get(item_id, []))
 
                 if chunk_ids_ordered:
                     chunks_dict = {}

hindsight-api/hindsight_api/engine/mental_models/__init__.py

@@ -0,0 +1,14 @@
+"""
+Mental models module for Hindsight.
+
+Mental models contain directives - hard rules that are injected into reflect prompts.
+Directives are user-defined and their observations are user-provided (not LLM-generated).
+
+Other types of consolidated knowledge are handled by:
+- Learnings: Automatic bottom-up consolidation from facts
+- Pinned Reflections: User-curated living documents
+"""
+
+from .models import MentalModel, MentalModelSubtype
+
+__all__ = ["MentalModel", "MentalModelSubtype"]

hindsight-api/hindsight_api/engine/mental_models/models.py

@@ -0,0 +1,53 @@
+"""
+Pydantic models for mental models.
+"""
+
+from datetime import datetime, timezone
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class MentalModelSubtype(str, Enum):
+    """Subtype of mental model.
+
+    Currently only DIRECTIVE is supported. Other types of consolidated knowledge
+    are handled by:
+    - Learnings: Automatic bottom-up consolidation from facts
+    - Pinned Reflections: User-curated living documents
+    """
+
+    DIRECTIVE = "directive"  # User-defined hard rules, observations user-provided
+
+
+class MentalModel(BaseModel):
+    """
+    A mental model representing synthesized understanding.
+
+    Mental models are the agent's consolidated knowledge. Unlike raw facts,
+    mental models provide:
+    - A one-liner description for quick scanning/retrieval
+    - A full summary for deep understanding
+    - Links to related mental models
+    """
+
+    id: str = Field(description="Unique identifier within the bank")
+    bank_id: str = Field(description="Bank this mental model belongs to")
+    subtype: MentalModelSubtype = Field(description="How this model was created")
+    name: str = Field(description="Human-readable name")
+    description: str = Field(description="One-liner for quick scanning and retrieval matching")
+    summary: str | None = Field(default=None, description="Full synthesized understanding")
+
+    # References
+    entity_id: str | None = Field(default=None, description="Reference to entities table when type=entity")
+    source_facts: list[str] = Field(default_factory=list, description="Fact IDs used to generate summary")
+    links: list[str] = Field(default_factory=list, description="Related mental model IDs")
+
+    # Tags for scoped visibility (similar to document tags)
+    tags: list[str] = Field(default_factory=list, description="Tags for scoped visibility filtering")
+
+    # Timestamps
+    last_updated: datetime | None = Field(default=None, description="When summary was last regenerated")
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="When this model was created"
+    )

hindsight-api/hindsight_api/engine/retain/fact_extraction.py

@@ -944,15 +944,16 @@ async def _extract_facts_from_chunk(
     user_message = _build_user_message(chunk, chunk_index, total_chunks, event_date, context, metadata)
 
     # Retry logic for JSON validation errors
-    # Use retain-specific overrides if set, otherwise fall back to global LLM config
-    llm_max_retries = (
-        config.retain_llm_max_retries if config.retain_llm_max_retries is not None else config.llm_max_retries
-    )
-    last_error: Exception | None = None
+    max_retries = 2
+    last_error = None
 
     usage = TokenUsage()  # Track cumulative usage across retries
-    for attempt in range(llm_max_retries):
+    for attempt in range(max_retries):
         try:
+            # Use retain-specific overrides if set, otherwise fall back to global LLM config
+            max_retries = (
+                config.retain_llm_max_retries if config.retain_llm_max_retries is not None else config.llm_max_retries
+            )
             initial_backoff = (
                 config.retain_llm_initial_backoff
                 if config.retain_llm_initial_backoff is not None
@@ -968,7 +969,7 @@ async def _extract_facts_from_chunk(
                 scope="retain_extract_facts",
                 temperature=0.1,
                 max_completion_tokens=config.retain_max_completion_tokens,
-                max_retries=llm_max_retries,
+                max_retries=max_retries,
                 initial_backoff=initial_backoff,
                 max_backoff=max_backoff,
                 skip_validation=True,  # Get raw JSON, we'll validate leniently
@@ -982,14 +983,14 @@ async def _extract_facts_from_chunk(
 
             # Handle malformed LLM responses
             if not isinstance(extraction_response_json, dict):
-                if attempt < llm_max_retries - 1:
+                if attempt < max_retries - 1:
                     logger.warning(
-                        f"LLM returned non-dict JSON on attempt {attempt + 1}/{llm_max_retries}: {type(extraction_response_json).__name__}. Retrying..."
+                        f"LLM returned non-dict JSON on attempt {attempt + 1}/{max_retries}: {type(extraction_response_json).__name__}. Retrying..."
                     )
                     continue
                 else:
                     logger.warning(
-                        f"LLM returned non-dict JSON after {llm_max_retries} attempts: {type(extraction_response_json).__name__}. "
+                        f"LLM returned non-dict JSON after {max_retries} attempts: {type(extraction_response_json).__name__}. "
                         f"Raw: {str(extraction_response_json)[:500]}"
                     )
                     return [], usage
@@ -1205,9 +1206,9 @@ async def _extract_facts_from_chunk(
                     continue
 
             # If we got malformed facts and haven't exhausted retries, try again
-            if has_malformed_facts and len(chunk_facts) < len(raw_facts) * 0.8 and attempt < llm_max_retries - 1:
+            if has_malformed_facts and len(chunk_facts) < len(raw_facts) * 0.8 and attempt < max_retries - 1:
                 logger.warning(
-                    f"Got {len(raw_facts) - len(chunk_facts)} malformed facts out of {len(raw_facts)} on attempt {attempt + 1}/{llm_max_retries}. Retrying..."
+                    f"Got {len(raw_facts) - len(chunk_facts)} malformed facts out of {len(raw_facts)} on attempt {attempt + 1}/{max_retries}. Retrying..."
                 )
                 continue
 
@@ -1240,18 +1241,16 @@ async def _extract_facts_from_chunk(
 
             if "json_validate_failed" in str(e):
                 logger.warning(
-                    f"          [1.3.{chunk_index + 1}] Attempt {attempt + 1}/{llm_max_retries} failed with JSON validation error: {e}"
+                    f"          [1.3.{chunk_index + 1}] Attempt {attempt + 1}/{max_retries} failed with JSON validation error: {e}"
                 )
-                if attempt < llm_max_retries - 1:
+                if attempt < max_retries - 1:
                     logger.info(f"          [1.3.{chunk_index + 1}] Retrying...")
                     continue
             # If it's not a JSON validation error or we're out of retries, re-raise
             raise
 
-    # If we exhausted all retries, raise the last error or a descriptive fallback
-    if last_error is not None:
-        raise last_error
-    raise RuntimeError(f"Fact extraction failed after {llm_max_retries} attempts: LLM did not return valid JSON")
+    # If we exhausted all retries, raise the last error
+    raise last_error
 
 
 async def _extract_facts_with_auto_split(

hindsight-api/hindsight_api/engine/retain/orchestrator.py

@@ -7,7 +7,6 @@ Coordinates all retain pipeline modules to store memories efficiently.
 import logging
 import time
 import uuid
-from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime
 from typing import Any
 
@@ -53,8 +52,6 @@ def parse_datetime_flexible(value: Any) -> datetime:
         raise TypeError(f"Expected datetime or string, got {type(value).__name__}")
 
 
-import asyncpg
-
 from ..response_models import TokenUsage
 from . import (
     chunk_storage,
@@ -85,7 +82,6 @@ async def retain_batch(
     document_tags: list[str] | None = None,
     operation_id: str | None = None,
     schema: str | None = None,
-    outbox_callback: Callable[["asyncpg.Connection"], Awaitable[None]] | None = None,
 ) -> tuple[list[list[str]], TokenUsage]:
     """
     Process a batch of content through the retain pipeline.
@@ -488,11 +484,6 @@ async def retain_batch(
             # Map results back to original content items
             result_unit_ids = _map_results_to_contents(contents, extracted_facts, unit_ids)
 
-            # Transactional outbox: queue any side-effect tasks (e.g. webhook deliveries)
-            # inside the same transaction so they are atomically committed with the retain data.
-            if outbox_callback:
-                await outbox_callback(conn)
-
         # Flush entity stats (mention_count / last_seen) now that the transaction
         # has committed.  Uses a fresh pool connection — no locks held.
         await entity_resolver.flush_pending_stats()

hindsight-api/hindsight_api/engine/search/link_expansion_retrieval.py

@@ -395,28 +395,27 @@ class LinkExpansionRetriever(GraphRetriever):
                 WHERE id = ANY($1::uuid[])
                   AND source_memory_ids IS NOT NULL
             ),
-            connected_sources AS (
-                -- Mirror the non-observation entity expansion: follow pre-bounded entity
-                -- links in memory_links (capped to MAX_LINKS_PER_ENTITY=50 at retain time).
-                -- Score = number of distinct shared entities, same as the non-obs path.
-                SELECT DISTINCT ml.to_unit_id AS source_id
+            source_entities AS (
+                SELECT DISTINCT ue.entity_id
                 FROM seed_sources ss
-                JOIN {fq_table("memory_links")} ml ON ml.from_unit_id = ss.source_id
-                WHERE ml.link_type = 'entity'
+                JOIN {fq_table("unit_entities")} ue ON ss.source_id = ue.unit_id
             ),
-            connected_array AS (
-                SELECT array_agg(source_id) AS source_ids FROM connected_sources
+            all_connected_sources AS (
+                SELECT DISTINCT other_ue.unit_id AS source_id
+                FROM source_entities se
+                JOIN {fq_table("unit_entities")} other_ue ON se.entity_id = other_ue.entity_id
             )
             SELECT
                 mu.id, mu.text, mu.context, mu.event_date, mu.occurred_start,
                 mu.occurred_end, mu.mentioned_at,
                 mu.fact_type, mu.document_id, mu.chunk_id, mu.tags,
-                (SELECT COUNT(DISTINCT s) FROM unnest(mu.source_memory_ids) s WHERE s = ANY(ca.source_ids))::float AS score
-            FROM {fq_table("memory_units")} mu, connected_array ca
+                COUNT(DISTINCT cs.source_id)::float AS score
+            FROM all_connected_sources cs
+            JOIN {fq_table("memory_units")} mu
+                ON mu.source_memory_ids @> ARRAY[cs.source_id]
             WHERE mu.fact_type = 'observation'
               AND mu.id != ALL($1::uuid[])
-              AND ca.source_ids IS NOT NULL
-              AND mu.source_memory_ids && ca.source_ids
+            GROUP BY mu.id
             ORDER BY score DESC
             LIMIT $2
             """,

hindsight-api/hindsight_api/engine/search/reranking.py

@@ -2,72 +2,8 @@
 Cross-encoder neural reranking for search results.
 """
 
-from datetime import datetime, timezone
-
 from .types import MergedCandidate, ScoredResult
 
-UTC = timezone.utc
-
-# Multiplicative boost alphas for recency and temporal proximity.
-# Each signal contributes at most ±(alpha/2) relative adjustment to the base CE score,
-# so the max combined boost is (1 + alpha/2)^2 ≈ +21% and min is (1 - alpha/2)^2 ≈ -19%.
-_RECENCY_ALPHA: float = 0.2
-_TEMPORAL_ALPHA: float = 0.2
-
-
-def apply_combined_scoring(
-    scored_results: list[ScoredResult],
-    now: datetime,
-    recency_alpha: float = _RECENCY_ALPHA,
-    temporal_alpha: float = _TEMPORAL_ALPHA,
-) -> None:
-    """Apply combined scoring to a list of ScoredResults in-place.
-
-    Uses the cross-encoder score as the primary relevance signal, with recency
-    and temporal proximity applied as multiplicative boosts. This ensures the
-    influence of these secondary signals is always proportional to the base
-    relevance score, regardless of the cross-encoder model's score calibration.
-
-    Formula::
-
-        recency_boost  = 1 + recency_alpha  * (recency  - 0.5)   # in [1-α/2, 1+α/2]
-        temporal_boost = 1 + temporal_alpha * (temporal - 0.5)   # in [1-α/2, 1+α/2]
-        combined_score = cross_encoder_score_normalized * recency_boost * temporal_boost
-
-    Temporal proximity is treated as neutral (0.5) when not set by temporal retrieval,
-    so temporal_boost collapses to 1.0 for non-temporal queries.
-
-    Args:
-        scored_results: Results from the cross-encoder reranker. Mutated in place.
-        now: Current UTC datetime for recency calculation.
-        recency_alpha: Max relative recency adjustment (default 0.2 → ±10%).
-        temporal_alpha: Max relative temporal adjustment (default 0.2 → ±10%).
-    """
-    if now.tzinfo is None:
-        now = now.replace(tzinfo=UTC)
-
-    for sr in scored_results:
-        # Recency: linear decay over 365 days → [0.1, 1.0]; neutral 0.5 if no date.
-        sr.recency = 0.5
-        if sr.retrieval.occurred_start:
-            occurred = sr.retrieval.occurred_start
-            if occurred.tzinfo is None:
-                occurred = occurred.replace(tzinfo=UTC)
-            days_ago = (now - occurred).total_seconds() / 86400
-            sr.recency = max(0.1, min(1.0, 1.0 - (days_ago / 365)))
-
-        # Temporal proximity: meaningful only for temporal queries; neutral otherwise.
-        sr.temporal = sr.retrieval.temporal_proximity if sr.retrieval.temporal_proximity is not None else 0.5
-
-        # RRF: kept at 0.0 for trace continuity but excluded from scoring.
-        # RRF is batch-relative (min-max normalised) and redundant after reranking.
-        sr.rrf_normalized = 0.0
-
-        recency_boost = 1.0 + recency_alpha * (sr.recency - 0.5)
-        temporal_boost = 1.0 + temporal_alpha * (sr.temporal - 0.5)
-        sr.combined_score = sr.cross_encoder_score_normalized * recency_boost * temporal_boost
-        sr.weight = sr.combined_score
-
 
 class CrossEncoderReranker:
     """

hindsight-api/hindsight_api/extensions/context.py

@@ -96,8 +96,6 @@ class DefaultExtensionContext(ExtensionContext):
 
     async def run_migration(self, schema: str) -> None:
         """Run migrations for a specific schema."""
-        import asyncio
-
         from hindsight_api.config import get_config
         from hindsight_api.migrations import (
             ensure_embedding_dimension,
@@ -113,14 +111,10 @@ class DefaultExtensionContext(ExtensionContext):
             if engine_url:
                 db_url = engine_url
 
-        # Run synchronous migration functions in a thread so the asyncio event loop
-        # remains free. This is critical for single-machine deployments where the
-        # worker runs in-process: if run_migrations() blocks the event loop, any
-        # in-flight asyncpg transactions cannot flush their COMMIT, and
-        # CREATE INDEX CONCURRENTLY inside the migration waits for those transactions
-        # forever — a deadlock.
+        run_migrations(db_url, schema=schema)
+
+        # Get config for vector extension setting
         config = get_config()
-        await asyncio.to_thread(run_migrations, db_url, schema=schema)
 
         # Ensure embedding column dimension matches the model's dimension
         # This is needed because migrations create columns with default dimension
@@ -129,23 +123,15 @@ class DefaultExtensionContext(ExtensionContext):
             if embeddings is not None:
                 dimension = getattr(embeddings, "dimension", None)
                 if dimension is not None:
-                    await asyncio.to_thread(
-                        ensure_embedding_dimension,
-                        db_url,
-                        dimension,
-                        schema=schema,
-                        vector_extension=config.vector_extension,
+                    ensure_embedding_dimension(
+                        db_url, dimension, schema=schema, vector_extension=config.vector_extension
                     )
 
         # Ensure vector indexes match the configured extension
-        await asyncio.to_thread(
-            ensure_vector_extension, db_url, vector_extension=config.vector_extension, schema=schema
-        )
+        ensure_vector_extension(db_url, vector_extension=config.vector_extension, schema=schema)
 
         # Ensure text search columns/indexes match the configured extension
-        await asyncio.to_thread(
-            ensure_text_search_extension, db_url, text_search_extension=config.text_search_extension, schema=schema
-        )
+        ensure_text_search_extension(db_url, text_search_extension=config.text_search_extension, schema=schema)
 
     def get_memory_engine(self) -> "MemoryEngineInterface":
         """Get the memory engine interface."""

hindsight-api/hindsight_api/main.py

@@ -307,10 +307,6 @@ def main():
             otel_exporter_otlp_headers=config.otel_exporter_otlp_headers,
             otel_service_name=config.otel_service_name,
             otel_deployment_environment=config.otel_deployment_environment,
-            webhook_url=config.webhook_url,
-            webhook_secret=config.webhook_secret,
-            webhook_event_types=config.webhook_event_types,
-            webhook_delivery_poll_interval_seconds=config.webhook_delivery_poll_interval_seconds,
         )
     config.configure_logging()
     if not args.daemon:
@@ -389,7 +385,6 @@ def main():
         "ws": "wsproto",  # Use wsproto instead of websockets to avoid deprecation warnings
         "loop": loop_impl,  # Explicitly set event loop implementation
         "timeout_keep_alive": 30,  # Exceed aiohttp's 15s client timeout so the client always closes first
-        "timeout_graceful_shutdown": 5,  # Cap graceful shutdown at 5s; also enables force-kill on second Ctrl+C
     }
 
     # Add optional parameters if provided

hindsight-api/hindsight_api/mcp_tools.py

@@ -271,71 +271,48 @@ def register_mcp_tools(
 def _apply_bank_tool_filtering(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig) -> None:
     """Filter bank-level mcp_enabled_tools from both tools/list and tool invocation.
 
-    Compatible with FastMCP 2.x (_tool_manager pattern) and 3.x (provider pattern).
+    Wraps _tool_manager.get_tools() so that:
+    - tools/list only returns permitted tools (they are hidden, not just blocked)
+    - tools/call for a disabled tool raises NotFoundError (via the manager) before run()
+
+    tool.run wrappers are kept as defense-in-depth for any caller that bypasses the manager.
     """
+    try:
+        tool_manager = mcp._tool_manager
+        original_get_tools = tool_manager.get_tools
 
-    async def _get_enabled_tools() -> set[str] | None:
-        """Return the enabled tool set for the current bank, or None if unrestricted."""
-        bank_id = config.bank_id_resolver()
-        if not bank_id:
-            return None
-        request_context = _get_request_context(config)
-        bank_cfg = await memory._config_resolver.get_bank_config(bank_id, request_context)
-        enabled: list[str] | None = bank_cfg.get("mcp_enabled_tools")
-        if enabled is None:
-            return None
-        return set(enabled)
+        async def _filtered_get_tools():
+            all_tools = await original_get_tools()
+            bank_id = config.bank_id_resolver()
+            if not bank_id:
+                return all_tools
+            request_context = _get_request_context(config)
+            bank_cfg = await memory._config_resolver.get_bank_config(bank_id, request_context)
+            enabled: list[str] | None = bank_cfg.get("mcp_enabled_tools")
+            if enabled is None:
+                return all_tools
+            enabled_set = set(enabled)
+            return {k: v for k, v in all_tools.items() if k in enabled_set}
 
-    if hasattr(mcp, "list_tools"):
-        # FastMCP 3.x: wrap list_tools() and get_tool() on the instance
-        original_list_tools = mcp.list_tools
-        original_get_tool = mcp.get_tool
+        setattr(tool_manager, "get_tools", _filtered_get_tools)
 
-        async def _filtered_list_tools(**kwargs):
-            tools = await original_list_tools(**kwargs)
-            enabled_set = await _get_enabled_tools()
-            if enabled_set is None:
-                return tools
-            return [t for t in tools if t.name in enabled_set]
+        # Defense-in-depth: also wrap tool.run for any direct caller that bypasses the manager
+        for name, tool in tool_manager._tools.items():
+            original_run = tool.run
 
-        async def _filtered_get_tool(name, **kwargs):
-            enabled_set = await _get_enabled_tools()
-            if enabled_set is not None and name not in enabled_set:
-                return None  # FastMCP treats None as "not found" → raises NotFoundError
-            return await original_get_tool(name, **kwargs)
+            async def _filtered_run(arguments, _name=name, _orig=original_run):
+                bank_id = config.bank_id_resolver()
+                if bank_id:
+                    request_context = _get_request_context(config)
+                    bank_cfg = await memory._config_resolver.get_bank_config(bank_id, request_context)
+                    enabled: list[str] | None = bank_cfg.get("mcp_enabled_tools")
+                    if enabled is not None and _name not in enabled:
+                        raise ValueError(f"Tool '{_name}' is not enabled for bank '{bank_id}'")
+                return await _orig(arguments)
 
-        object.__setattr__(mcp, "list_tools", _filtered_list_tools)
-        object.__setattr__(mcp, "get_tool", _filtered_get_tool)
-
-    elif hasattr(mcp, "_tool_manager"):
-        # FastMCP 2.x: wrap _tool_manager.get_tools() and tool.run()
-        try:
-            tool_manager = mcp._tool_manager
-            original_get_tools = tool_manager.get_tools
-
-            async def _filtered_get_tools():
-                all_tools = await original_get_tools()
-                enabled_set = await _get_enabled_tools()
-                if enabled_set is None:
-                    return all_tools
-                return {k: v for k, v in all_tools.items() if k in enabled_set}
-
-            setattr(tool_manager, "get_tools", _filtered_get_tools)
-
-            for name, tool in tool_manager._tools.items():
-                original_run = tool.run
-
-                async def _filtered_run(arguments, _name=name, _orig=original_run):
-                    enabled_set = await _get_enabled_tools()
-                    if enabled_set is not None and _name not in enabled_set:
-                        raise ValueError(f"Tool '{_name}' is not enabled for bank '{config.bank_id_resolver()}'")
-                    return await _orig(arguments)
-
-                object.__setattr__(tool, "run", _filtered_run)
-        except (AttributeError, KeyError) as e:
-            logger.warning(f"Could not apply bank tool filtering (v2): {e}")
-    else:
-        logger.warning("Could not apply bank tool filtering: unknown FastMCP version")
+            object.__setattr__(tool, "run", _filtered_run)
+    except (AttributeError, KeyError) as e:
+        logger.warning(f"Could not apply bank tool filtering: {e}")
 
 
 def _register_retain(mcp: FastMCP, memory: MemoryEngine, config: MCPToolsConfig) -> None:

hindsight-api/hindsight_api/webhooks/__init__.py

@@ -1,13 +0,0 @@
-"""Webhook system for Hindsight API event notifications."""
-
-from .manager import WebhookManager
-from .models import ConsolidationEventData, RetainEventData, WebhookConfig, WebhookEvent, WebhookEventType
-
-__all__ = [
-    "WebhookManager",
-    "WebhookConfig",
-    "WebhookEvent",
-    "WebhookEventType",
-    "ConsolidationEventData",
-    "RetainEventData",
-]

hindsight-api/hindsight_api/webhooks/manager.py

@@ -1,242 +0,0 @@
-"""Webhook manager for delivering event notifications."""
-
-import hashlib
-import hmac
-import json
-import logging
-import uuid
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING
-
-import asyncpg
-
-from .models import WebhookConfig, WebhookEvent, WebhookHttpConfig
-
-if TYPE_CHECKING:
-    from hindsight_api.extensions.tenant import TenantExtension
-
-logger = logging.getLogger(__name__)
-
-# Retry delay schedule in seconds: 5 retries after the first attempt.
-# Fast early retries catch transient failures; later retries handle longer outages.
-RETRY_DELAYS = [5, 300, 1800, 7200, 18000]
-MAX_ATTEMPTS = len(RETRY_DELAYS) + 1  # first attempt + len(RETRY_DELAYS) retries
-
-
-def _fq_table(table: str, schema: str | None = None) -> str:
-    """Get fully-qualified table name with optional schema prefix."""
-    if schema:
-        return f'"{schema}".{table}'
-    return table
-
-
-def _parse_http_config(value: str | dict | None) -> WebhookHttpConfig:
-    """Parse http_config column value (JSONB returned as text or dict) into a model."""
-    if value is None:
-        return WebhookHttpConfig()
-    if isinstance(value, str):
-        return WebhookHttpConfig.model_validate_json(value)
-    return WebhookHttpConfig.model_validate(value)
-
-
-class WebhookManager:
-    """
-    Manages webhook registration and event firing.
-
-    Supports both global webhooks (configured via env vars) and per-bank
-    webhooks stored in the database. Deliveries are queued as async_operations
-    tasks (operation_type='webhook_delivery') and picked up by the worker poller.
-    """
-
-    def __init__(
-        self,
-        pool: asyncpg.Pool,
-        global_webhooks: list[WebhookConfig],
-        tenant_extension: "TenantExtension | None" = None,
-    ):
-        self._pool = pool
-        self._global_webhooks = global_webhooks
-        self._tenant_extension = tenant_extension
-
-    def _sign_payload(self, secret: str, payload_bytes: bytes) -> str:
-        """Compute HMAC-SHA256 signature for a payload."""
-        return "sha256=" + hmac.new(secret.encode(), payload_bytes, hashlib.sha256).hexdigest()
-
-    async def fire_event(self, event: WebhookEvent, schema: str | None = None) -> None:
-        """
-        Queue webhook deliveries for an event as async_operations tasks.
-
-        Loads per-bank and global webhooks, inserts pending webhook_delivery tasks for
-        any webhook whose event_types list matches the fired event type. The worker
-        poller picks these up and calls MemoryEngine._handle_webhook_delivery().
-
-        Args:
-            event: The event to deliver.
-            schema: Database schema (for multi-tenant). None = default schema.
-        """
-        webhook_table = _fq_table("webhooks", schema)
-        ops_table = _fq_table("async_operations", schema)
-        now = datetime.now(timezone.utc)
-        payload_str = event.model_dump_json()
-
-        try:
-            # Load per-bank webhooks from DB (bank-specific + global NULL rows)
-            rows = await self._pool.fetch(
-                f"""
-                SELECT id, bank_id, url, secret, event_types, enabled, http_config::text
-                FROM {webhook_table}
-                WHERE (bank_id = $1 OR bank_id IS NULL) AND enabled = true
-                """,
-                event.bank_id,
-            )
-
-            db_webhooks = [
-                WebhookConfig(
-                    id=str(row["id"]),
-                    bank_id=row["bank_id"],
-                    url=row["url"],
-                    secret=row["secret"],
-                    event_types=list(row["event_types"]) if row["event_types"] else [],
-                    enabled=row["enabled"],
-                    http_config=_parse_http_config(row["http_config"]),
-                )
-                for row in rows
-            ]
-
-            # Merge with global webhooks from env config
-            all_webhooks = self._global_webhooks + db_webhooks
-            matched = 0
-
-            for webhook in all_webhooks:
-                if not webhook.enabled:
-                    continue
-                if event.event.value not in webhook.event_types:
-                    continue
-
-                operation_id = uuid.uuid4()
-                webhook_id = webhook.id if webhook.id else None
-
-                task_payload = json.dumps(
-                    {
-                        "type": "webhook_delivery",
-                        "operation_id": str(operation_id),
-                        "bank_id": event.bank_id,
-                        "url": webhook.url,
-                        "secret": webhook.secret,
-                        "event_type": event.event.value,
-                        "payload": payload_str,
-                        "webhook_id": webhook_id,
-                        "http_config": webhook.http_config.model_dump(),
-                    }
-                )
-
-                await self._pool.execute(
-                    f"""
-                    INSERT INTO {ops_table}
-                      (operation_id, bank_id, operation_type, status, task_payload, result_metadata, created_at, updated_at)
-                    VALUES ($1, $2, 'webhook_delivery', 'pending', $3::jsonb, '{{}}'::jsonb, $4, $4)
-                    """,
-                    operation_id,
-                    event.bank_id,
-                    task_payload,
-                    now,
-                )
-                matched += 1
-
-            logger.debug(f"Fired webhook event {event.event} for bank {event.bank_id}: {matched} delivery(ies) queued")
-
-        except Exception as e:
-            logger.error(f"Failed to queue webhook deliveries for event {event.event}: {e}")
-
-    async def fire_event_with_conn(
-        self, event: WebhookEvent, conn: asyncpg.Connection, schema: str | None = None
-    ) -> None:
-        """
-        Queue webhook deliveries within an existing database connection/transaction.
-
-        Identical to fire_event() but uses the provided connection instead of acquiring
-        one from the pool. Use this to atomically insert delivery tasks in the same
-        transaction as the primary operation (transactional outbox pattern).
-
-        Args:
-            event: The event to deliver.
-            conn: Existing asyncpg connection (may be inside an active transaction).
-            schema: Database schema (for multi-tenant). None = default schema.
-        """
-        webhook_table = _fq_table("webhooks", schema)
-        ops_table = _fq_table("async_operations", schema)
-        now = datetime.now(timezone.utc)
-        payload_str = event.model_dump_json()
-
-        try:
-            rows = await conn.fetch(
-                f"""
-                SELECT id, bank_id, url, secret, event_types, enabled, http_config::text
-                FROM {webhook_table}
-                WHERE (bank_id = $1 OR bank_id IS NULL) AND enabled = true
-                """,
-                event.bank_id,
-            )
-
-            db_webhooks = [
-                WebhookConfig(
-                    id=str(row["id"]),
-                    bank_id=row["bank_id"],
-                    url=row["url"],
-                    secret=row["secret"],
-                    event_types=list(row["event_types"]) if row["event_types"] else [],
-                    enabled=row["enabled"],
-                    http_config=_parse_http_config(row["http_config"]),
-                )
-                for row in rows
-            ]
-
-            all_webhooks = self._global_webhooks + db_webhooks
-            matched = 0
-
-            for webhook in all_webhooks:
-                if not webhook.enabled:
-                    continue
-                if event.event.value not in webhook.event_types:
-                    continue
-
-                operation_id = uuid.uuid4()
-                webhook_id = webhook.id if webhook.id else None
-
-                task_payload = json.dumps(
-                    {
-                        "type": "webhook_delivery",
-                        "operation_id": str(operation_id),
-                        "bank_id": event.bank_id,
-                        "url": webhook.url,
-                        "secret": webhook.secret,
-                        "event_type": event.event.value,
-                        "payload": payload_str,
-                        "webhook_id": webhook_id,
-                        "http_config": webhook.http_config.model_dump(),
-                    }
-                )
-
-                await conn.execute(
-                    f"""
-                    INSERT INTO {ops_table}
-                      (operation_id, bank_id, operation_type, status, task_payload, result_metadata, created_at, updated_at)
-                    VALUES ($1, $2, 'webhook_delivery', 'pending', $3::jsonb, '{{}}'::jsonb, $4, $4)
-                    """,
-                    operation_id,
-                    event.bank_id,
-                    task_payload,
-                    now,
-                )
-                matched += 1
-
-            logger.debug(
-                f"Fired webhook event {event.event} for bank {event.bank_id}: {matched} delivery(ies) queued (in-transaction)"
-            )
-
-        except Exception as e:
-            logger.error(
-                f"Failed to queue webhook deliveries (in-transaction) for event {event.event}: {e}. "
-                "CRITICAL: The enclosing database transaction is now aborted and will roll back all changes."
-            )
-            raise

hindsight-api/hindsight_api/webhooks/models.py

@@ -1,51 +0,0 @@
-"""Pydantic models for the webhook system."""
-
-from datetime import datetime
-from enum import StrEnum
-
-from pydantic import BaseModel, Field
-
-
-class WebhookEventType(StrEnum):
-    CONSOLIDATION_COMPLETED = "consolidation.completed"
-    RETAIN_COMPLETED = "retain.completed"
-
-
-class ConsolidationEventData(BaseModel):
-    observations_created: int | None = None
-    observations_updated: int | None = None
-    observations_deleted: int | None = None
-    error_message: str | None = None
-
-
-class RetainEventData(BaseModel):
-    document_id: str | None = None
-    tags: list[str] | None = None
-
-
-class WebhookEvent(BaseModel):
-    event: WebhookEventType
-    bank_id: str
-    operation_id: str
-    status: str  # "completed" or "failed"
-    timestamp: datetime
-    data: ConsolidationEventData | RetainEventData
-
-
-class WebhookHttpConfig(BaseModel):
-    """HTTP delivery configuration for a webhook."""
-
-    method: str = Field(default="POST", description="HTTP method: GET or POST")
-    timeout_seconds: int = Field(default=30, description="HTTP request timeout in seconds")
-    headers: dict[str, str] = Field(default_factory=dict, description="Custom HTTP headers")
-    params: dict[str, str] = Field(default_factory=dict, description="Custom HTTP query parameters")
-
-
-class WebhookConfig(BaseModel):
-    id: str
-    bank_id: str | None
-    url: str
-    secret: str | None
-    event_types: list[str]
-    enabled: bool
-    http_config: WebhookHttpConfig = Field(default_factory=WebhookHttpConfig)

hindsight-api/hindsight_api/worker/exceptions.py

@@ -1,9 +0,0 @@
-from datetime import datetime
-
-
-class RetryTaskAt(Exception):
-    """Raise from a task handler to schedule a retry at a specific time."""
-
-    def __init__(self, retry_at: datetime, message: str = ""):
-        self.retry_at = retry_at
-        super().__init__(message)

hindsight-api/hindsight_api/worker/main.py

@@ -219,6 +219,7 @@ def main():
             worker_id=args.worker_id,
             executor=memory.execute_task,
             poll_interval_ms=args.poll_interval,
+            max_retries=args.max_retries,
             schema=schema,
             tenant_extension=tenant_extension,
             max_slots=config.worker_max_slots,

hindsight-api/hindsight_api/worker/poller.py

@@ -14,8 +14,6 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from .exceptions import RetryTaskAt
-
 if TYPE_CHECKING:
     import asyncpg
 
@@ -59,6 +57,7 @@ class WorkerPoller:
         worker_id: str,
         executor: Callable[[dict[str, Any]], Awaitable[None]],
         poll_interval_ms: int = 500,
+        max_retries: int = 3,
         schema: str | None = None,
         tenant_extension: "TenantExtension | None" = None,
         max_slots: int = 10,
@@ -72,6 +71,7 @@ class WorkerPoller:
             worker_id: Unique identifier for this worker
             executor: Async function to execute tasks (typically MemoryEngine.execute_task)
             poll_interval_ms: Interval between polls when no tasks found (milliseconds)
+            max_retries: Maximum retry attempts before marking task as failed
             schema: Database schema for single-tenant support (deprecated, use tenant_extension)
             tenant_extension: Extension for dynamic multi-tenant discovery. If None, creates a
                             DefaultTenantExtension with the configured schema.
@@ -82,6 +82,7 @@ class WorkerPoller:
         self._worker_id = worker_id
         self._executor = executor
         self._poll_interval_ms = poll_interval_ms
+        self._max_retries = max_retries
         self._schema = schema
         # Always set tenant extension (use DefaultTenantExtension if none provided)
         if tenant_extension is None:
@@ -217,12 +218,11 @@ class WorkerPoller:
                 # 1. Claim non-consolidation tasks (up to limit)
                 non_consolidation_rows = await conn.fetch(
                     f"""
-                    SELECT operation_id, task_payload, retry_count
+                    SELECT operation_id, task_payload
                     FROM {table}
                     WHERE status = 'pending'
                       AND task_payload IS NOT NULL
                       AND operation_type != 'consolidation'
-                      AND (next_retry_at IS NULL OR next_retry_at <= NOW())
                     ORDER BY created_at
                     LIMIT $1
                     FOR UPDATE SKIP LOCKED
@@ -238,12 +238,11 @@ class WorkerPoller:
                 if consolidation_limit > 0 and remaining_limit > 0:
                     consolidation_rows = await conn.fetch(
                         f"""
-                        SELECT operation_id, task_payload, retry_count
+                        SELECT operation_id, task_payload
                         FROM {table} AS pending
                         WHERE status = 'pending'
                           AND task_payload IS NOT NULL
                           AND operation_type = 'consolidation'
-                          AND (next_retry_at IS NULL OR next_retry_at <= NOW())
                           AND NOT EXISTS (
                               SELECT 1 FROM {table} AS processing
                               WHERE processing.bank_id = pending.bank_id
@@ -275,19 +274,14 @@ class WorkerPoller:
                 )
 
                 # Parse and return task payloads with schema context
-                result = []
-                for row in all_rows:
-                    task_dict = json.loads(row["task_payload"])
-                    task_dict["_retry_count"] = row["retry_count"]
-                    task_dict["_operation_id"] = str(row["operation_id"])
-                    result.append(
-                        ClaimedTask(
-                            operation_id=str(row["operation_id"]),
-                            task_dict=task_dict,
-                            schema=schema,
-                        )
+                return [
+                    ClaimedTask(
+                        operation_id=str(row["operation_id"]),
+                        task_dict=json.loads(row["task_payload"]),
+                        schema=schema,
                     )
-                return result
+                    for row in all_rows
+                ]
 
     async def _mark_completed(self, operation_id: str, schema: str | None):
         """Mark a task as completed."""
@@ -316,22 +310,40 @@ class WorkerPoller:
             error_message,
         )
 
-    async def _schedule_retry(self, operation_id: str, retry_at: "Any", error_message: str, schema: str | None):
-        """Reset task to pending with a future retry timestamp."""
+    async def _retry_or_fail(self, operation_id: str, error_message: str, schema: str | None):
+        """Increment retry count or mark as failed if max retries exceeded."""
         table = fq_table("async_operations", schema)
-        error_message = error_message[:5000] if len(error_message) > 5000 else error_message
-        await self._pool.execute(
-            f"""
-            UPDATE {table}
-            SET status = 'pending', next_retry_at = $2, worker_id = NULL, claimed_at = NULL,
-                retry_count = retry_count + 1, error_message = $3, updated_at = now()
-            WHERE operation_id = $1
-            """,
+
+        # Get current retry count
+        row = await self._pool.fetchrow(
+            f"SELECT retry_count FROM {table} WHERE operation_id = $1",
             operation_id,
-            retry_at,
-            error_message,
         )
-        logger.warning(f"Task {operation_id} scheduled for retry at {retry_at}: {error_message}")
+
+        if row is None:
+            logger.warning(f"Operation {operation_id} not found, cannot retry")
+            return
+
+        retry_count = row["retry_count"]
+
+        if retry_count >= self._max_retries:
+            # Max retries exceeded, mark as failed
+            await self._mark_failed(
+                operation_id, f"Max retries ({self._max_retries}) exceeded. Last error: {error_message}", schema
+            )
+            logger.error(f"Task {operation_id} failed after {retry_count} retries")
+        else:
+            # Increment retry and reset to pending
+            await self._pool.execute(
+                f"""
+                UPDATE {table}
+                SET status = 'pending', worker_id = NULL, claimed_at = NULL,
+                    retry_count = retry_count + 1, updated_at = now()
+                WHERE operation_id = $1
+                """,
+                operation_id,
+            )
+            logger.warning(f"Task {operation_id} failed, will retry (attempt {retry_count + 1}/{self._max_retries})")
 
     async def execute_task(self, task: ClaimedTask):
         """Execute a single task as a background job (fire-and-forget)."""
@@ -366,10 +378,11 @@ class WorkerPoller:
     async def _execute_task_inner(self, task: ClaimedTask):
         """Inner task execution with retry/fail handling.
 
-        Tasks that want to be retried raise RetryTaskAt; the poller sets next_retry_at
-        and resets status to 'pending'. All other exceptions are marked as failed immediately.
-        Non-retryable failures (e.g., file_convert_retain) are handled by the executor
-        internally — it marks the operation as failed and returns normally.
+        Retryable task failures are re-raised by the executor (MemoryEngine.execute_task)
+        and handled here via _retry_or_fail, which resets status='pending' (or marks as
+        'failed' after max retries). Non-retryable failures (e.g., file_convert_retain) are
+        handled by the executor internally — it marks the operation as failed and returns
+        normally, so no exception reaches here.
         """
         task_type = task.task_dict.get("type", "unknown")
         bank_id = task.task_dict.get("bank_id", "unknown")
@@ -381,12 +394,10 @@ class WorkerPoller:
                 task.task_dict["_schema"] = task.schema
             await self._executor(task.task_dict)
             logger.debug(f"Task {task.operation_id} execution finished")
-        except RetryTaskAt as e:
-            await self._schedule_retry(task.operation_id, e.retry_at, str(e), task.schema)
         except Exception as e:
             logger.error(f"Task {task.operation_id} failed: {e}")
             traceback.print_exc()
-            await self._mark_failed(task.operation_id, str(e), task.schema)
+            await self._retry_or_fail(task.operation_id, str(e), task.schema)
 
     async def recover_own_tasks(self) -> int:
         """

hindsight-api/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hindsight-api"
-version = "0.4.16"
+version = "0.4.15"
 description = "Hindsight: Agent Memory That Works Like Human Memory"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -43,8 +43,8 @@ dependencies = [
     "cohere>=5.0.0",
     "flashrank>=0.2.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)
+    "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)
     # Local ML models for embeddings/reranking - can be excluded in Docker with INCLUDE_LOCAL_MODELS=false
     "sentence-transformers>=3.3.0",
     "transformers>=4.53.0", # Security fixes for ReDoS vulnerabilities
@@ -53,16 +53,11 @@ dependencies = [
     # 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
+    "langchain-core>=1.2.5", # Serialization injection vulnerability fix
     "filelock>=3.20.1", # TOCTOU race condition fix
     "authlib>=1.6.6", # Account takeover vulnerability fix
     "aiohttp>=3.13.3", # Multiple DoS vulnerabilities
     "claude-agent-sdk>=0.1.27",
-    "einops>=0.8.2",
 ]
 
 [project.optional-dependencies]

hindsight-api/tests/test_batch_api.py

@@ -413,6 +413,7 @@ async def test_worker_batch_recovery(memory, request_context):
             worker_id="test_worker_recovery",
             executor=memory,
             poll_interval_ms=100,
+            max_retries=3,
             schema=schema,
             tenant_extension=tenant_extension,
             max_slots=5,

hindsight-api/tests/test_combined_scoring.py

@@ -1,171 +1,334 @@
 """
-Tests for combined scoring (apply_combined_scoring).
+Tests for combined scoring functionality.
 
-The function applies multiplicative recency/temporal boosts to the cross-encoder
-score so that the relative influence of these signals is proportional to the base
-relevance score, independent of the cross-encoder model's score calibration.
+Verifies that:
+1. RRF scores are properly normalized to [0, 1] range
+2. Combined scoring formula is applied correctly
+3. Tracer captures normalized values (not raw values)
 """
-
-from datetime import datetime, timedelta, timezone
-from unittest.mock import MagicMock
-
 import pytest
-
-from hindsight_api.engine.search.reranking import apply_combined_scoring, _RECENCY_ALPHA, _TEMPORAL_ALPHA
-from hindsight_api.engine.search.types import MergedCandidate, RetrievalResult, ScoredResult
-
-UTC = timezone.utc
-NOW = datetime(2024, 6, 1, tzinfo=UTC)
+from datetime import datetime, timezone
+from hindsight_api.engine.search.types import RetrievalResult, MergedCandidate, ScoredResult
+from hindsight_api.engine.memory_engine import Budget
+from hindsight_api import RequestContext
 
 
-def _make_result(
-    ce_norm: float,
-    occurred_start: datetime | None = None,
-    temporal_proximity: float | None = None,
-) -> ScoredResult:
-    retrieval = MagicMock(spec=RetrievalResult)
-    retrieval.occurred_start = occurred_start
-    retrieval.temporal_proximity = temporal_proximity
+class TestRRFNormalization:
+    """Test that RRF scores are properly normalized."""
 
-    candidate = MagicMock(spec=MergedCandidate)
-    candidate.retrieval = retrieval
-    candidate.rrf_score = 0.05
+    def test_rrf_normalized_range(self):
+        """RRF normalized values should be in [0, 1] range, not raw [0.04, 0.06]."""
+        # Simulate RRF scores like what we get from actual retrieval
+        raw_rrf_scores = [0.0607, 0.0550, 0.0480, 0.0390]
 
-    return ScoredResult(
-        candidate=candidate,
-        cross_encoder_score=1.0,
-        cross_encoder_score_normalized=ce_norm,
-        weight=ce_norm,
-    )
+        max_rrf = max(raw_rrf_scores)
+        min_rrf = min(raw_rrf_scores)
+        rrf_range = max_rrf - min_rrf
+
+        normalized = []
+        for score in raw_rrf_scores:
+            if rrf_range > 0:
+                norm = (score - min_rrf) / rrf_range
+            else:
+                norm = 0.5
+            normalized.append(norm)
+
+        # Verify normalized values are in [0, 1]
+        for i, norm in enumerate(normalized):
+            assert 0.0 <= norm <= 1.0, f"Normalized RRF {norm} not in [0, 1] for raw {raw_rrf_scores[i]}"
+
+        # Highest raw should be 1.0
+        assert normalized[0] == 1.0, f"Highest RRF should normalize to 1.0, got {normalized[0]}"
+
+        # Lowest raw should be 0.0
+        assert normalized[-1] == 0.0, f"Lowest RRF should normalize to 0.0, got {normalized[-1]}"
+
+    def test_rrf_all_same_scores(self):
+        """When all RRF scores are the same, normalized should be 0.5 (neutral)."""
+        raw_rrf_scores = [0.0500, 0.0500, 0.0500]
+
+        max_rrf = max(raw_rrf_scores)
+        min_rrf = min(raw_rrf_scores)
+        rrf_range = max_rrf - min_rrf
+
+        normalized = []
+        for score in raw_rrf_scores:
+            if rrf_range > 0:
+                norm = (score - min_rrf) / rrf_range
+            else:
+                norm = 0.5  # Neutral value when all same
+            normalized.append(norm)
+
+        # All should be 0.5 when scores are identical
+        for norm in normalized:
+            assert norm == 0.5, f"Expected 0.5 for identical scores, got {norm}"
 
 
-class TestBoostFormula:
-    def test_neutral_signals_leave_score_unchanged(self):
-        """recency=0.5 and temporal=0.5 both produce boost=1.0, so weight == ce."""
-        sr = _make_result(ce_norm=0.6)
-        apply_combined_scoring([sr], now=NOW)
-        assert abs(sr.weight - 0.6) < 1e-9
+class TestCombinedScoringFormula:
+    """Test that the combined scoring formula is applied correctly."""
 
-    def test_max_recency_boost(self):
-        """A memory from today (recency≈1.0) should boost by (1 + alpha*0.5)."""
-        sr = _make_result(ce_norm=0.5, occurred_start=NOW)
-        apply_combined_scoring([sr], now=NOW)
-        expected = 0.5 * (1.0 + _RECENCY_ALPHA * 0.5) * 1.0  # temporal neutral
-        assert abs(sr.weight - expected) < 1e-6
+    def test_combined_score_calculation(self):
+        """Verify the weighted combination: 0.6*CE + 0.2*RRF + 0.1*temporal + 0.1*recency."""
+        # Test case 1: All components at 1.0
+        ce_norm = 1.0
+        rrf_norm = 1.0
+        temporal = 1.0
+        recency = 1.0
 
-    def test_min_recency_penalty(self):
-        """A memory from >365 days ago (recency=0.1) should penalise score."""
-        old = NOW - timedelta(days=400)
-        sr = _make_result(ce_norm=0.5, occurred_start=old)
-        apply_combined_scoring([sr], now=NOW)
-        expected = 0.5 * (1.0 + _RECENCY_ALPHA * (0.1 - 0.5)) * 1.0
-        assert abs(sr.weight - expected) < 1e-6
+        expected = 0.6 * ce_norm + 0.2 * rrf_norm + 0.1 * temporal + 0.1 * recency
+        assert expected == 1.0, f"All 1.0 should give 1.0, got {expected}"
 
-    def test_max_temporal_boost(self):
-        """temporal_proximity=1.0 should boost by (1 + alpha*0.5)."""
-        sr = _make_result(ce_norm=0.5, temporal_proximity=1.0)
-        apply_combined_scoring([sr], now=NOW)
-        expected = 0.5 * 1.0 * (1.0 + _TEMPORAL_ALPHA * 0.5)  # recency neutral
-        assert abs(sr.weight - expected) < 1e-6
+        # Test case 2: All components at 0.0
+        ce_norm = 0.0
+        rrf_norm = 0.0
+        temporal = 0.0
+        recency = 0.0
 
-    def test_temporal_none_is_neutral(self):
-        """temporal_proximity=None must be treated as 0.5 (no boost/penalty)."""
-        sr_none = _make_result(ce_norm=0.5, temporal_proximity=None)
-        sr_half = _make_result(ce_norm=0.5, temporal_proximity=0.5)
-        apply_combined_scoring([sr_none], now=NOW)
-        apply_combined_scoring([sr_half], now=NOW)
-        assert abs(sr_none.weight - sr_half.weight) < 1e-9
+        expected = 0.6 * ce_norm + 0.2 * rrf_norm + 0.1 * temporal + 0.1 * recency
+        assert expected == 0.0, f"All 0.0 should give 0.0, got {expected}"
 
-    def test_both_signals_combined(self):
-        """Both boosts are applied multiplicatively."""
-        sr = _make_result(ce_norm=0.5, occurred_start=NOW, temporal_proximity=1.0)
-        apply_combined_scoring([sr], now=NOW)
-        recency_boost = 1.0 + _RECENCY_ALPHA * (1.0 - 0.5)
-        temporal_boost = 1.0 + _TEMPORAL_ALPHA * (1.0 - 0.5)
-        expected = 0.5 * recency_boost * temporal_boost
-        assert abs(sr.weight - expected) < 1e-6
+        # Test case 3: High CE, low RRF (cross-encoder finds something retrieval missed)
+        ce_norm = 0.999
+        rrf_norm = 0.0  # Lowest in set
+        temporal = 0.5
+        recency = 0.5
 
-    def test_boost_is_proportional_to_ce(self):
-        """The absolute boost from recency scales with the CE score."""
-        sr_high = _make_result(ce_norm=0.9, occurred_start=NOW)
-        sr_low = _make_result(ce_norm=0.3, occurred_start=NOW)
-        apply_combined_scoring([sr_high, sr_low], now=NOW)
+        expected = 0.6 * ce_norm + 0.2 * rrf_norm + 0.1 * temporal + 0.1 * recency
+        # 0.5994 + 0.0 + 0.05 + 0.05 = 0.6994
+        assert abs(expected - 0.6994) < 0.001, f"Expected ~0.6994, got {expected}"
 
-        # Both get the same recency boost factor — absolute gain is proportional to CE
-        boost_factor = 1.0 + _RECENCY_ALPHA * 0.5
-        assert abs(sr_high.weight - 0.9 * boost_factor) < 1e-6
-        assert abs(sr_low.weight - 0.3 * boost_factor) < 1e-6
+        # Test case 4: Medium CE, high RRF (retrieval consensus)
+        ce_norm = 0.8
+        rrf_norm = 1.0  # Highest in set
+        temporal = 0.5
+        recency = 0.5
 
-    def test_boost_capped(self):
-        """Max boost: recency=1.0 + temporal=1.0 gives ≤21% uplift on CE."""
-        sr = _make_result(ce_norm=1.0, occurred_start=NOW, temporal_proximity=1.0)
-        apply_combined_scoring([sr], now=NOW)
-        assert sr.weight <= 1.0 * (1 + _RECENCY_ALPHA / 2) * (1 + _TEMPORAL_ALPHA / 2) + 1e-9
+        expected = 0.6 * ce_norm + 0.2 * rrf_norm + 0.1 * temporal + 0.1 * recency
+        # 0.48 + 0.2 + 0.05 + 0.05 = 0.78
+        assert abs(expected - 0.78) < 0.001, f"Expected ~0.78, got {expected}"
 
-    def test_rrf_normalized_always_zero(self):
-        """RRF is excluded from scoring; rrf_normalized is set to 0.0 for trace clarity."""
-        sr = _make_result(ce_norm=0.5)
-        apply_combined_scoring([sr], now=NOW)
-        assert sr.rrf_normalized == 0.0
+    def test_rrf_contribution_is_significant(self):
+        """Verify RRF actually contributes to the final score (not negligible)."""
+        # Same CE, different RRF
+        ce_norm = 0.8
+        temporal = 0.5
+        recency = 0.5
 
-    def test_combined_score_equals_weight(self):
-        """combined_score and weight must stay in sync."""
-        sr = _make_result(ce_norm=0.7, occurred_start=NOW, temporal_proximity=0.8)
-        apply_combined_scoring([sr], now=NOW)
-        assert sr.combined_score == sr.weight
+        # Low RRF
+        score_low_rrf = 0.6 * ce_norm + 0.2 * 0.0 + 0.1 * temporal + 0.1 * recency
 
-    def test_model_calibration_independence(self):
-        """
-        A low-calibration model (low CE scores) and a high-calibration model
-        (high CE scores) should produce the same ranking for identical content.
+        # High RRF
+        score_high_rrf = 0.6 * ce_norm + 0.2 * 1.0 + 0.1 * temporal + 0.1 * recency
 
-        With additive scoring the recency term would dominate for low-CE models;
-        with multiplicative boosting the relative ranking is stable.
-        """
-        recent = NOW - timedelta(days=10)
-        old = NOW - timedelta(days=300)
+        # Difference should be 0.2 (20% contribution)
+        diff = score_high_rrf - score_low_rrf
+        assert abs(diff - 0.2) < 0.001, f"RRF should contribute 0.2 difference, got {diff}"
 
-        # High-calibration model: clear winner is #1 (more relevant, slightly older)
-        h_relevant = _make_result(ce_norm=0.85, occurred_start=old)
-        h_recent = _make_result(ce_norm=0.60, occurred_start=recent)
-        apply_combined_scoring([h_relevant, h_recent], now=NOW)
-        assert h_relevant.weight > h_recent.weight, "High-CE model: relevance should win"
 
-        # Low-calibration model: same relative difference, just compressed scores
-        l_relevant = _make_result(ce_norm=0.34, occurred_start=old)
-        l_recent = _make_result(ce_norm=0.24, occurred_start=recent)
-        apply_combined_scoring([l_relevant, l_recent], now=NOW)
-        assert l_relevant.weight > l_recent.weight, "Low-CE model: relevance should still win"
+@pytest.mark.asyncio
+async def test_trace_has_normalized_rrf(memory, request_context):
+    """Integration test: verify trace contains normalized RRF values, not raw."""
+    bank_id = f"test_scoring_{datetime.now(timezone.utc).timestamp()}"
 
-    def test_no_occurred_start_defaults_recency_neutral(self):
-        """Missing occurred_start → recency=0.5 → no boost/penalty."""
-        sr = _make_result(ce_norm=0.5, occurred_start=None)
-        apply_combined_scoring([sr], now=NOW)
-        assert sr.recency == 0.5
-        assert abs(sr.weight - 0.5) < 1e-9
+    try:
+        # Store multiple memories to ensure different RRF scores
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="Python is a programming language created by Guido van Rossum",
+            context="tech facts",
+            request_context=request_context,
+        )
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="JavaScript was created by Brendan Eich at Netscape",
+            context="tech facts",
+            request_context=request_context,
+        )
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="The Eiffel Tower is located in Paris, France",
+            context="geography facts",
+            request_context=request_context,
+        )
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="Mount Everest is the tallest mountain on Earth",
+            context="geography facts",
+            request_context=request_context,
+        )
 
-    def test_timezone_naive_occurred_start_handled(self):
-        """Naive datetimes in occurred_start should not raise."""
-        naive_date = datetime(2024, 1, 1)  # no tzinfo
-        sr = _make_result(ce_norm=0.5, occurred_start=naive_date)
-        apply_combined_scoring([sr], now=NOW)  # must not raise
-        assert 0.0 < sr.weight < 1.0
+        # Search with tracing
+        result = await memory.recall_async(
+            bank_id=bank_id,
+            query="programming languages",
+            fact_type=["world"],
+            budget=Budget.LOW,
+            max_tokens=1024,
+            enable_trace=True,
+            request_context=request_context,
+        )
 
-    def test_custom_alpha_values(self):
-        """Custom alpha parameters are respected."""
-        sr = _make_result(ce_norm=0.5, occurred_start=NOW)
-        apply_combined_scoring([sr], now=NOW, recency_alpha=0.4, temporal_alpha=0.0)
-        expected = 0.5 * (1.0 + 0.4 * 0.5) * 1.0
-        assert abs(sr.weight - expected) < 1e-6
+        assert result.trace is not None, "Trace should be present"
+        trace = result.trace
 
-    def test_future_event_recency_capped_at_one(self):
-        """Events in the future must not produce recency > 1.0, keeping boost within bounds."""
-        future = NOW + timedelta(days=180)
-        sr = _make_result(ce_norm=0.5, occurred_start=future)
-        apply_combined_scoring([sr], now=NOW)
-        assert sr.recency == 1.0
-        expected_max_boost = 1.0 + _RECENCY_ALPHA * 0.5
-        assert sr.weight <= 0.5 * expected_max_boost + 1e-9
+        # Check reranked results have proper score_components
+        assert "reranked" in trace, "Trace should have reranked results"
+        assert len(trace["reranked"]) > 0, "Should have reranked results"
 
-    def test_empty_list_is_noop(self):
-        apply_combined_scoring([], now=NOW)  # must not raise
+        has_valid_rrf = False
+        has_valid_temporal = False
+        has_valid_recency = False
+
+        for r in trace["reranked"]:
+            sc = r.get("score_components", {})
+
+            # Check RRF normalized is present and in valid range
+            if "rrf_normalized" in sc:
+                rrf_norm = sc["rrf_normalized"]
+                assert 0.0 <= rrf_norm <= 1.0, f"rrf_normalized {rrf_norm} should be in [0, 1]"
+                # Should NOT be raw RRF score (which would be ~0.04-0.06)
+                # A normalized value of exactly 0.0 or 1.0 is valid (min/max of set)
+                # But raw scores like 0.0607 should never appear as normalized
+                if rrf_norm > 0.1:  # Any value > 0.1 is likely properly normalized
+                    has_valid_rrf = True
+
+            # Check temporal is present and in valid range
+            if "temporal" in sc:
+                temporal = sc["temporal"]
+                assert 0.0 <= temporal <= 1.0, f"temporal {temporal} should be in [0, 1]"
+                has_valid_temporal = True
+
+            # Check recency is present and in valid range
+            if "recency" in sc:
+                recency = sc["recency"]
+                assert 0.0 <= recency <= 1.0, f"recency {recency} should be in [0, 1]"
+                has_valid_recency = True
+
+        # At least some results should have these components
+        # (might not have rrf > 0.1 if all scores are same, which is fine)
+        assert has_valid_temporal, "Should have temporal scores in trace"
+        assert has_valid_recency, "Should have recency scores in trace"
+
+        print("\n✓ Combined scoring trace test passed!")
+        print(f"  - Reranked results: {len(trace['reranked'])}")
+        if trace["reranked"]:
+            sc = trace["reranked"][0].get("score_components", {})
+            print(f"  - First result score components: {sc}")
+
+    finally:
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+
+@pytest.mark.asyncio
+async def test_rrf_normalized_not_raw_in_trace(memory, request_context):
+    """Verify that raw RRF scores (0.04-0.06 range) don't appear as normalized values."""
+    bank_id = f"test_rrf_raw_{datetime.now(timezone.utc).timestamp()}"
+
+    try:
+        # Store enough memories to get varied RRF scores
+        for i in range(5):
+            await memory.retain_async(
+                bank_id=bank_id,
+                content=f"Test fact number {i} about various topics",
+                context="test context",
+                request_context=request_context,
+            )
+
+        result = await memory.recall_async(
+            bank_id=bank_id,
+            query="test fact",
+            fact_type=["world"],
+            budget=Budget.LOW,
+            max_tokens=512,
+            enable_trace=True,
+            request_context=request_context,
+        )
+
+        trace = result.trace
+        assert trace is not None
+
+        # Check that rrf_normalized values are NOT in the raw range
+        raw_rrf_range = (0.01, 0.08)  # Raw RRF scores are typically in this range
+
+        for r in trace.get("reranked", []):
+            sc = r.get("score_components", {})
+
+            if "rrf_normalized" in sc and "rrf_score" in sc:
+                rrf_norm = sc["rrf_normalized"]
+                rrf_raw = sc["rrf_score"]
+
+                # Raw should be in the typical range
+                assert raw_rrf_range[0] <= rrf_raw <= raw_rrf_range[1], \
+                    f"Raw RRF {rrf_raw} should be in typical range {raw_rrf_range}"
+
+                # Normalized should either be:
+                # - 0.0 (min in set)
+                # - 1.0 (max in set)
+                # - 0.5 (all same)
+                # - Something in between (0.0 to 1.0)
+                # But NOT the same as raw (which would indicate no normalization)
+                if len(trace["reranked"]) > 1:
+                    # If we have multiple results, normalized should differ from raw
+                    # (unless by coincidence, which is very unlikely)
+                    assert rrf_norm != rrf_raw, \
+                        f"Normalized RRF ({rrf_norm}) should differ from raw ({rrf_raw})"
+
+        print("\n✓ RRF raw vs normalized test passed!")
+
+    finally:
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+
+@pytest.mark.asyncio
+async def test_combined_score_matches_components(memory, request_context):
+    """Verify the final score actually equals the weighted sum of components."""
+    bank_id = f"test_combined_{datetime.now(timezone.utc).timestamp()}"
+
+    try:
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="The quick brown fox jumps over the lazy dog",
+            context="test",
+            request_context=request_context,
+        )
+        await memory.retain_async(
+            bank_id=bank_id,
+            content="A quick test of the emergency broadcast system",
+            context="test",
+            request_context=request_context,
+        )
+
+        result = await memory.recall_async(
+            bank_id=bank_id,
+            query="quick test",
+            fact_type=["world"],
+            budget=Budget.LOW,
+            max_tokens=512,
+            enable_trace=True,
+            request_context=request_context,
+        )
+
+        trace = result.trace
+        assert trace is not None
+
+        for r in trace.get("reranked", []):
+            sc = r.get("score_components", {})
+            final_score = r.get("rerank_score", 0)
+
+            # Get components (use defaults if missing)
+            ce = sc.get("cross_encoder_score_normalized", 0)
+            rrf = sc.get("rrf_normalized", 0.5)
+            tmp = sc.get("temporal", 0.5)
+            rec = sc.get("recency", 0.5)
+
+            # Calculate expected score
+            expected = 0.6 * ce + 0.2 * rrf + 0.1 * tmp + 0.1 * rec
+
+            # Allow small floating point difference
+            assert abs(final_score - expected) < 0.01, \
+                f"Final score {final_score} doesn't match expected {expected} from components"
+
+        print("\n✓ Combined score verification test passed!")
+
+    finally:
+        await memory.delete_bank(bank_id, request_context=request_context)

hindsight-api/tests/test_consolidation.py

@@ -5,15 +5,11 @@ Note: Consolidation runs automatically after retain via SyncTaskBackend in tests
 """
 
 import uuid
-from datetime import datetime, timezone
 from unittest.mock import patch
 
 import pytest
 
-from hindsight_api.engine.consolidation.consolidator import (
-    _aggregate_source_fields,
-    run_consolidation_job,
-)
+from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
 from hindsight_api.engine.memory_engine import MemoryEngine
 from hindsight_api.engine.reflect.tools import (
     tool_recall,
@@ -2321,100 +2317,3 @@ async def test_observation_scopes_all_combinations(memory: MemoryEngine, request
         assert combined, f"Expected an observation scoped to both tags, got: {tag_sets}"
     finally:
         await memory.delete_bank(bank_id, request_context=request_context)
-
-
-def _dt(year: int, month: int, day: int) -> datetime:
-    return datetime(year, month, day, tzinfo=timezone.utc)
-
-
-class TestAggregateSourceFields:
-    """Unit tests for _aggregate_source_fields – no database required."""
-
-    def test_all_none_temporal_fields_stay_none(self):
-        """When source memories carry no temporal data, all fields must remain None."""
-        source_mems = [
-            {"tags": ["t1"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-            {"tags": ["t1"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-        ]
-        agg = _aggregate_source_fields(source_mems)
-        assert agg.event_date is None
-        assert agg.occurred_start is None
-        assert agg.occurred_end is None
-        assert agg.mentioned_at is None
-
-    def test_temporal_fields_aggregated_correctly(self):
-        """occurred_start and event_date are minimised; occurred_end and mentioned_at are maximised."""
-        early = _dt(2023, 1, 1)
-        late = _dt(2024, 6, 15)
-        source_mems = [
-            {
-                "tags": [],
-                "event_date": late,
-                "occurred_start": late,
-                "occurred_end": early,
-                "mentioned_at": early,
-            },
-            {
-                "tags": [],
-                "event_date": early,
-                "occurred_start": early,
-                "occurred_end": late,
-                "mentioned_at": late,
-            },
-        ]
-        agg = _aggregate_source_fields(source_mems)
-        assert agg.event_date == early
-        assert agg.occurred_start == early
-        assert agg.occurred_end == late
-        assert agg.mentioned_at == late
-
-    def test_partial_temporal_fields_ignored_when_none(self):
-        """None values in individual sources do not corrupt the min/max from sources that do have dates."""
-        d = _dt(2023, 3, 10)
-        source_mems = [
-            {"tags": [], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-            {"tags": [], "event_date": d, "occurred_start": d, "occurred_end": d, "mentioned_at": d},
-        ]
-        agg = _aggregate_source_fields(source_mems)
-        assert agg.event_date == d
-        assert agg.occurred_start == d
-        assert agg.occurred_end == d
-        assert agg.mentioned_at == d
-
-    def test_tags_inherited_from_first_source_memory(self):
-        """Tags default to those of the first source memory (batch invariant)."""
-        source_mems = [
-            {"tags": ["user:alice"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-            {"tags": ["user:alice"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-        ]
-        agg = _aggregate_source_fields(source_mems)
-        assert agg.tags == ["user:alice"]
-
-    def test_tags_override_takes_precedence(self):
-        """Explicit tags parameter overrides the source-memory tags."""
-        source_mems = [
-            {"tags": ["user:alice"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-        ]
-        agg = _aggregate_source_fields(source_mems, tags=["scope:override"])
-        assert agg.tags == ["scope:override"]
-
-    def test_empty_tags_override_is_respected(self):
-        """An explicit empty list override must not fall back to source tags."""
-        source_mems = [
-            {"tags": ["user:alice"], "event_date": None, "occurred_start": None, "occurred_end": None, "mentioned_at": None},
-        ]
-        agg = _aggregate_source_fields(source_mems, tags=[])
-        assert agg.tags == []
-
-    def test_single_source_memory(self):
-        """Single-source aggregation should just pass through that memory's fields."""
-        d = _dt(2024, 11, 5)
-        source_mems = [
-            {"tags": ["x"], "event_date": d, "occurred_start": d, "occurred_end": d, "mentioned_at": d},
-        ]
-        agg = _aggregate_source_fields(source_mems)
-        assert agg.event_date == d
-        assert agg.occurred_start == d
-        assert agg.occurred_end == d
-        assert agg.mentioned_at == d
-        assert agg.tags == ["x"]

hindsight-api/tests/test_fact_extraction_retry.py

@@ -1,141 +0,0 @@
-"""
-Unit tests for fact extraction retry logic.
-
-Tests the fix for the TypeError when LLM returns invalid JSON across all retries.
-Previously, `raise last_error` would raise None (TypeError) because last_error was
-only set in the BadRequestError handler, not when the LLM returned non-dict JSON.
-"""
-
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-
-def _make_config(llm_max_retries: int = 3, retain_llm_max_retries: int | None = None):
-    """Build a minimal HindsightConfig for fact extraction tests."""
-    from hindsight_api.config import HindsightConfig
-
-    cfg = MagicMock(spec=HindsightConfig)
-    cfg.retain_llm_max_retries = retain_llm_max_retries
-    cfg.llm_max_retries = llm_max_retries
-    cfg.retain_llm_initial_backoff = None
-    cfg.llm_initial_backoff = 0.0
-    cfg.retain_llm_max_backoff = None
-    cfg.llm_max_backoff = 0.0
-    cfg.retain_max_completion_tokens = 8192
-    cfg.retain_extraction_mode = "concise"
-    cfg.retain_extract_causal_links = False
-    cfg.retain_mission = None
-    return cfg
-
-
-def _make_llm_config(mock_response):
-    """Build a mock LLMProvider that returns the given response."""
-    from hindsight_api.engine.llm_wrapper import LLMProvider
-
-    llm = MagicMock(spec=LLMProvider)
-    llm.provider = "mock"
-    token_usage = MagicMock()
-    token_usage.__add__ = lambda self, other: self
-    llm.call = AsyncMock(return_value=(mock_response, token_usage))
-    return llm
-
-
-@pytest.mark.asyncio
-async def test_non_dict_json_all_retries_returns_empty():
-    """
-    When LLM returns non-dict JSON on every attempt, extraction should return []
-    without raising TypeError ('exceptions must derive from BaseException').
-
-    This was the bug: the loop ran range(2) times (hardcoded), but comparisons
-    used config.llm_max_retries (default 10). On the last loop iteration (attempt=1),
-    `attempt < 10 - 1` was True, so the code called `continue`, the loop
-    exhausted, and `raise last_error` raised None → TypeError.
-    """
-    from hindsight_api.engine.retain.fact_extraction import _extract_facts_from_chunk
-
-    # llm_max_retries=3 ensures the bug triggers with the old code (3 != 2 hardcoded)
-    config = _make_config(llm_max_retries=3, retain_llm_max_retries=None)
-
-    # Mock: always returns a list (non-dict), which is invalid
-    llm_config = _make_llm_config(mock_response=[{"invalid": "response"}])
-
-    with patch(
-        "hindsight_api.engine.retain.fact_extraction._build_extraction_prompt_and_schema",
-        return_value=("system prompt", MagicMock()),
-    ):
-        facts, usage = await _extract_facts_from_chunk(
-            chunk="Alice visited Paris in 2023.",
-            chunk_index=0,
-            total_chunks=1,
-            event_date=datetime(2023, 1, 1, tzinfo=timezone.utc),
-            context="travel notes",
-            llm_config=llm_config,
-            config=config,
-            agent_name="test-agent",
-        )
-
-    assert facts == []
-
-
-@pytest.mark.asyncio
-async def test_non_dict_json_with_default_max_retries_returns_empty():
-    """
-    Same scenario with the default llm_max_retries=10 (matching real default config).
-    The old code ran range(2) but checked against 10, always continuing until
-    the loop exhausted, then raised None → TypeError.
-    """
-    from hindsight_api.engine.retain.fact_extraction import _extract_facts_from_chunk
-
-    config = _make_config(llm_max_retries=10, retain_llm_max_retries=None)
-    llm_config = _make_llm_config(mock_response="not a dict at all")
-
-    with patch(
-        "hindsight_api.engine.retain.fact_extraction._build_extraction_prompt_and_schema",
-        return_value=("system prompt", MagicMock()),
-    ):
-        facts, usage = await _extract_facts_from_chunk(
-            chunk="Some text.",
-            chunk_index=0,
-            total_chunks=1,
-            event_date=datetime(2023, 6, 1, tzinfo=timezone.utc),
-            context="",
-            llm_config=llm_config,
-            config=config,
-            agent_name="agent",
-        )
-
-    assert facts == []
-
-
-@pytest.mark.asyncio
-async def test_retain_llm_max_retries_overrides_global():
-    """
-    When retain_llm_max_retries is set, it should be used for the loop range
-    and all comparisons (no shadowing bug).
-    """
-    from hindsight_api.engine.retain.fact_extraction import _extract_facts_from_chunk
-
-    # retain_llm_max_retries=5 should override llm_max_retries=10
-    config = _make_config(llm_max_retries=10, retain_llm_max_retries=5)
-    llm_config = _make_llm_config(mock_response=42)  # non-dict: integer
-
-    with patch(
-        "hindsight_api.engine.retain.fact_extraction._build_extraction_prompt_and_schema",
-        return_value=("system prompt", MagicMock()),
-    ):
-        facts, usage = await _extract_facts_from_chunk(
-            chunk="Bob likes Python.",
-            chunk_index=0,
-            total_chunks=1,
-            event_date=datetime(2024, 1, 1, tzinfo=timezone.utc),
-            context="",
-            llm_config=llm_config,
-            config=config,
-            agent_name="agent",
-        )
-
-    assert facts == []
-    # Verify it retried exactly retain_llm_max_retries times
-    assert llm_config.call.call_count == 5

hindsight-api/tests/test_recall_chunks_independence.py

@@ -231,61 +231,6 @@ async def test_recall_chunks_ordering_by_relevance(memory, request_context):
         await memory.delete_bank(bank_id, request_context=request_context)
 
 
-@pytest.mark.asyncio
-async def test_recall_chunks_for_observations(memory, request_context):
-    """
-    Test that chunks are returned when recalling only observations.
-
-    Observations have no direct chunk_id (they are synthesized from source memories).
-    When include_chunks=True, chunks should be resolved via source_memory_ids.
-    """
-    bank_id = "test-chunks-observations"
-
-    try:
-        # Retain content that will generate observations via consolidation
-        test_content = """
-        Alice is a senior software engineer at a large technology company.
-        She specializes in distributed systems and has 10 years of experience.
-        Alice leads a team of 8 engineers working on cloud infrastructure.
-        She holds a PhD in computer science from Stanford University.
-        Alice has published several papers on fault-tolerant distributed systems.
-        """ * 8
-
-        await memory.retain_async(
-            bank_id=bank_id,
-            content=test_content,
-            context="profile notes",
-            request_context=request_context,
-        )
-
-        # Trigger consolidation explicitly to ensure observations exist
-        await memory.run_consolidation(bank_id=bank_id, request_context=request_context)
-
-        # Recall observations only with chunks enabled
-        result = await memory.recall_async(
-            bank_id=bank_id,
-            query="Alice software engineer",
-            fact_type=["observation"],
-            max_tokens=4096,
-            include_chunks=True,
-            max_chunk_tokens=2000,
-            budget=Budget.MID,
-            request_context=request_context,
-        )
-
-        # If observations were created, chunks should be resolved from source memories
-        if len(result.results) > 0:
-            assert result.chunks is not None, "Should include chunks dict when observations are found"
-            assert len(result.chunks) > 0, "Should return chunks resolved from observation source memories"
-
-            for chunk_id, chunk_info in result.chunks.items():
-                assert len(chunk_info.chunk_text) > 0, "Chunks should contain text"
-                assert chunk_info.chunk_index >= 0, "Chunk should have valid index"
-
-    finally:
-        await memory.delete_bank(bank_id, request_context=request_context)
-
-
 @pytest.mark.asyncio
 async def test_recall_chunks_without_include_flag(memory, request_context):
     """

hindsight-api/tests/test_webhooks.py

@@ -1,780 +0,0 @@
-"""Tests for the webhook system.
-
-Covers:
-- Unit tests for HMAC signing and retry constants (no DB required)
-- Integration tests for fire_event() using a real DB (inserts into async_operations)
-- Integration tests for _handle_webhook_delivery() on the memory engine
-- HTTP API integration tests for CRUD and delivery listing endpoints
-"""
-
-import json
-import uuid
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import httpx
-import pytest
-import pytest_asyncio
-
-from hindsight_api.api import create_app
-from hindsight_api.engine.memory_engine import MemoryEngine
-from hindsight_api.webhooks.manager import MAX_ATTEMPTS, RETRY_DELAYS, WebhookManager
-from hindsight_api.webhooks.models import (
-    ConsolidationEventData,
-    RetainEventData,
-    WebhookConfig,
-    WebhookEvent,
-    WebhookEventType,
-)
-from hindsight_api.worker.exceptions import RetryTaskAt
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_event(bank_id: str = "bank-1") -> WebhookEvent:
-    return WebhookEvent(
-        event=WebhookEventType.CONSOLIDATION_COMPLETED,
-        bank_id=bank_id,
-        operation_id=uuid.uuid4().hex,
-        status="completed",
-        timestamp=datetime.now(timezone.utc),
-        data=ConsolidationEventData(observations_created=1),
-    )
-
-
-def _make_delivery_task(
-    bank_id: str = "bank-1",
-    url: str = "https://example.com/hook",
-    retry_count: int = 0,
-    webhook_id: str | None = None,
-) -> dict:
-    return {
-        "type": "webhook_delivery",
-        "bank_id": bank_id,
-        "url": url,
-        "secret": None,
-        "event_type": "consolidation.completed",
-        "payload": '{"event":"consolidation.completed"}',
-        "webhook_id": webhook_id,
-        "_retry_count": retry_count,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Unit tests (no DB)
-# ---------------------------------------------------------------------------
-
-
-class TestHmacSigning:
-    """Unit tests for WebhookManager._sign_payload()."""
-
-    def _make_manager(self) -> WebhookManager:
-        """Create a WebhookManager with a dummy pool (not used for signing)."""
-        pool = MagicMock()
-        return WebhookManager(pool=pool, global_webhooks=[])
-
-    def test_hmac_signing_format(self):
-        """_sign_payload should return a string starting with 'sha256='."""
-        manager = self._make_manager()
-        sig = manager._sign_payload("my-secret", b"hello world")
-        assert sig.startswith("sha256="), f"Expected 'sha256=' prefix, got: {sig!r}"
-        hex_part = sig[len("sha256="):]
-        # SHA-256 hex digest is always 64 characters
-        assert len(hex_part) == 64
-        # Hex characters only
-        assert all(c in "0123456789abcdef" for c in hex_part)
-
-    def test_hmac_signing_is_deterministic(self):
-        """Same secret + payload always produces the same signature."""
-        manager = self._make_manager()
-        payload = b'{"event":"consolidation.completed"}'
-        sig1 = manager._sign_payload("secret-key", payload)
-        sig2 = manager._sign_payload("secret-key", payload)
-        assert sig1 == sig2
-
-    def test_hmac_signing_differs_with_different_secret(self):
-        """Different secrets must produce different signatures."""
-        manager = self._make_manager()
-        payload = b"payload"
-        sig1 = manager._sign_payload("secret-a", payload)
-        sig2 = manager._sign_payload("secret-b", payload)
-        assert sig1 != sig2
-
-    def test_hmac_signing_differs_with_different_payload(self):
-        """Different payloads must produce different signatures."""
-        manager = self._make_manager()
-        sig1 = manager._sign_payload("secret", b"payload-one")
-        sig2 = manager._sign_payload("secret", b"payload-two")
-        assert sig1 != sig2
-
-
-class TestRetryConstants:
-    """Unit tests to verify retry schedule constants."""
-
-    def test_retry_delays_values(self):
-        """RETRY_DELAYS must match the documented schedule."""
-        assert RETRY_DELAYS == [5, 300, 1800, 7200, 18000]
-
-    def test_max_attempts(self):
-        """MAX_ATTEMPTS should be len(RETRY_DELAYS) + 1."""
-        assert MAX_ATTEMPTS == 6
-        assert MAX_ATTEMPTS == len(RETRY_DELAYS) + 1
-
-
-# ---------------------------------------------------------------------------
-# DB integration tests
-# ---------------------------------------------------------------------------
-
-
-@pytest_asyncio.fixture
-async def webhook_manager(memory: MemoryEngine) -> WebhookManager:
-    """Return a WebhookManager backed by the test pool with no global webhooks."""
-    return WebhookManager(pool=memory._pool, global_webhooks=[])
-
-
-class TestFireEvent:
-    """Integration tests for WebhookManager.fire_event()."""
-
-    @pytest.mark.asyncio
-    async def test_fire_event_creates_delivery(
-        self, memory: MemoryEngine, webhook_manager: WebhookManager
-    ):
-        """fire_event() inserts a pending webhook_delivery task in async_operations."""
-        bank_id = f"wh-test-{uuid.uuid4().hex[:8]}"
-        webhook_id = uuid.uuid4()
-
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO webhooks (id, bank_id, url, secret, event_types, enabled, created_at, updated_at)
-                VALUES ($1, $2, $3, NULL, $4, true, NOW(), NOW())
-                """,
-                webhook_id,
-                bank_id,
-                "https://example.com/hook",
-                ["consolidation.completed"],
-            )
-
-        try:
-            event = _make_event(bank_id)
-            await webhook_manager.fire_event(event)
-
-            async with memory._pool.acquire() as conn:
-                rows = await conn.fetch(
-                    """
-                    SELECT status, task_payload
-                    FROM async_operations
-                    WHERE operation_type = 'webhook_delivery'
-                      AND bank_id = $1
-                      AND task_payload->>'webhook_id' = $2
-                    """,
-                    bank_id,
-                    str(webhook_id),
-                )
-
-            assert len(rows) == 1
-            assert rows[0]["status"] == "pending"
-            payload = rows[0]["task_payload"]
-            if isinstance(payload, str):
-                payload = json.loads(payload)
-            assert payload["event_type"] == "consolidation.completed"
-        finally:
-            async with memory._pool.acquire() as conn:
-                await conn.execute(
-                    "DELETE FROM async_operations WHERE operation_type = 'webhook_delivery' AND bank_id = $1",
-                    bank_id,
-                )
-                await conn.execute("DELETE FROM webhooks WHERE id = $1", webhook_id)
-
-    @pytest.mark.asyncio
-    async def test_fire_event_global_webhook(
-        self, memory: MemoryEngine
-    ):
-        """fire_event() also queues delivery tasks for global webhooks (not stored in DB)."""
-        bank_id = f"wh-global-{uuid.uuid4().hex[:8]}"
-        global_webhook = WebhookConfig(
-            id="",  # No DB row
-            bank_id=None,
-            url="https://global.example.com/hook",
-            secret=None,
-            event_types=["consolidation.completed"],
-            enabled=True,
-        )
-        manager = WebhookManager(pool=memory._pool, global_webhooks=[global_webhook])
-
-        event = _make_event(bank_id)
-        await manager.fire_event(event)
-
-        async with memory._pool.acquire() as conn:
-            rows = await conn.fetch(
-                """
-                SELECT status, task_payload
-                FROM async_operations
-                WHERE operation_type = 'webhook_delivery'
-                  AND bank_id = $1
-                  AND task_payload->>'url' = 'https://global.example.com/hook'
-                ORDER BY created_at DESC
-                LIMIT 1
-                """
-                ,
-                bank_id,
-            )
-
-        assert len(rows) == 1
-        assert rows[0]["status"] == "pending"
-        payload = rows[0]["task_payload"]
-        if isinstance(payload, str):
-            payload = json.loads(payload)
-        assert payload["webhook_id"] is None  # global webhook has no DB row
-
-        # Cleanup
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                "DELETE FROM async_operations WHERE operation_type = 'webhook_delivery' AND bank_id = $1",
-                bank_id,
-            )
-
-    @pytest.mark.asyncio
-    async def test_fire_event_no_match_if_event_type_mismatch(
-        self, memory: MemoryEngine, webhook_manager: WebhookManager
-    ):
-        """Webhooks registered for a different event type receive no delivery task."""
-        bank_id = f"wh-mismatch-{uuid.uuid4().hex[:8]}"
-        webhook_id = uuid.uuid4()
-
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO webhooks (id, bank_id, url, secret, event_types, enabled, created_at, updated_at)
-                VALUES ($1, $2, $3, NULL, $4, true, NOW(), NOW())
-                """,
-                webhook_id,
-                bank_id,
-                "https://example.com/other-hook",
-                ["other.event"],
-            )
-
-        try:
-            event = _make_event(bank_id)
-            await webhook_manager.fire_event(event)
-
-            async with memory._pool.acquire() as conn:
-                count = await conn.fetchval(
-                    """
-                    SELECT COUNT(*) FROM async_operations
-                    WHERE operation_type = 'webhook_delivery' AND bank_id = $1
-                    """,
-                    bank_id,
-                )
-
-            assert count == 0
-        finally:
-            async with memory._pool.acquire() as conn:
-                await conn.execute("DELETE FROM webhooks WHERE id = $1", webhook_id)
-
-
-class TestHandleWebhookDelivery:
-    """Integration tests for MemoryEngine._handle_webhook_delivery()."""
-
-    @pytest.mark.asyncio
-    async def test_deliver_success(self, memory: MemoryEngine):
-        """A successful HTTP POST completes without raising."""
-        task_dict = _make_delivery_task(retry_count=0)
-
-        mock_response = MagicMock()
-        mock_response.raise_for_status = MagicMock()
-
-        with patch.object(memory._http_client, "post", new=AsyncMock(return_value=mock_response)):
-            # Should not raise
-            await memory._handle_webhook_delivery(task_dict)
-
-    @pytest.mark.asyncio
-    async def test_deliver_failure_raises_retry_task_at(self, memory: MemoryEngine):
-        """A failed HTTP POST raises RetryTaskAt when retries remain."""
-        task_dict = _make_delivery_task(retry_count=0)
-
-        with patch.object(
-            memory._http_client, "post", new=AsyncMock(side_effect=Exception("connection refused"))
-        ):
-            with pytest.raises(RetryTaskAt):
-                await memory._handle_webhook_delivery(task_dict)
-
-    @pytest.mark.asyncio
-    async def test_deliver_exhausted_retries_raises(self, memory: MemoryEngine):
-        """When retry_count reaches MAX_ATTEMPTS-1, a failure raises the original exception."""
-        task_dict = _make_delivery_task(retry_count=MAX_ATTEMPTS - 1)
-
-        with patch.object(
-            memory._http_client, "post", new=AsyncMock(side_effect=Exception("server error"))
-        ):
-            with pytest.raises(Exception, match="server error"):
-                await memory._handle_webhook_delivery(task_dict)
-
-    @pytest.mark.asyncio
-    async def test_deliver_retry_at_uses_delay_schedule(self, memory: MemoryEngine):
-        """RetryTaskAt.retry_at is approximately now + RETRY_DELAYS[retry_count]."""
-        from datetime import timedelta
-
-        task_dict = _make_delivery_task(retry_count=1)
-
-        with patch.object(
-            memory._http_client, "post", new=AsyncMock(side_effect=Exception("fail"))
-        ):
-            before = datetime.now(timezone.utc)
-            with pytest.raises(RetryTaskAt) as exc_info:
-                await memory._handle_webhook_delivery(task_dict)
-            after = datetime.now(timezone.utc)
-
-        retry_at = exc_info.value.retry_at
-        expected_delay = RETRY_DELAYS[1]  # retry_count=1
-        assert retry_at >= before + timedelta(seconds=expected_delay - 2)
-        assert retry_at <= after + timedelta(seconds=expected_delay + 2)
-
-    @pytest.mark.asyncio
-    async def test_execute_task_marks_operation_completed(self, memory: MemoryEngine):
-        """After a successful delivery, execute_task marks the async_operations row as completed."""
-        operation_id = str(uuid.uuid4())
-        bank_id = f"wh-exec-{uuid.uuid4().hex[:8]}"
-
-        # Insert a real async_operations row so _mark_operation_completed has something to update
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO async_operations
-                  (operation_id, bank_id, operation_type, status, task_payload, result_metadata, created_at, updated_at)
-                VALUES ($1, $2, 'webhook_delivery', 'processing', '{}'::jsonb, '{}'::jsonb, NOW(), NOW())
-                """,
-                uuid.UUID(operation_id),
-                bank_id,
-            )
-
-        task_dict = {
-            **_make_delivery_task(bank_id=bank_id, retry_count=0),
-            "operation_id": operation_id,
-        }
-
-        mock_response = MagicMock()
-        mock_response.raise_for_status = MagicMock()
-
-        with patch.object(memory._http_client, "post", new=AsyncMock(return_value=mock_response)):
-            await memory.execute_task(task_dict)
-
-        async with memory._pool.acquire() as conn:
-            row = await conn.fetchrow(
-                "SELECT status FROM async_operations WHERE operation_id = $1",
-                uuid.UUID(operation_id),
-            )
-
-        assert row is not None
-        assert row["status"] == "completed", f"Expected 'completed', got '{row['status']}'"
-
-        # Cleanup
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                "DELETE FROM async_operations WHERE operation_id = $1",
-                uuid.UUID(operation_id),
-            )
-
-
-# ---------------------------------------------------------------------------
-# HTTP API integration tests
-# ---------------------------------------------------------------------------
-
-
-@pytest_asyncio.fixture
-async def api_client(memory: MemoryEngine):
-    """Async HTTP test client wired to the FastAPI app."""
-    app = create_app(memory, initialize_memory=False)
-    transport = httpx.ASGITransport(app=app)
-    async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
-        yield client
-
-
-class TestWebhookHttpApi:
-    """HTTP API integration tests for webhook CRUD endpoints."""
-
-    @pytest.mark.asyncio
-    async def test_http_create_webhook(self, api_client: httpx.AsyncClient):
-        """POST /webhooks returns 201 and an id."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-        response = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={
-                "url": "https://example.com/create",
-                "event_types": ["consolidation.completed"],
-            },
-        )
-        assert response.status_code == 201, response.text
-        data = response.json()
-        assert "id" in data
-        assert data["url"] == "https://example.com/create"
-        assert data["bank_id"] == bank_id
-        assert data["secret"] is None  # secrets are never echoed back
-
-        # Cleanup
-        await api_client.delete(
-            f"/v1/default/banks/{bank_id}/webhooks/{data['id']}"
-        )
-
-    @pytest.mark.asyncio
-    async def test_http_list_webhooks(self, api_client: httpx.AsyncClient):
-        """GET /webhooks returns the webhooks registered for a bank."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/list", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        list_resp = await api_client.get(f"/v1/default/banks/{bank_id}/webhooks")
-        assert list_resp.status_code == 200
-        items = list_resp.json()["items"]
-        assert any(item["id"] == webhook_id for item in items)
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-    @pytest.mark.asyncio
-    async def test_http_delete_webhook(self, api_client: httpx.AsyncClient):
-        """DELETE /webhooks/{id} removes the webhook; subsequent list returns empty for that bank."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/delete", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        delete_resp = await api_client.delete(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}"
-        )
-        assert delete_resp.status_code == 200
-        assert delete_resp.json()["success"] is True
-
-        list_resp = await api_client.get(f"/v1/default/banks/{bank_id}/webhooks")
-        assert list_resp.status_code == 200
-        ids = [item["id"] for item in list_resp.json()["items"]]
-        assert webhook_id not in ids
-
-    @pytest.mark.asyncio
-    async def test_http_delete_webhook_not_found(self, api_client: httpx.AsyncClient):
-        """DELETE with a non-existent webhook id returns 404."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-        missing_id = str(uuid.uuid4())
-        response = await api_client.delete(
-            f"/v1/default/banks/{bank_id}/webhooks/{missing_id}"
-        )
-        assert response.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_http_list_deliveries(
-        self, memory: MemoryEngine, api_client: httpx.AsyncClient
-    ):
-        """GET /webhooks/{id}/deliveries returns delivery records for a webhook."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        # Create webhook via HTTP API
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={
-                "url": "https://example.com/deliveries",
-                "event_types": ["consolidation.completed"],
-            },
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        # Insert a delivery row directly into async_operations
-        delivery_id = uuid.uuid4()
-        now = datetime.now(timezone.utc)
-        task_payload = json.dumps(
-            {
-                "type": "webhook_delivery",
-                "bank_id": bank_id,
-                "url": "https://example.com/deliveries",
-                "secret": None,
-                "event_type": "consolidation.completed",
-                "payload": '{"event":"consolidation.completed"}',
-                "webhook_id": webhook_id,
-            }
-        )
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO async_operations
-                  (operation_id, bank_id, operation_type, status, retry_count, task_payload, result_metadata, created_at, updated_at)
-                VALUES ($1, $2, 'webhook_delivery', 'completed', 0, $3::jsonb, '{}'::jsonb, $4, $4)
-                """,
-                delivery_id,
-                bank_id,
-                task_payload,
-                now,
-            )
-
-        try:
-            deliveries_resp = await api_client.get(
-                f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}/deliveries"
-            )
-            assert deliveries_resp.status_code == 200
-            items = deliveries_resp.json()["items"]
-            ids = [item["id"] for item in items]
-            assert str(delivery_id) in ids
-
-            # Verify shape of a delivery item
-            delivery = next(item for item in items if item["id"] == str(delivery_id))
-            assert delivery["status"] == "completed"
-            assert delivery["event_type"] == "consolidation.completed"
-            assert delivery["attempts"] == 1
-        finally:
-            async with memory._pool.acquire() as conn:
-                await conn.execute(
-                    "DELETE FROM async_operations WHERE operation_id = $1", delivery_id
-                )
-            await api_client.delete(
-                f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}"
-            )
-
-    @pytest.mark.asyncio
-    async def test_http_list_deliveries_webhook_not_found(self, api_client: httpx.AsyncClient):
-        """GET /webhooks/{id}/deliveries for a non-existent webhook returns 404."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-        missing_id = str(uuid.uuid4())
-        response = await api_client.get(
-            f"/v1/default/banks/{bank_id}/webhooks/{missing_id}/deliveries"
-        )
-        assert response.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_url(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} updates only the provided fields."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/original", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        patch_resp = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-            json={"url": "https://example.com/updated"},
-        )
-        assert patch_resp.status_code == 200
-        data = patch_resp.json()
-        assert data["url"] == "https://example.com/updated"
-        # event_types should be unchanged
-        assert "consolidation.completed" in data["event_types"]
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_event_types(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} can update event_types."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/hook", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        patch_resp = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-            json={"event_types": ["retain.completed"]},
-        )
-        assert patch_resp.status_code == 200
-        data = patch_resp.json()
-        assert data["event_types"] == ["retain.completed"]
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_enabled(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} can toggle enabled."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/hook", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-        assert create_resp.json()["enabled"] is True
-
-        patch_resp = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-            json={"enabled": False},
-        )
-        assert patch_resp.status_code == 200
-        assert patch_resp.json()["enabled"] is False
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_http_config(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} can update http_config."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/hook", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        patch_resp = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-            json={
-                "http_config": {
-                    "method": "POST",
-                    "timeout_seconds": 10,
-                    "headers": {"X-Custom": "value"},
-                    "params": {},
-                }
-            },
-        )
-        assert patch_resp.status_code == 200
-        data = patch_resp.json()
-        assert data["http_config"]["timeout_seconds"] == 10
-        assert data["http_config"]["headers"] == {"X-Custom": "value"}
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_not_found(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} returns 404 for a non-existent webhook."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-        missing_id = str(uuid.uuid4())
-        response = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{missing_id}",
-            json={"url": "https://example.com/new"},
-        )
-        assert response.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_http_update_webhook_no_fields(self, api_client: httpx.AsyncClient):
-        """PATCH /webhooks/{id} with empty body returns 422."""
-        bank_id = f"http-wh-{uuid.uuid4().hex[:8]}"
-
-        create_resp = await api_client.post(
-            f"/v1/default/banks/{bank_id}/webhooks",
-            json={"url": "https://example.com/hook", "event_types": ["consolidation.completed"]},
-        )
-        assert create_resp.status_code == 201
-        webhook_id = create_resp.json()["id"]
-
-        patch_resp = await api_client.patch(
-            f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}",
-            json={},
-        )
-        assert patch_resp.status_code == 422
-
-        # Cleanup
-        await api_client.delete(f"/v1/default/banks/{bank_id}/webhooks/{webhook_id}")
-
-
-# ---------------------------------------------------------------------------
-# retain.completed webhook tests
-# ---------------------------------------------------------------------------
-
-
-class TestRetainCompletedWebhook:
-    """Tests for the retain.completed webhook event."""
-
-    def test_retain_event_data_model(self):
-        """RetainEventData can be constructed with optional fields."""
-        data = RetainEventData(document_id="doc-123", tags=["tag1", "tag2"])
-        assert data.document_id == "doc-123"
-        assert data.tags == ["tag1", "tag2"]
-
-        empty = RetainEventData()
-        assert empty.document_id is None
-        assert empty.tags is None
-
-    def test_retain_event_type_value(self):
-        """WebhookEventType.RETAIN_COMPLETED has the correct string value."""
-        assert WebhookEventType.RETAIN_COMPLETED == "retain.completed"
-
-    @pytest.mark.asyncio
-    async def test_fire_retain_webhook_queues_per_document(
-        self, memory: MemoryEngine, webhook_manager: WebhookManager
-    ):
-        """_fire_retain_webhook queues one delivery task per content item."""
-        bank_id = f"wh-retain-{uuid.uuid4().hex[:8]}"
-        webhook_id = uuid.uuid4()
-
-        async with memory._pool.acquire() as conn:
-            await conn.execute(
-                """
-                INSERT INTO webhooks (id, bank_id, url, secret, event_types, enabled, created_at, updated_at)
-                VALUES ($1, $2, $3, NULL, $4, true, NOW(), NOW())
-                """,
-                webhook_id,
-                bank_id,
-                "https://example.com/retain-hook",
-                ["retain.completed"],
-            )
-
-        try:
-            contents = [
-                {"content": "Alice works at Google", "document_id": "doc-1"},
-                {"content": "Bob loves Python", "document_id": "doc-2"},
-            ]
-            # Temporarily replace webhook manager on memory engine
-            original_manager = memory._webhook_manager
-            memory._webhook_manager = webhook_manager
-            try:
-                callback = memory._build_retain_outbox_callback(
-                    bank_id=bank_id,
-                    contents=contents,
-                    operation_id="test-op-123",
-                )
-                assert callback is not None
-                async with memory._pool.acquire() as conn:
-                    await callback(conn)
-            finally:
-                memory._webhook_manager = original_manager
-
-            async with memory._pool.acquire() as conn:
-                rows = await conn.fetch(
-                    """
-                    SELECT task_payload
-                    FROM async_operations
-                    WHERE operation_type = 'webhook_delivery'
-                      AND bank_id = $1
-                      AND task_payload->>'event_type' = 'retain.completed'
-                    ORDER BY created_at
-                    """,
-                    bank_id,
-                )
-
-            assert len(rows) == 2
-            payloads = []
-            for row in rows:
-                p = row["task_payload"]
-                if isinstance(p, str):
-                    p = json.loads(p)
-                payloads.append(p)
-
-            doc_ids_in_payloads = [json.loads(p["payload"]).get("data", {}).get("document_id") for p in payloads]
-            assert "doc-1" in doc_ids_in_payloads
-            assert "doc-2" in doc_ids_in_payloads
-        finally:
-            async with memory._pool.acquire() as conn:
-                await conn.execute(
-                    "DELETE FROM async_operations WHERE operation_type = 'webhook_delivery' AND bank_id = $1",
-                    bank_id,
-                )
-                await conn.execute("DELETE FROM webhooks WHERE id = $1", webhook_id)

hindsight-api/tests/test_worker.py

@@ -294,17 +294,14 @@ class TestWorkerPoller:
             payload,
         )
 
-        from datetime import datetime, timezone
-
-        from hindsight_api.worker.exceptions import RetryTaskAt
-
         async def failing_executor(task_dict):
-            raise RetryTaskAt(retry_at=datetime.now(timezone.utc), message="TimeoutError during recall")
+            raise ValueError("TimeoutError during recall")
 
         poller = WorkerPoller(
             pool=pool,
             worker_id="test-worker-1",
             executor=failing_executor,
+            max_retries=3,
         )
 
         task_dict = json.loads(payload)
@@ -329,35 +326,39 @@ class TestWorkerPoller:
         assert row["retry_count"] == 1
 
     @pytest.mark.asyncio
-    async def test_executor_exception_marks_failed_immediately(self, pool, clean_operations):
-        """Test that a plain exception (not RetryTaskAt) permanently marks a task as 'failed'.
+    async def test_executor_exception_marks_failed_after_max_retries(self, pool, clean_operations):
+        """Test that a task is permanently marked 'failed' once retry_count hits max_retries.
 
-        With the task-owned retry model, plain exceptions are non-retryable — the poller
-        marks them as 'failed' immediately. Tasks that want to be retried must raise RetryTaskAt.
+        After max_retries exhaustion the task must NOT be reset to 'pending' — it should
+        be marked 'failed' with an error message so it stops consuming retry budget.
         """
         from hindsight_api.worker import WorkerPoller
         from hindsight_api.worker.poller import ClaimedTask
 
+        max_retries = 3
         bank_id = f"test-worker-{uuid.uuid4().hex[:8]}"
         op_id = uuid.uuid4()
         payload = json.dumps({"type": "consolidation", "operation_id": str(op_id), "bank_id": bank_id})
+        # Insert with retry_count already at the limit
         await pool.execute(
             """
             INSERT INTO async_operations (operation_id, bank_id, operation_type, status, task_payload, worker_id, claimed_at, retry_count)
-            VALUES ($1, $2, 'consolidation', 'processing', $3::jsonb, 'test-worker-1', now(), 0)
+            VALUES ($1, $2, 'consolidation', 'processing', $3::jsonb, 'test-worker-1', now(), $4)
             """,
             op_id,
             bank_id,
             payload,
+            max_retries,
         )
 
         async def failing_executor(task_dict):
-            raise ValueError("Non-retryable error")
+            raise ValueError("Still failing after all retries")
 
         poller = WorkerPoller(
             pool=pool,
             worker_id="test-worker-1",
             executor=failing_executor,
+            max_retries=max_retries,
         )
 
         task_dict = json.loads(payload)
@@ -372,10 +373,11 @@ class TestWorkerPoller:
             op_id,
         )
         assert row["status"] == "failed", (
-            f"Expected 'failed' for plain exception, got '{row['status']}'"
+            f"Expected 'failed' after max retries, got '{row['status']}'"
         )
         assert row["error_message"] is not None
-        assert row["retry_count"] == 0  # not incremented; plain exception = immediate fail
+        assert "Max retries" in row["error_message"]
+        assert row["retry_count"] == max_retries  # not incremented further
 
     @pytest.mark.asyncio
     async def test_executor_failed_status_not_overridden(self, pool, clean_operations):

hindsight-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hindsight-cli"
-version = "0.4.16"
+version = "0.4.15"
 edition = "2021"
 authors = ["Hindsight Team"]
 description = "A beautiful CLI for Hindsight - semantic memory system"

hindsight-clients/go/api/openapi.yaml

@@ -7,7 +7,7 @@ info:
     name: Apache 2.0
     url: https://www.apache.org/licenses/LICENSE-2.0.html
   title: Hindsight HTTP API
-  version: 0.4.16
+  version: 0.4.15
 servers:
 - url: /
 paths:
@@ -2111,248 +2111,6 @@ paths:
       summary: Trigger consolidation
       tags:
       - Banks
-  /v1/default/banks/{bank_id}/webhooks:
-    get:
-      description: List all webhooks registered for a bank.
-      operationId: list_webhooks
-      parameters:
-      - explode: false
-        in: path
-        name: bank_id
-        required: true
-        schema:
-          title: Bank Id
-          type: string
-        style: simple
-      - explode: false
-        in: header
-        name: authorization
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: simple
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/WebhookListResponse'
-          description: Successful Response
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: List webhooks
-      tags:
-      - Webhooks
-    post:
-      description: Register a webhook endpoint to receive event notifications for
-        this bank.
-      operationId: create_webhook
-      parameters:
-      - explode: false
-        in: path
-        name: bank_id
-        required: true
-        schema:
-          title: Bank Id
-          type: string
-        style: simple
-      - explode: false
-        in: header
-        name: authorization
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: simple
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/CreateWebhookRequest'
-        required: true
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/WebhookResponse'
-          description: Successful Response
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: Register webhook
-      tags:
-      - Webhooks
-  /v1/default/banks/{bank_id}/webhooks/{webhook_id}:
-    delete:
-      description: Remove a registered webhook.
-      operationId: delete_webhook
-      parameters:
-      - explode: false
-        in: path
-        name: bank_id
-        required: true
-        schema:
-          title: Bank Id
-          type: string
-        style: simple
-      - explode: false
-        in: path
-        name: webhook_id
-        required: true
-        schema:
-          title: Webhook Id
-          type: string
-        style: simple
-      - explode: false
-        in: header
-        name: authorization
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: simple
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/DeleteResponse'
-          description: Successful Response
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: Delete webhook
-      tags:
-      - Webhooks
-    patch:
-      description: Update one or more fields of a registered webhook. Only provided
-        fields are changed.
-      operationId: update_webhook
-      parameters:
-      - explode: false
-        in: path
-        name: bank_id
-        required: true
-        schema:
-          title: Bank Id
-          type: string
-        style: simple
-      - explode: false
-        in: path
-        name: webhook_id
-        required: true
-        schema:
-          title: Webhook Id
-          type: string
-        style: simple
-      - explode: false
-        in: header
-        name: authorization
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: simple
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/UpdateWebhookRequest'
-        required: true
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/WebhookResponse'
-          description: Successful Response
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: Update webhook
-      tags:
-      - Webhooks
-  /v1/default/banks/{bank_id}/webhooks/{webhook_id}/deliveries:
-    get:
-      description: Inspect delivery history for a webhook (useful for debugging).
-      operationId: list_webhook_deliveries
-      parameters:
-      - explode: false
-        in: path
-        name: bank_id
-        required: true
-        schema:
-          title: Bank Id
-          type: string
-        style: simple
-      - explode: false
-        in: path
-        name: webhook_id
-        required: true
-        schema:
-          title: Webhook Id
-          type: string
-        style: simple
-      - description: Maximum number of deliveries to return
-        explode: true
-        in: query
-        name: limit
-        required: false
-        schema:
-          default: 50
-          description: Maximum number of deliveries to return
-          maximum: 200
-          title: Limit
-          type: integer
-        style: form
-      - description: Pagination cursor (created_at of last item)
-        explode: true
-        in: query
-        name: cursor
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: form
-      - explode: false
-        in: header
-        name: authorization
-        required: false
-        schema:
-          nullable: true
-          type: string
-        style: simple
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/WebhookDeliveryListResponse'
-          description: Successful Response
-        "422":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-          description: Validation Error
-      summary: List webhook deliveries
-      tags:
-      - Webhooks
   /v1/default/banks/{bank_id}/memories:
     delete:
       description: "Delete memory units for a memory bank. Optionally filter by type\
@@ -3121,47 +2879,6 @@ components:
       required:
       - operation_id
       title: CreateMentalModelResponse
-    CreateWebhookRequest:
-      description: Request model for registering a webhook.
-      example:
-        event_types:
-        - event_types
-        - event_types
-        secret: secret
-        http_config:
-          headers:
-            key: headers
-          method: POST
-          timeout_seconds: 0
-          params:
-            key: params
-        url: url
-        enabled: true
-      properties:
-        url:
-          description: HTTP(S) endpoint URL to deliver events to
-          title: Url
-          type: string
-        secret:
-          nullable: true
-          type: string
-        event_types:
-          default:
-          - consolidation.completed
-          description: "List of event types to deliver. Currently supported: 'consolidation.completed'"
-          items:
-            type: string
-          type: array
-        enabled:
-          default: true
-          description: Whether this webhook is active
-          title: Enabled
-          type: boolean
-        http_config:
-          $ref: '#/components/schemas/WebhookHttpConfig'
-      required:
-      - url
-      title: CreateWebhookRequest
     DeleteDocumentResponse:
       description: Response model for delete document endpoint.
       example:
@@ -4720,41 +4437,6 @@ components:
         trigger:
           $ref: '#/components/schemas/MentalModelTrigger'
       title: UpdateMentalModelRequest
-    UpdateWebhookRequest:
-      description: Request model for updating a webhook. Only provided fields are
-        updated.
-      example:
-        event_types:
-        - event_types
-        - event_types
-        secret: secret
-        http_config:
-          headers:
-            key: headers
-          method: POST
-          timeout_seconds: 0
-          params:
-            key: params
-        url: url
-        enabled: true
-      properties:
-        url:
-          nullable: true
-          type: string
-        secret:
-          nullable: true
-          type: string
-        event_types:
-          items:
-            type: string
-          nullable: true
-          type: array
-        enabled:
-          nullable: true
-          type: boolean
-        http_config:
-          $ref: '#/components/schemas/WebhookHttpConfig'
-      title: UpdateWebhookRequest
     ValidationError:
       example:
         msg: msg
@@ -4799,244 +4481,6 @@ components:
       - api_version
       - features
       title: VersionResponse
-    WebhookDeliveryListResponse:
-      description: Response model for listing webhook deliveries.
-      example:
-        next_cursor: next_cursor
-        items:
-        - last_response_body: last_response_body
-          last_attempt_at: last_attempt_at
-          created_at: created_at
-          last_response_status: 6
-          url: url
-          event_type: event_type
-          updated_at: updated_at
-          webhook_id: webhook_id
-          next_retry_at: next_retry_at
-          id: id
-          last_error: last_error
-          status: status
-          attempts: 0
-        - last_response_body: last_response_body
-          last_attempt_at: last_attempt_at
-          created_at: created_at
-          last_response_status: 6
-          url: url
-          event_type: event_type
-          updated_at: updated_at
-          webhook_id: webhook_id
-          next_retry_at: next_retry_at
-          id: id
-          last_error: last_error
-          status: status
-          attempts: 0
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/WebhookDeliveryResponse'
-          type: array
-        next_cursor:
-          nullable: true
-          type: string
-      required:
-      - items
-      title: WebhookDeliveryListResponse
-    WebhookDeliveryResponse:
-      description: Response model for a webhook delivery record.
-      example:
-        last_response_body: last_response_body
-        last_attempt_at: last_attempt_at
-        created_at: created_at
-        last_response_status: 6
-        url: url
-        event_type: event_type
-        updated_at: updated_at
-        webhook_id: webhook_id
-        next_retry_at: next_retry_at
-        id: id
-        last_error: last_error
-        status: status
-        attempts: 0
-      properties:
-        id:
-          title: Id
-          type: string
-        webhook_id:
-          nullable: true
-          type: string
-        url:
-          title: Url
-          type: string
-        event_type:
-          title: Event Type
-          type: string
-        status:
-          title: Status
-          type: string
-        attempts:
-          title: Attempts
-          type: integer
-        next_retry_at:
-          nullable: true
-          type: string
-        last_error:
-          nullable: true
-          type: string
-        last_response_status:
-          nullable: true
-          type: integer
-        last_response_body:
-          nullable: true
-          type: string
-        last_attempt_at:
-          nullable: true
-          type: string
-        created_at:
-          nullable: true
-          type: string
-        updated_at:
-          nullable: true
-          type: string
-      required:
-      - attempts
-      - event_type
-      - id
-      - status
-      - url
-      - webhook_id
-      title: WebhookDeliveryResponse
-    WebhookHttpConfig:
-      description: HTTP delivery configuration for a webhook.
-      example:
-        headers:
-          key: headers
-        method: POST
-        timeout_seconds: 0
-        params:
-          key: params
-      properties:
-        method:
-          default: POST
-          description: "HTTP method: GET or POST"
-          title: Method
-          type: string
-        timeout_seconds:
-          default: 30
-          description: HTTP request timeout in seconds
-          title: Timeout Seconds
-          type: integer
-        headers:
-          additionalProperties:
-            type: string
-          description: Custom HTTP headers
-          title: Headers
-        params:
-          additionalProperties:
-            type: string
-          description: Custom HTTP query parameters
-          title: Params
-      title: WebhookHttpConfig
-    WebhookListResponse:
-      description: Response model for listing webhooks.
-      example:
-        items:
-        - event_types:
-          - event_types
-          - event_types
-          updated_at: updated_at
-          bank_id: bank_id
-          created_at: created_at
-          id: id
-          secret: secret
-          http_config:
-            headers:
-              key: headers
-            method: POST
-            timeout_seconds: 0
-            params:
-              key: params
-          url: url
-          enabled: true
-        - event_types:
-          - event_types
-          - event_types
-          updated_at: updated_at
-          bank_id: bank_id
-          created_at: created_at
-          id: id
-          secret: secret
-          http_config:
-            headers:
-              key: headers
-            method: POST
-            timeout_seconds: 0
-            params:
-              key: params
-          url: url
-          enabled: true
-      properties:
-        items:
-          items:
-            $ref: '#/components/schemas/WebhookResponse'
-          type: array
-      required:
-      - items
-      title: WebhookListResponse
-    WebhookResponse:
-      description: Response model for a webhook.
-      example:
-        event_types:
-        - event_types
-        - event_types
-        updated_at: updated_at
-        bank_id: bank_id
-        created_at: created_at
-        id: id
-        secret: secret
-        http_config:
-          headers:
-            key: headers
-          method: POST
-          timeout_seconds: 0
-          params:
-            key: params
-        url: url
-        enabled: true
-      properties:
-        id:
-          title: Id
-          type: string
-        bank_id:
-          nullable: true
-          type: string
-        url:
-          title: Url
-          type: string
-        secret:
-          nullable: true
-          type: string
-        event_types:
-          items:
-            type: string
-          type: array
-        enabled:
-          title: Enabled
-          type: boolean
-        http_config:
-          $ref: '#/components/schemas/WebhookHttpConfig'
-        created_at:
-          nullable: true
-          type: string
-        updated_at:
-          nullable: true
-          type: string
-      required:
-      - bank_id
-      - enabled
-      - event_types
-      - id
-      - url
-      title: WebhookResponse
     Timestamp:
       anyOf:
       - format: date-time

hindsight-clients/go/api_banks.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_directives.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_documents.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_entities.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_files.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_memory.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_mental_models.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_monitoring.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_operations.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/api_webhooks.go

@@ -1,691 +0,0 @@
-/*
-Hindsight HTTP API
-
-HTTP API for Hindsight
-
-API version: 0.4.16
-*/
-
-// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
-
-package hindsight
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-)
-
-
-// WebhooksAPIService WebhooksAPI service
-type WebhooksAPIService service
-
-type ApiCreateWebhookRequest struct {
-	ctx context.Context
-	ApiService *WebhooksAPIService
-	bankId string
-	createWebhookRequest *CreateWebhookRequest
-	authorization *string
-}
-
-func (r ApiCreateWebhookRequest) CreateWebhookRequest(createWebhookRequest CreateWebhookRequest) ApiCreateWebhookRequest {
-	r.createWebhookRequest = &createWebhookRequest
-	return r
-}
-
-func (r ApiCreateWebhookRequest) Authorization(authorization string) ApiCreateWebhookRequest {
-	r.authorization = &authorization
-	return r
-}
-
-func (r ApiCreateWebhookRequest) Execute() (*WebhookResponse, *http.Response, error) {
-	return r.ApiService.CreateWebhookExecute(r)
-}
-
-/*
-CreateWebhook Register webhook
-
-Register a webhook endpoint to receive event notifications for this bank.
-
- @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
- @param bankId
- @return ApiCreateWebhookRequest
-*/
-func (a *WebhooksAPIService) CreateWebhook(ctx context.Context, bankId string) ApiCreateWebhookRequest {
-	return ApiCreateWebhookRequest{
-		ApiService: a,
-		ctx: ctx,
-		bankId: bankId,
-	}
-}
-
-// Execute executes the request
-//  @return WebhookResponse
-func (a *WebhooksAPIService) CreateWebhookExecute(r ApiCreateWebhookRequest) (*WebhookResponse, *http.Response, error) {
-	var (
-		localVarHTTPMethod   = http.MethodPost
-		localVarPostBody     interface{}
-		formFiles            []formFile
-		localVarReturnValue  *WebhookResponse
-	)
-
-	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "WebhooksAPIService.CreateWebhook")
-	if err != nil {
-		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
-	}
-
-	localVarPath := localBasePath + "/v1/default/banks/{bank_id}/webhooks"
-	localVarPath = strings.Replace(localVarPath, "{"+"bank_id"+"}", url.PathEscape(parameterValueToString(r.bankId, "bankId")), -1)
-
-	localVarHeaderParams := make(map[string]string)
-	localVarQueryParams := url.Values{}
-	localVarFormParams := url.Values{}
-	if r.createWebhookRequest == nil {
-		return localVarReturnValue, nil, reportError("createWebhookRequest is required and must be specified")
-	}
-
-	// to determine the Content-Type header
-	localVarHTTPContentTypes := []string{"application/json"}
-
-	// set Content-Type header
-	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
-	if localVarHTTPContentType != "" {
-		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
-	}
-
-	// to determine the Accept header
-	localVarHTTPHeaderAccepts := []string{"application/json"}
-
-	// set Accept header
-	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
-	if localVarHTTPHeaderAccept != "" {
-		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
-	}
-	if r.authorization != nil {
-		parameterAddToHeaderOrQuery(localVarHeaderParams, "authorization", r.authorization, "simple", "")
-	}
-	// body params
-	localVarPostBody = r.createWebhookRequest
-	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
-	if err != nil {
-		return localVarReturnValue, nil, err
-	}
-
-	localVarHTTPResponse, err := a.client.callAPI(req)
-	if err != nil || localVarHTTPResponse == nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
-	localVarHTTPResponse.Body.Close()
-	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
-	if err != nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	if localVarHTTPResponse.StatusCode >= 300 {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: localVarHTTPResponse.Status,
-		}
-		if localVarHTTPResponse.StatusCode == 422 {
-			var v HTTPValidationError
-			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-			if err != nil {
-				newErr.error = err.Error()
-				return localVarReturnValue, localVarHTTPResponse, newErr
-			}
-					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
-					newErr.model = v
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-	if err != nil {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: err.Error(),
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	return localVarReturnValue, localVarHTTPResponse, nil
-}
-
-type ApiDeleteWebhookRequest struct {
-	ctx context.Context
-	ApiService *WebhooksAPIService
-	bankId string
-	webhookId string
-	authorization *string
-}
-
-func (r ApiDeleteWebhookRequest) Authorization(authorization string) ApiDeleteWebhookRequest {
-	r.authorization = &authorization
-	return r
-}
-
-func (r ApiDeleteWebhookRequest) Execute() (*DeleteResponse, *http.Response, error) {
-	return r.ApiService.DeleteWebhookExecute(r)
-}
-
-/*
-DeleteWebhook Delete webhook
-
-Remove a registered webhook.
-
- @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
- @param bankId
- @param webhookId
- @return ApiDeleteWebhookRequest
-*/
-func (a *WebhooksAPIService) DeleteWebhook(ctx context.Context, bankId string, webhookId string) ApiDeleteWebhookRequest {
-	return ApiDeleteWebhookRequest{
-		ApiService: a,
-		ctx: ctx,
-		bankId: bankId,
-		webhookId: webhookId,
-	}
-}
-
-// Execute executes the request
-//  @return DeleteResponse
-func (a *WebhooksAPIService) DeleteWebhookExecute(r ApiDeleteWebhookRequest) (*DeleteResponse, *http.Response, error) {
-	var (
-		localVarHTTPMethod   = http.MethodDelete
-		localVarPostBody     interface{}
-		formFiles            []formFile
-		localVarReturnValue  *DeleteResponse
-	)
-
-	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "WebhooksAPIService.DeleteWebhook")
-	if err != nil {
-		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
-	}
-
-	localVarPath := localBasePath + "/v1/default/banks/{bank_id}/webhooks/{webhook_id}"
-	localVarPath = strings.Replace(localVarPath, "{"+"bank_id"+"}", url.PathEscape(parameterValueToString(r.bankId, "bankId")), -1)
-	localVarPath = strings.Replace(localVarPath, "{"+"webhook_id"+"}", url.PathEscape(parameterValueToString(r.webhookId, "webhookId")), -1)
-
-	localVarHeaderParams := make(map[string]string)
-	localVarQueryParams := url.Values{}
-	localVarFormParams := url.Values{}
-
-	// to determine the Content-Type header
-	localVarHTTPContentTypes := []string{}
-
-	// set Content-Type header
-	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
-	if localVarHTTPContentType != "" {
-		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
-	}
-
-	// to determine the Accept header
-	localVarHTTPHeaderAccepts := []string{"application/json"}
-
-	// set Accept header
-	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
-	if localVarHTTPHeaderAccept != "" {
-		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
-	}
-	if r.authorization != nil {
-		parameterAddToHeaderOrQuery(localVarHeaderParams, "authorization", r.authorization, "simple", "")
-	}
-	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
-	if err != nil {
-		return localVarReturnValue, nil, err
-	}
-
-	localVarHTTPResponse, err := a.client.callAPI(req)
-	if err != nil || localVarHTTPResponse == nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
-	localVarHTTPResponse.Body.Close()
-	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
-	if err != nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	if localVarHTTPResponse.StatusCode >= 300 {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: localVarHTTPResponse.Status,
-		}
-		if localVarHTTPResponse.StatusCode == 422 {
-			var v HTTPValidationError
-			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-			if err != nil {
-				newErr.error = err.Error()
-				return localVarReturnValue, localVarHTTPResponse, newErr
-			}
-					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
-					newErr.model = v
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-	if err != nil {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: err.Error(),
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	return localVarReturnValue, localVarHTTPResponse, nil
-}
-
-type ApiListWebhookDeliveriesRequest struct {
-	ctx context.Context
-	ApiService *WebhooksAPIService
-	bankId string
-	webhookId string
-	limit *int32
-	cursor *string
-	authorization *string
-}
-
-// Maximum number of deliveries to return
-func (r ApiListWebhookDeliveriesRequest) Limit(limit int32) ApiListWebhookDeliveriesRequest {
-	r.limit = &limit
-	return r
-}
-
-// Pagination cursor (created_at of last item)
-func (r ApiListWebhookDeliveriesRequest) Cursor(cursor string) ApiListWebhookDeliveriesRequest {
-	r.cursor = &cursor
-	return r
-}
-
-func (r ApiListWebhookDeliveriesRequest) Authorization(authorization string) ApiListWebhookDeliveriesRequest {
-	r.authorization = &authorization
-	return r
-}
-
-func (r ApiListWebhookDeliveriesRequest) Execute() (*WebhookDeliveryListResponse, *http.Response, error) {
-	return r.ApiService.ListWebhookDeliveriesExecute(r)
-}
-
-/*
-ListWebhookDeliveries List webhook deliveries
-
-Inspect delivery history for a webhook (useful for debugging).
-
- @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
- @param bankId
- @param webhookId
- @return ApiListWebhookDeliveriesRequest
-*/
-func (a *WebhooksAPIService) ListWebhookDeliveries(ctx context.Context, bankId string, webhookId string) ApiListWebhookDeliveriesRequest {
-	return ApiListWebhookDeliveriesRequest{
-		ApiService: a,
-		ctx: ctx,
-		bankId: bankId,
-		webhookId: webhookId,
-	}
-}
-
-// Execute executes the request
-//  @return WebhookDeliveryListResponse
-func (a *WebhooksAPIService) ListWebhookDeliveriesExecute(r ApiListWebhookDeliveriesRequest) (*WebhookDeliveryListResponse, *http.Response, error) {
-	var (
-		localVarHTTPMethod   = http.MethodGet
-		localVarPostBody     interface{}
-		formFiles            []formFile
-		localVarReturnValue  *WebhookDeliveryListResponse
-	)
-
-	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "WebhooksAPIService.ListWebhookDeliveries")
-	if err != nil {
-		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
-	}
-
-	localVarPath := localBasePath + "/v1/default/banks/{bank_id}/webhooks/{webhook_id}/deliveries"
-	localVarPath = strings.Replace(localVarPath, "{"+"bank_id"+"}", url.PathEscape(parameterValueToString(r.bankId, "bankId")), -1)
-	localVarPath = strings.Replace(localVarPath, "{"+"webhook_id"+"}", url.PathEscape(parameterValueToString(r.webhookId, "webhookId")), -1)
-
-	localVarHeaderParams := make(map[string]string)
-	localVarQueryParams := url.Values{}
-	localVarFormParams := url.Values{}
-
-	if r.limit != nil {
-		parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
-	} else {
-		var defaultValue int32 = 50
-		r.limit = &defaultValue
-	}
-	if r.cursor != nil {
-		parameterAddToHeaderOrQuery(localVarQueryParams, "cursor", r.cursor, "form", "")
-	}
-	// to determine the Content-Type header
-	localVarHTTPContentTypes := []string{}
-
-	// set Content-Type header
-	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
-	if localVarHTTPContentType != "" {
-		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
-	}
-
-	// to determine the Accept header
-	localVarHTTPHeaderAccepts := []string{"application/json"}
-
-	// set Accept header
-	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
-	if localVarHTTPHeaderAccept != "" {
-		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
-	}
-	if r.authorization != nil {
-		parameterAddToHeaderOrQuery(localVarHeaderParams, "authorization", r.authorization, "simple", "")
-	}
-	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
-	if err != nil {
-		return localVarReturnValue, nil, err
-	}
-
-	localVarHTTPResponse, err := a.client.callAPI(req)
-	if err != nil || localVarHTTPResponse == nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
-	localVarHTTPResponse.Body.Close()
-	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
-	if err != nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	if localVarHTTPResponse.StatusCode >= 300 {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: localVarHTTPResponse.Status,
-		}
-		if localVarHTTPResponse.StatusCode == 422 {
-			var v HTTPValidationError
-			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-			if err != nil {
-				newErr.error = err.Error()
-				return localVarReturnValue, localVarHTTPResponse, newErr
-			}
-					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
-					newErr.model = v
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-	if err != nil {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: err.Error(),
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	return localVarReturnValue, localVarHTTPResponse, nil
-}
-
-type ApiListWebhooksRequest struct {
-	ctx context.Context
-	ApiService *WebhooksAPIService
-	bankId string
-	authorization *string
-}
-
-func (r ApiListWebhooksRequest) Authorization(authorization string) ApiListWebhooksRequest {
-	r.authorization = &authorization
-	return r
-}
-
-func (r ApiListWebhooksRequest) Execute() (*WebhookListResponse, *http.Response, error) {
-	return r.ApiService.ListWebhooksExecute(r)
-}
-
-/*
-ListWebhooks List webhooks
-
-List all webhooks registered for a bank.
-
- @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
- @param bankId
- @return ApiListWebhooksRequest
-*/
-func (a *WebhooksAPIService) ListWebhooks(ctx context.Context, bankId string) ApiListWebhooksRequest {
-	return ApiListWebhooksRequest{
-		ApiService: a,
-		ctx: ctx,
-		bankId: bankId,
-	}
-}
-
-// Execute executes the request
-//  @return WebhookListResponse
-func (a *WebhooksAPIService) ListWebhooksExecute(r ApiListWebhooksRequest) (*WebhookListResponse, *http.Response, error) {
-	var (
-		localVarHTTPMethod   = http.MethodGet
-		localVarPostBody     interface{}
-		formFiles            []formFile
-		localVarReturnValue  *WebhookListResponse
-	)
-
-	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "WebhooksAPIService.ListWebhooks")
-	if err != nil {
-		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
-	}
-
-	localVarPath := localBasePath + "/v1/default/banks/{bank_id}/webhooks"
-	localVarPath = strings.Replace(localVarPath, "{"+"bank_id"+"}", url.PathEscape(parameterValueToString(r.bankId, "bankId")), -1)
-
-	localVarHeaderParams := make(map[string]string)
-	localVarQueryParams := url.Values{}
-	localVarFormParams := url.Values{}
-
-	// to determine the Content-Type header
-	localVarHTTPContentTypes := []string{}
-
-	// set Content-Type header
-	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
-	if localVarHTTPContentType != "" {
-		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
-	}
-
-	// to determine the Accept header
-	localVarHTTPHeaderAccepts := []string{"application/json"}
-
-	// set Accept header
-	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
-	if localVarHTTPHeaderAccept != "" {
-		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
-	}
-	if r.authorization != nil {
-		parameterAddToHeaderOrQuery(localVarHeaderParams, "authorization", r.authorization, "simple", "")
-	}
-	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
-	if err != nil {
-		return localVarReturnValue, nil, err
-	}
-
-	localVarHTTPResponse, err := a.client.callAPI(req)
-	if err != nil || localVarHTTPResponse == nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
-	localVarHTTPResponse.Body.Close()
-	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
-	if err != nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	if localVarHTTPResponse.StatusCode >= 300 {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: localVarHTTPResponse.Status,
-		}
-		if localVarHTTPResponse.StatusCode == 422 {
-			var v HTTPValidationError
-			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-			if err != nil {
-				newErr.error = err.Error()
-				return localVarReturnValue, localVarHTTPResponse, newErr
-			}
-					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
-					newErr.model = v
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-	if err != nil {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: err.Error(),
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	return localVarReturnValue, localVarHTTPResponse, nil
-}
-
-type ApiUpdateWebhookRequest struct {
-	ctx context.Context
-	ApiService *WebhooksAPIService
-	bankId string
-	webhookId string
-	updateWebhookRequest *UpdateWebhookRequest
-	authorization *string
-}
-
-func (r ApiUpdateWebhookRequest) UpdateWebhookRequest(updateWebhookRequest UpdateWebhookRequest) ApiUpdateWebhookRequest {
-	r.updateWebhookRequest = &updateWebhookRequest
-	return r
-}
-
-func (r ApiUpdateWebhookRequest) Authorization(authorization string) ApiUpdateWebhookRequest {
-	r.authorization = &authorization
-	return r
-}
-
-func (r ApiUpdateWebhookRequest) Execute() (*WebhookResponse, *http.Response, error) {
-	return r.ApiService.UpdateWebhookExecute(r)
-}
-
-/*
-UpdateWebhook Update webhook
-
-Update one or more fields of a registered webhook. Only provided fields are changed.
-
- @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
- @param bankId
- @param webhookId
- @return ApiUpdateWebhookRequest
-*/
-func (a *WebhooksAPIService) UpdateWebhook(ctx context.Context, bankId string, webhookId string) ApiUpdateWebhookRequest {
-	return ApiUpdateWebhookRequest{
-		ApiService: a,
-		ctx: ctx,
-		bankId: bankId,
-		webhookId: webhookId,
-	}
-}
-
-// Execute executes the request
-//  @return WebhookResponse
-func (a *WebhooksAPIService) UpdateWebhookExecute(r ApiUpdateWebhookRequest) (*WebhookResponse, *http.Response, error) {
-	var (
-		localVarHTTPMethod   = http.MethodPatch
-		localVarPostBody     interface{}
-		formFiles            []formFile
-		localVarReturnValue  *WebhookResponse
-	)
-
-	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "WebhooksAPIService.UpdateWebhook")
-	if err != nil {
-		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
-	}
-
-	localVarPath := localBasePath + "/v1/default/banks/{bank_id}/webhooks/{webhook_id}"
-	localVarPath = strings.Replace(localVarPath, "{"+"bank_id"+"}", url.PathEscape(parameterValueToString(r.bankId, "bankId")), -1)
-	localVarPath = strings.Replace(localVarPath, "{"+"webhook_id"+"}", url.PathEscape(parameterValueToString(r.webhookId, "webhookId")), -1)
-
-	localVarHeaderParams := make(map[string]string)
-	localVarQueryParams := url.Values{}
-	localVarFormParams := url.Values{}
-	if r.updateWebhookRequest == nil {
-		return localVarReturnValue, nil, reportError("updateWebhookRequest is required and must be specified")
-	}
-
-	// to determine the Content-Type header
-	localVarHTTPContentTypes := []string{"application/json"}
-
-	// set Content-Type header
-	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
-	if localVarHTTPContentType != "" {
-		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
-	}
-
-	// to determine the Accept header
-	localVarHTTPHeaderAccepts := []string{"application/json"}
-
-	// set Accept header
-	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
-	if localVarHTTPHeaderAccept != "" {
-		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
-	}
-	if r.authorization != nil {
-		parameterAddToHeaderOrQuery(localVarHeaderParams, "authorization", r.authorization, "simple", "")
-	}
-	// body params
-	localVarPostBody = r.updateWebhookRequest
-	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
-	if err != nil {
-		return localVarReturnValue, nil, err
-	}
-
-	localVarHTTPResponse, err := a.client.callAPI(req)
-	if err != nil || localVarHTTPResponse == nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
-	localVarHTTPResponse.Body.Close()
-	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
-	if err != nil {
-		return localVarReturnValue, localVarHTTPResponse, err
-	}
-
-	if localVarHTTPResponse.StatusCode >= 300 {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: localVarHTTPResponse.Status,
-		}
-		if localVarHTTPResponse.StatusCode == 422 {
-			var v HTTPValidationError
-			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-			if err != nil {
-				newErr.error = err.Error()
-				return localVarReturnValue, localVarHTTPResponse, newErr
-			}
-					newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
-					newErr.model = v
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
-	if err != nil {
-		newErr := &GenericOpenAPIError{
-			body:  localVarBody,
-			error: err.Error(),
-		}
-		return localVarReturnValue, localVarHTTPResponse, newErr
-	}
-
-	return localVarReturnValue, localVarHTTPResponse, nil
-}

hindsight-clients/go/client.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
@@ -41,7 +41,7 @@ var (
 	queryDescape    = strings.NewReplacer( "%5B", "[", "%5D", "]" )
 )
 
-// APIClient manages communication with the Hindsight HTTP API API v0.4.16
+// APIClient manages communication with the Hindsight HTTP API API v0.4.15
 // In most cases there should be only one, shared, APIClient.
 type APIClient struct {
 	cfg    *Configuration
@@ -66,8 +66,6 @@ type APIClient struct {
 	MonitoringAPI *MonitoringAPIService
 
 	OperationsAPI *OperationsAPIService
-
-	WebhooksAPI *WebhooksAPIService
 }
 
 type service struct {
@@ -95,7 +93,6 @@ func NewAPIClient(cfg *Configuration) *APIClient {
 	c.MentalModelsAPI = (*MentalModelsAPIService)(&c.common)
 	c.MonitoringAPI = (*MonitoringAPIService)(&c.common)
 	c.OperationsAPI = (*OperationsAPIService)(&c.common)
-	c.WebhooksAPI = (*WebhooksAPIService)(&c.common)
 
 	return c
 }

hindsight-clients/go/configuration.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_add_background_request.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_async_operation_submit_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_background_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_config_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_config_update.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_list_item.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_list_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_profile_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_bank_stats_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_budget.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_cancel_operation_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_child_operation_status.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_chunk_data.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_chunk_include_options.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_chunk_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_clear_memory_observations_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_consolidation_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_create_bank_request.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_create_directive_request.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_create_mental_model_request.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_create_mental_model_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_create_webhook_request.go

@@ -1,320 +0,0 @@
-/*
-Hindsight HTTP API
-
-HTTP API for Hindsight
-
-API version: 0.4.16
-*/
-
-// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
-
-package hindsight
-
-import (
-	"encoding/json"
-	"bytes"
-	"fmt"
-)
-
-// checks if the CreateWebhookRequest type satisfies the MappedNullable interface at compile time
-var _ MappedNullable = &CreateWebhookRequest{}
-
-// CreateWebhookRequest Request model for registering a webhook.
-type CreateWebhookRequest struct {
-	// HTTP(S) endpoint URL to deliver events to
-	Url string `json:"url"`
-	Secret NullableString `json:"secret,omitempty"`
-	// List of event types to deliver. Currently supported: 'consolidation.completed'
-	EventTypes []string `json:"event_types,omitempty"`
-	// Whether this webhook is active
-	Enabled *bool `json:"enabled,omitempty"`
-	// HTTP delivery configuration (method, timeout, headers, params)
-	HttpConfig *WebhookHttpConfig `json:"http_config,omitempty"`
-}
-
-type _CreateWebhookRequest CreateWebhookRequest
-
-// NewCreateWebhookRequest instantiates a new CreateWebhookRequest object
-// This constructor will assign default values to properties that have it defined,
-// and makes sure properties required by API are set, but the set of arguments
-// will change when the set of required properties is changed
-func NewCreateWebhookRequest(url string) *CreateWebhookRequest {
-	this := CreateWebhookRequest{}
-	this.Url = url
-	var enabled bool = true
-	this.Enabled = &enabled
-	return &this
-}
-
-// NewCreateWebhookRequestWithDefaults instantiates a new CreateWebhookRequest object
-// This constructor will only assign default values to properties that have it defined,
-// but it doesn't guarantee that properties required by API are set
-func NewCreateWebhookRequestWithDefaults() *CreateWebhookRequest {
-	this := CreateWebhookRequest{}
-	var enabled bool = true
-	this.Enabled = &enabled
-	return &this
-}
-
-// GetUrl returns the Url field value
-func (o *CreateWebhookRequest) GetUrl() string {
-	if o == nil {
-		var ret string
-		return ret
-	}
-
-	return o.Url
-}
-
-// GetUrlOk returns a tuple with the Url field value
-// and a boolean to check if the value has been set.
-func (o *CreateWebhookRequest) GetUrlOk() (*string, bool) {
-	if o == nil {
-		return nil, false
-	}
-	return &o.Url, true
-}
-
-// SetUrl sets field value
-func (o *CreateWebhookRequest) SetUrl(v string) {
-	o.Url = v
-}
-
-// GetSecret returns the Secret field value if set, zero value otherwise (both if not set or set to explicit null).
-func (o *CreateWebhookRequest) GetSecret() string {
-	if o == nil || IsNil(o.Secret.Get()) {
-		var ret string
-		return ret
-	}
-	return *o.Secret.Get()
-}
-
-// GetSecretOk returns a tuple with the Secret field value if set, nil otherwise
-// and a boolean to check if the value has been set.
-// NOTE: If the value is an explicit nil, `nil, true` will be returned
-func (o *CreateWebhookRequest) GetSecretOk() (*string, bool) {
-	if o == nil {
-		return nil, false
-	}
-	return o.Secret.Get(), o.Secret.IsSet()
-}
-
-// HasSecret returns a boolean if a field has been set.
-func (o *CreateWebhookRequest) HasSecret() bool {
-	if o != nil && o.Secret.IsSet() {
-		return true
-	}
-
-	return false
-}
-
-// SetSecret gets a reference to the given NullableString and assigns it to the Secret field.
-func (o *CreateWebhookRequest) SetSecret(v string) {
-	o.Secret.Set(&v)
-}
-// SetSecretNil sets the value for Secret to be an explicit nil
-func (o *CreateWebhookRequest) SetSecretNil() {
-	o.Secret.Set(nil)
-}
-
-// UnsetSecret ensures that no value is present for Secret, not even an explicit nil
-func (o *CreateWebhookRequest) UnsetSecret() {
-	o.Secret.Unset()
-}
-
-// GetEventTypes returns the EventTypes field value if set, zero value otherwise.
-func (o *CreateWebhookRequest) GetEventTypes() []string {
-	if o == nil || IsNil(o.EventTypes) {
-		var ret []string
-		return ret
-	}
-	return o.EventTypes
-}
-
-// GetEventTypesOk returns a tuple with the EventTypes field value if set, nil otherwise
-// and a boolean to check if the value has been set.
-func (o *CreateWebhookRequest) GetEventTypesOk() ([]string, bool) {
-	if o == nil || IsNil(o.EventTypes) {
-		return nil, false
-	}
-	return o.EventTypes, true
-}
-
-// HasEventTypes returns a boolean if a field has been set.
-func (o *CreateWebhookRequest) HasEventTypes() bool {
-	if o != nil && !IsNil(o.EventTypes) {
-		return true
-	}
-
-	return false
-}
-
-// SetEventTypes gets a reference to the given []string and assigns it to the EventTypes field.
-func (o *CreateWebhookRequest) SetEventTypes(v []string) {
-	o.EventTypes = v
-}
-
-// GetEnabled returns the Enabled field value if set, zero value otherwise.
-func (o *CreateWebhookRequest) GetEnabled() bool {
-	if o == nil || IsNil(o.Enabled) {
-		var ret bool
-		return ret
-	}
-	return *o.Enabled
-}
-
-// GetEnabledOk returns a tuple with the Enabled field value if set, nil otherwise
-// and a boolean to check if the value has been set.
-func (o *CreateWebhookRequest) GetEnabledOk() (*bool, bool) {
-	if o == nil || IsNil(o.Enabled) {
-		return nil, false
-	}
-	return o.Enabled, true
-}
-
-// HasEnabled returns a boolean if a field has been set.
-func (o *CreateWebhookRequest) HasEnabled() bool {
-	if o != nil && !IsNil(o.Enabled) {
-		return true
-	}
-
-	return false
-}
-
-// SetEnabled gets a reference to the given bool and assigns it to the Enabled field.
-func (o *CreateWebhookRequest) SetEnabled(v bool) {
-	o.Enabled = &v
-}
-
-// GetHttpConfig returns the HttpConfig field value if set, zero value otherwise.
-func (o *CreateWebhookRequest) GetHttpConfig() WebhookHttpConfig {
-	if o == nil || IsNil(o.HttpConfig) {
-		var ret WebhookHttpConfig
-		return ret
-	}
-	return *o.HttpConfig
-}
-
-// GetHttpConfigOk returns a tuple with the HttpConfig field value if set, nil otherwise
-// and a boolean to check if the value has been set.
-func (o *CreateWebhookRequest) GetHttpConfigOk() (*WebhookHttpConfig, bool) {
-	if o == nil || IsNil(o.HttpConfig) {
-		return nil, false
-	}
-	return o.HttpConfig, true
-}
-
-// HasHttpConfig returns a boolean if a field has been set.
-func (o *CreateWebhookRequest) HasHttpConfig() bool {
-	if o != nil && !IsNil(o.HttpConfig) {
-		return true
-	}
-
-	return false
-}
-
-// SetHttpConfig gets a reference to the given WebhookHttpConfig and assigns it to the HttpConfig field.
-func (o *CreateWebhookRequest) SetHttpConfig(v WebhookHttpConfig) {
-	o.HttpConfig = &v
-}
-
-func (o CreateWebhookRequest) MarshalJSON() ([]byte, error) {
-	toSerialize,err := o.ToMap()
-	if err != nil {
-		return []byte{}, err
-	}
-	return json.Marshal(toSerialize)
-}
-
-func (o CreateWebhookRequest) ToMap() (map[string]interface{}, error) {
-	toSerialize := map[string]interface{}{}
-	toSerialize["url"] = o.Url
-	if o.Secret.IsSet() {
-		toSerialize["secret"] = o.Secret.Get()
-	}
-	if !IsNil(o.EventTypes) {
-		toSerialize["event_types"] = o.EventTypes
-	}
-	if !IsNil(o.Enabled) {
-		toSerialize["enabled"] = o.Enabled
-	}
-	if !IsNil(o.HttpConfig) {
-		toSerialize["http_config"] = o.HttpConfig
-	}
-	return toSerialize, nil
-}
-
-func (o *CreateWebhookRequest) UnmarshalJSON(data []byte) (err error) {
-	// This validates that all required properties are included in the JSON object
-	// by unmarshalling the object into a generic map with string keys and checking
-	// that every required field exists as a key in the generic map.
-	requiredProperties := []string{
-		"url",
-	}
-
-	allProperties := make(map[string]interface{})
-
-	err = json.Unmarshal(data, &allProperties)
-
-	if err != nil {
-		return err;
-	}
-
-	for _, requiredProperty := range(requiredProperties) {
-		if _, exists := allProperties[requiredProperty]; !exists {
-			return fmt.Errorf("no value given for required property %v", requiredProperty)
-		}
-	}
-
-	varCreateWebhookRequest := _CreateWebhookRequest{}
-
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.DisallowUnknownFields()
-	err = decoder.Decode(&varCreateWebhookRequest)
-
-	if err != nil {
-		return err
-	}
-
-	*o = CreateWebhookRequest(varCreateWebhookRequest)
-
-	return err
-}
-
-type NullableCreateWebhookRequest struct {
-	value *CreateWebhookRequest
-	isSet bool
-}
-
-func (v NullableCreateWebhookRequest) Get() *CreateWebhookRequest {
-	return v.value
-}
-
-func (v *NullableCreateWebhookRequest) Set(val *CreateWebhookRequest) {
-	v.value = val
-	v.isSet = true
-}
-
-func (v NullableCreateWebhookRequest) IsSet() bool {
-	return v.isSet
-}
-
-func (v *NullableCreateWebhookRequest) Unset() {
-	v.value = nil
-	v.isSet = false
-}
-
-func NewNullableCreateWebhookRequest(val *CreateWebhookRequest) *NullableCreateWebhookRequest {
-	return &NullableCreateWebhookRequest{value: val, isSet: true}
-}
-
-func (v NullableCreateWebhookRequest) MarshalJSON() ([]byte, error) {
-	return json.Marshal(v.value)
-}
-
-func (v *NullableCreateWebhookRequest) UnmarshalJSON(src []byte) error {
-	v.isSet = true
-	return json.Unmarshal(src, &v.value)
-}
-
-

hindsight-clients/go/model_delete_document_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_delete_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_directive_list_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_directive_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_disposition_traits.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_document_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_detail_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_include_options.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_input.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_list_item.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_list_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_observation_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_entity_state_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_features_info.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_file_retain_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_graph_data_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_http_validation_error.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_include_options.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_list_documents_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_list_memory_units_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_list_tags_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_memory_item.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_mental_model_list_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_mental_model_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_mental_model_trigger.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_observation_scopes.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_operation_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_operation_status_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_operations_list_response.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

hindsight-clients/go/model_recall_request.go

@@ -3,7 +3,7 @@ Hindsight HTTP API
 
 HTTP API for Hindsight
 
-API version: 0.4.16
+API version: 0.4.15
 */
 
 // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.