hindsight-api 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

hindsight_api/worker/poller.py

@@ -57,10 +57,11 @@ class WorkerPoller:
         worker_id: str,
         executor: Callable[[dict[str, Any]], Awaitable[None]],
         poll_interval_ms: int = 500,
-        batch_size: int = 10,
         max_retries: int = 3,
         schema: str | None = None,
         tenant_extension: "TenantExtension | None" = None,
+        max_slots: int = 10,
+        consolidation_max_slots: int = 2,
     ):
         """
         Initialize the worker poller.
@@ -70,28 +71,32 @@ class WorkerPoller:
             worker_id: Unique identifier for this worker
             executor: Async function to execute tasks (typically MemoryEngine.execute_task)
             poll_interval_ms: Interval between polls when no tasks found (milliseconds)
-            batch_size: Maximum number of tasks to claim per poll cycle
             max_retries: Maximum retry attempts before marking task as failed
             schema: Database schema for single-tenant support (ignored if tenant_extension is set)
             tenant_extension: Extension for dynamic multi-tenant discovery. If set, list_tenants()
                             is called on each poll cycle to discover schemas dynamically.
+            max_slots: Maximum concurrent tasks per worker
+            consolidation_max_slots: Maximum concurrent consolidation tasks per worker
         """
         self._pool = pool
         self._worker_id = worker_id
         self._executor = executor
         self._poll_interval_ms = poll_interval_ms
-        self._batch_size = batch_size
         self._max_retries = max_retries
         self._schema = schema
         self._tenant_extension = tenant_extension
+        self._max_slots = max_slots
+        self._consolidation_max_slots = consolidation_max_slots
         self._shutdown = asyncio.Event()
         self._current_tasks: set[asyncio.Task] = set()
         self._in_flight_count = 0
         self._in_flight_lock = asyncio.Lock()
         self._last_progress_log = 0.0
         self._tasks_completed_since_log = 0
-        # Track active tasks locally: operation_id -> (op_type, bank_id, schema)
-        self._active_tasks: dict[str, tuple[str, str, str | None]] = {}
+        # Track active tasks locally: operation_id -> (op_type, bank_id, schema, asyncio.Task)
+        self._active_tasks: dict[str, tuple[str, str, str | None, asyncio.Task]] = {}
+        # Track in-flight tasks by operation type
+        self._in_flight_by_type: dict[str, int] = {}
 
     async def _get_schemas(self) -> list[str | None]:
         """Get list of schemas to poll. Returns [None] for public schema."""
@@ -102,59 +107,114 @@ class WorkerPoller:
         # Single schema mode
         return [self._schema]
 
-    async def claim_batch(self) -> list[ClaimedTask]:
+    async def _get_available_slots(self) -> tuple[int, int]:
         """
-        Claim up to batch_size pending tasks atomically across all tenant schemas.
+        Calculate available slots for claiming tasks.
 
-        Uses FOR UPDATE SKIP LOCKED to ensure no conflicts with other workers.
+        Returns:
+            (total_available, consolidation_available) tuple
+        """
+        async with self._in_flight_lock:
+            total_in_flight = self._in_flight_count
+            consolidation_in_flight = self._in_flight_by_type.get("consolidation", 0)
 
-        For consolidation tasks specifically, skips pending tasks if there's already
-        a processing consolidation for the same bank (to avoid duplicate work).
+        total_available = max(0, self._max_slots - total_in_flight)
+        consolidation_available = max(0, self._consolidation_max_slots - consolidation_in_flight)
 
-        If tenant_extension is configured, dynamically discovers schemas on each call.
+        return total_available, consolidation_available
+
+    async def wait_for_active_tasks(self, timeout: float = 10.0) -> bool:
+        """
+        Wait for all active background tasks to complete (test helper).
+
+        This is a test-only utility that allows tests to synchronize with
+        fire-and-forget background tasks without using sleep().
+
+        Args:
+            timeout: Maximum time to wait in seconds
+
+        Returns:
+            True if all tasks completed, False if timeout was reached
+        """
+        start_time = asyncio.get_event_loop().time()
+        while True:
+            async with self._in_flight_lock:
+                if self._in_flight_count == 0:
+                    return True
+
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed >= timeout:
+                return False
+
+            # Short sleep to avoid busy-waiting
+            await asyncio.sleep(0.01)
+
+    async def claim_batch(self) -> list[ClaimedTask]:
+        """
+        Claim pending tasks atomically across all tenant schemas,
+        respecting slot limits (total and consolidation).
+
+        Uses FOR UPDATE SKIP LOCKED to ensure no conflicts with other workers.
 
         Returns:
             List of ClaimedTask objects containing operation_id, task_dict, and schema
         """
+        # Calculate available slots
+        total_available, consolidation_available = await self._get_available_slots()
+
+        if total_available <= 0:
+            return []
+
         schemas = await self._get_schemas()
         all_tasks: list[ClaimedTask] = []
-        remaining_batch = self._batch_size
+        remaining_total = total_available
+        remaining_consolidation = consolidation_available
 
         for schema in schemas:
-            if remaining_batch <= 0:
+            if remaining_total <= 0:
                 break
 
-            tasks = await self._claim_batch_for_schema(schema, remaining_batch)
+            tasks = await self._claim_batch_for_schema(schema, remaining_total, remaining_consolidation)
+
+            # Update remaining slots based on what was claimed
+            for task in tasks:
+                op_type = task.task_dict.get("operation_type", "unknown")
+                if op_type == "consolidation":
+                    remaining_consolidation -= 1
+
             all_tasks.extend(tasks)
-            remaining_batch -= len(tasks)
+            remaining_total -= len(tasks)
 
         return all_tasks
 
-    async def _claim_batch_for_schema(self, schema: str | None, limit: int) -> list[ClaimedTask]:
-        """Claim tasks from a specific schema."""
+    async def _claim_batch_for_schema(
+        self, schema: str | None, limit: int, consolidation_limit: int
+    ) -> list[ClaimedTask]:
+        """Claim tasks from a specific schema respecting slot limits."""
+        try:
+            return await self._claim_batch_for_schema_inner(schema, limit, consolidation_limit)
+        except Exception as e:
+            logger.warning(f"Worker {self._worker_id} failed to claim tasks for schema {schema or 'public'}: {e}")
+            return []
+
+    async def _claim_batch_for_schema_inner(
+        self, schema: str | None, limit: int, consolidation_limit: int
+    ) -> list[ClaimedTask]:
+        """Inner implementation for claiming tasks from a specific schema with slot limits."""
         table = fq_table("async_operations", schema)
 
         async with self._pool.acquire() as conn:
             async with conn.transaction():
-                # Select and lock pending tasks
-                # For consolidation: skip if same bank already has one processing
-                rows = await conn.fetch(
+                # Strategy: Claim non-consolidation tasks first, then consolidation up to limit
+
+                # 1. Claim non-consolidation tasks (up to limit)
+                non_consolidation_rows = await conn.fetch(
                     f"""
                     SELECT operation_id, task_payload
-                    FROM {table} AS pending
-                    WHERE status = 'pending' AND task_payload IS NOT NULL
-                    AND (
-                        -- Non-consolidation tasks: always claimable
-                        operation_type != 'consolidation'
-                        OR
-                        -- Consolidation: only if no other consolidation processing for same bank
-                        NOT EXISTS (
-                            SELECT 1 FROM {table} AS processing
-                            WHERE processing.bank_id = pending.bank_id
-                            AND processing.operation_type = 'consolidation'
-                            AND processing.status = 'processing'
-                        )
-                    )
+                    FROM {table}
+                    WHERE status = 'pending'
+                      AND task_payload IS NOT NULL
+                      AND operation_type != 'consolidation'
                     ORDER BY created_at
                     LIMIT $1
                     FOR UPDATE SKIP LOCKED
@@ -162,11 +222,39 @@ class WorkerPoller:
                     limit,
                 )
 
-                if not rows:
+                claimed_count = len(non_consolidation_rows)
+                remaining_limit = limit - claimed_count
+
+                # 2. Claim consolidation tasks (up to consolidation_limit and remaining_limit)
+                consolidation_rows = []
+                if consolidation_limit > 0 and remaining_limit > 0:
+                    consolidation_rows = await conn.fetch(
+                        f"""
+                        SELECT operation_id, task_payload
+                        FROM {table} AS pending
+                        WHERE status = 'pending'
+                          AND task_payload IS NOT NULL
+                          AND operation_type = 'consolidation'
+                          AND NOT EXISTS (
+                              SELECT 1 FROM {table} AS processing
+                              WHERE processing.bank_id = pending.bank_id
+                                AND processing.operation_type = 'consolidation'
+                                AND processing.status = 'processing'
+                          )
+                        ORDER BY created_at
+                        LIMIT $1
+                        FOR UPDATE SKIP LOCKED
+                        """,
+                        min(consolidation_limit, remaining_limit),
+                    )
+
+                all_rows = non_consolidation_rows + consolidation_rows
+
+                if not all_rows:
                     return []
 
                 # Claim the tasks by updating status and worker_id
-                operation_ids = [row["operation_id"] for row in rows]
+                operation_ids = [row["operation_id"] for row in all_rows]
                 await conn.execute(
                     f"""
                     UPDATE {table}
@@ -184,7 +272,7 @@ class WorkerPoller:
                         task_dict=json.loads(row["task_payload"]),
                         schema=schema,
                     )
-                    for row in rows
+                    for row in all_rows
                 ]
 
     async def _mark_completed(self, operation_id: str, schema: str | None):
@@ -250,18 +338,43 @@ class WorkerPoller:
             logger.warning(f"Task {operation_id} failed, will retry (attempt {retry_count + 1}/{self._max_retries})")
 
     async def execute_task(self, task: ClaimedTask):
-        """Execute a single task and update its status."""
+        """Execute a single task as a background job (fire-and-forget)."""
         task_type = task.task_dict.get("type", "unknown")
+        operation_type = task.task_dict.get("operation_type", "unknown")
         bank_id = task.task_dict.get("bank_id", "unknown")
 
+        # Create background task
+        bg_task = asyncio.create_task(self._execute_task_inner(task))
+
         # Track this task as active
         async with self._in_flight_lock:
-            self._active_tasks[task.operation_id] = (task_type, bank_id, task.schema)
+            self._active_tasks[task.operation_id] = (task_type, bank_id, task.schema, bg_task)
+            self._in_flight_count += 1
+            self._in_flight_by_type[operation_type] = self._in_flight_by_type.get(operation_type, 0) + 1
+
+        # Add cleanup callback
+        bg_task.add_done_callback(lambda _: asyncio.create_task(self._cleanup_task(task.operation_id, operation_type)))
+
+    async def _cleanup_task(self, operation_id: str, operation_type: str):
+        """Remove task from tracking after completion."""
+        async with self._in_flight_lock:
+            if operation_id in self._active_tasks:
+                self._active_tasks.pop(operation_id, None)
+                self._in_flight_count -= 1
+                count = self._in_flight_by_type.get(operation_type, 0)
+                if count > 0:
+                    self._in_flight_by_type[operation_type] = count - 1
+                    if self._in_flight_by_type[operation_type] == 0:
+                        del self._in_flight_by_type[operation_type]
+
+    async def _execute_task_inner(self, task: ClaimedTask):
+        """Inner task execution with error handling."""
+        task_type = task.task_dict.get("type", "unknown")
+        bank_id = task.task_dict.get("bank_id", "unknown")
 
         try:
             schema_info = f", schema={task.schema}" if task.schema else ""
             logger.debug(f"Executing task {task.operation_id} (type={task_type}, bank={bank_id}{schema_info})")
-            # Pass schema to executor so it can set the correct context
             if task.schema:
                 task.task_dict["_schema"] = task.schema
             await self._executor(task.task_dict)
@@ -271,10 +384,6 @@ class WorkerPoller:
             error_msg = f"{type(e).__name__}: {e}\n{traceback.format_exc()}"
             logger.error(f"Task {task.operation_id} failed: {e}")
             await self._retry_or_fail(task.operation_id, error_msg, task.schema)
-        finally:
-            # Remove from active tasks
-            async with self._in_flight_lock:
-                self._active_tasks.pop(task.operation_id, None)
 
     async def recover_own_tasks(self) -> int:
         """
@@ -293,20 +402,23 @@ class WorkerPoller:
         total_count = 0
 
         for schema in schemas:
-            table = fq_table("async_operations", schema)
+            try:
+                table = fq_table("async_operations", schema)
 
-            result = await self._pool.execute(
-                f"""
-                UPDATE {table}
-                SET status = 'pending', worker_id = NULL, claimed_at = NULL, updated_at = now()
-                WHERE status = 'processing' AND worker_id = $1
-                """,
-                self._worker_id,
-            )
+                result = await self._pool.execute(
+                    f"""
+                    UPDATE {table}
+                    SET status = 'pending', worker_id = NULL, claimed_at = NULL, updated_at = now()
+                    WHERE status = 'processing' AND worker_id = $1
+                    """,
+                    self._worker_id,
+                )
 
-            # Parse "UPDATE N" to get count
-            count = int(result.split()[-1]) if result else 0
-            total_count += count
+                # Parse "UPDATE N" to get count
+                count = int(result.split()[-1]) if result else 0
+                total_count += count
+            except Exception as e:
+                logger.warning(f"Worker {self._worker_id} failed to recover tasks for schema {schema or 'public'}: {e}")
 
         if total_count > 0:
             logger.info(f"Worker {self._worker_id} recovered {total_count} stale tasks from previous run")
@@ -314,59 +426,59 @@ class WorkerPoller:
 
     async def run(self):
         """
-        Main polling loop.
-
-        Continuously polls for pending tasks, claims them, and executes them
-        until shutdown is signaled.
+        Main polling loop with fire-and-forget task execution.
 
-        If tenant_extension is configured, dynamically discovers schemas on each poll.
+        Continuously polls for pending tasks, spawns them as background tasks,
+        and immediately continues polling (up to slot limits).
         """
-        # Recover any tasks from a previous crash before starting
         await self.recover_own_tasks()
 
-        logger.info(f"Worker {self._worker_id} starting polling loop")
+        logger.info(
+            f"Worker {self._worker_id} starting polling loop "
+            f"(max_slots={self._max_slots}, consolidation_max_slots={self._consolidation_max_slots})"
+        )
 
         while not self._shutdown.is_set():
             try:
-                # Claim a batch of tasks (across all tenant schemas if configured)
+                # Claim a batch of tasks (respecting slot limits)
                 tasks = await self.claim_batch()
 
                 if tasks:
                     # Log batch info
                     task_types: dict[str, int] = {}
                     schemas_seen: set[str | None] = set()
+                    consolidation_count = 0
                     for task in tasks:
                         t = task.task_dict.get("type", "unknown")
+                        op_type = task.task_dict.get("operation_type", "unknown")
                         task_types[t] = task_types.get(t, 0) + 1
                         schemas_seen.add(task.schema)
+                        if op_type == "consolidation":
+                            consolidation_count += 1
+
                     types_str = ", ".join(f"{k}:{v}" for k, v in task_types.items())
                     schemas_str = ", ".join(s or "public" for s in schemas_seen)
                     logger.info(
-                        f"Worker {self._worker_id} claimed {len(tasks)} tasks: {types_str} (schemas: {schemas_str})"
+                        f"Worker {self._worker_id} claimed {len(tasks)} tasks "
+                        f"({consolidation_count} consolidation): {types_str} (schemas: {schemas_str})"
                     )
 
-                    # Track in-flight tasks
-                    async with self._in_flight_lock:
-                        self._in_flight_count += len(tasks)
-
-                    # Execute tasks concurrently
-                    try:
-                        await asyncio.gather(
-                            *[self.execute_task(task) for task in tasks],
-                            return_exceptions=True,
-                        )
-                    finally:
-                        async with self._in_flight_lock:
-                            self._in_flight_count -= len(tasks)
-                else:
-                    # No tasks found, wait before polling again
-                    try:
-                        await asyncio.wait_for(
-                            self._shutdown.wait(),
-                            timeout=self._poll_interval_ms / 1000,
-                        )
-                    except asyncio.TimeoutError:
-                        pass  # Normal timeout, continue polling
+                    # Spawn tasks as background jobs (fire-and-forget)
+                    for task in tasks:
+                        await self.execute_task(task)
+
+                    # Continue immediately to claim more tasks (if slots available)
+                    continue
+
+                # No tasks claimed (either no pending tasks or slots full)
+                # Wait before polling again
+                try:
+                    await asyncio.wait_for(
+                        self._shutdown.wait(),
+                        timeout=self._poll_interval_ms / 1000,
+                    )
+                except asyncio.TimeoutError:
+                    pass  # Normal timeout, continue polling
 
                 # Log progress stats periodically
                 await self._log_progress_if_due()
@@ -397,15 +509,27 @@ class WorkerPoller:
         while asyncio.get_event_loop().time() - start_time < timeout:
             async with self._in_flight_lock:
                 in_flight = self._in_flight_count
+                active_task_objects = [task_info[3] for task_info in self._active_tasks.values()]
 
             if in_flight == 0:
                 logger.info(f"Worker {self._worker_id} graceful shutdown complete")
                 return
 
             logger.info(f"Worker {self._worker_id} waiting for {in_flight} in-flight tasks")
-            await asyncio.sleep(0.5)
 
-        logger.warning(f"Worker {self._worker_id} shutdown timeout after {timeout}s")
+            # Wait for at least one task to complete
+            if active_task_objects:
+                done, _ = await asyncio.wait(active_task_objects, timeout=0.5, return_when=asyncio.FIRST_COMPLETED)
+            else:
+                await asyncio.sleep(0.5)
+
+        logger.warning(f"Worker {self._worker_id} shutdown timeout after {timeout}s, cancelling remaining tasks")
+
+        # Cancel remaining tasks
+        async with self._in_flight_lock:
+            for operation_id, (_, _, _, bg_task) in list(self._active_tasks.items()):
+                if not bg_task.done():
+                    bg_task.cancel()
 
     async def _log_progress_if_due(self):
         """Log progress stats every PROGRESS_LOG_INTERVAL seconds."""
@@ -416,14 +540,19 @@ class WorkerPoller:
         self._last_progress_log = now
 
         try:
-            # Get local active tasks (this worker only)
+            # Get local active tasks
             async with self._in_flight_lock:
                 in_flight = self._in_flight_count
-                active_tasks = dict(self._active_tasks)  # Copy to avoid holding lock
+                in_flight_by_type = dict(self._in_flight_by_type)
+                active_tasks = dict(self._active_tasks)
+
+            consolidation_count = in_flight_by_type.get("consolidation", 0)
+            available_slots = self._max_slots - in_flight
+            available_consolidation_slots = self._consolidation_max_slots - consolidation_count
 
-            # Build local processing breakdown grouped by (op_type, bank_id)
+            # Build local processing breakdown
             task_groups: dict[tuple[str, str], int] = {}
-            for op_type, bank_id, _ in active_tasks.values():
+            for op_type, bank_id, _, _ in active_tasks.values():
                 key = (op_type, bank_id)
                 task_groups[key] = task_groups.get(key, 0) + 1
 
@@ -432,7 +561,7 @@ class WorkerPoller:
             if len(processing_info) > 10:
                 processing_str += f" +{len(processing_info) - 10} more"
 
-            # Get global stats from DB across all schemas
+            # Get global stats from DB
             schemas = await self._get_schemas()
             global_pending = 0
             all_worker_counts: dict[str, int] = {}
@@ -444,7 +573,6 @@ class WorkerPoller:
                     row = await conn.fetchrow(f"SELECT COUNT(*) as count FROM {table} WHERE status = 'pending'")
                     global_pending += row["count"] if row else 0
 
-                    # Get processing breakdown by worker
                     worker_rows = await conn.fetch(
                         f"""
                         SELECT worker_id, COUNT(*) as count
@@ -457,7 +585,6 @@ class WorkerPoller:
                         wid = wr["worker_id"] or "unknown"
                         all_worker_counts[wid] = all_worker_counts.get(wid, 0) + wr["count"]
 
-            # Format other workers' processing counts
             other_workers = []
             for wid, cnt in all_worker_counts.items():
                 if wid != self._worker_id:
@@ -466,7 +593,9 @@ class WorkerPoller:
 
             schemas_str = ", ".join(s or "public" for s in schemas)
             logger.info(
-                f"[WORKER_STATS] worker={self._worker_id} in_flight={in_flight} | "
+                f"[WORKER_STATS] worker={self._worker_id} "
+                f"slots={in_flight}/{self._max_slots} (consolidation={consolidation_count}/{self._consolidation_max_slots}) | "
+                f"available={available_slots} (consolidation={available_consolidation_slots}) | "
                 f"global: pending={global_pending} (schemas: {schemas_str}) | "
                 f"others: {others_str} | "
                 f"my_active: {processing_str}"

{hindsight_api-0.4.2.dist-info → hindsight_api-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hindsight-api
-Version: 0.4.2
+Version: 0.4.4
 Summary: Hindsight: Agent Memory That Works Like Human Memory
 Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.13.3
@@ -14,6 +14,7 @@ Requires-Dist: fastapi[standard]>=0.120.3
 Requires-Dist: fastmcp>=2.14.0
 Requires-Dist: filelock>=3.20.1
 Requires-Dist: flashrank>=0.2.0
+Requires-Dist: google-auth>=2.0.0
 Requires-Dist: google-genai>=1.0.0
 Requires-Dist: greenlet>=3.2.4
 Requires-Dist: httpx>=0.27.0

{hindsight_api-0.4.2.dist-info → hindsight_api-0.4.4.dist-info}/RECORD

@@ -1,14 +1,14 @@
-hindsight_api/__init__.py,sha256=SkMHa_uH21mNyfFm0-90uFJhMK45y1dJtD54LbxbXGU,1197
+hindsight_api/__init__.py,sha256=RoPZUUBQY9G4ThNGetuvEqf2rgEdMGlcm_ythXpBYQ4,1197
 hindsight_api/banner.py,sha256=BXn-jhkXe4xi-YV4JeuaVvjYhTMs96O43XoOMv4Cd28,4591
-hindsight_api/config.py,sha256=rD-00bhB0k9wz4q7TKTVd9bEuqFmzNQ_PpUtZ9Gn94Q,31526
+hindsight_api/config.py,sha256=mLUMuQrhZCbUd___6Wqdc-OcMXtZ_CZZmxM4b7vO7CE,32506
 hindsight_api/daemon.py,sha256=yqMtalX0tlNz7KUpMjsRpC0r8T0WwHGvVKPxuO_Ye40,6111
-hindsight_api/main.py,sha256=aqMjsUVbB3D910kkgMPnAIt8HOTDNb9CPdNdrl1-yIc,15074
+hindsight_api/main.py,sha256=-nVh2KrW-Y9y7Punv-1qUz7q4M4IY2vDHBiyAC-Igpk,15243
 hindsight_api/mcp_local.py,sha256=fJnCxMBc79GlBZrma94Ux6g-GVuh-W66194cqQdkKJQ,5613
-hindsight_api/mcp_tools.py,sha256=KGzgDeRoChwgt3HB-OoUHcWgHz6ELequLIkw6u7kkyo,19669
-hindsight_api/metrics.py,sha256=go3X7wyFAPkc55HFvu7esiaJXDrUsrSrC8Pq5NjcqU0,20692
+hindsight_api/mcp_tools.py,sha256=cLQ9Bdu8FoL2DscO_Z1pAGpNiCeFY2PHBvIPLZXkwE8,20493
+hindsight_api/metrics.py,sha256=zgOh_UFTT8ZtqnLaZuyErRtoPZ9SGP3mbmiHT3wX3v4,20677
 hindsight_api/migrations.py,sha256=V4QL_N1cMe6kNF1ejJ3lPIPFXKU2Pzbaiviws7AyMIY,14624
 hindsight_api/models.py,sha256=SzJ8uM2nGr3D6X-UEfE8VIT-PbS9J4DmRT_4lv5n9T8,12831
-hindsight_api/pg0.py,sha256=XORoiemECidQgBP53EBSCF3i0PJegLRRWKl2hU5UPhE,6390
+hindsight_api/pg0.py,sha256=Ntj3FYPLfmQTskG4gHoz_NTlQ4A3DqCm2PbbXm-ivGQ,6337
 hindsight_api/server.py,sha256=MU2ZvKe3KWfxKYZq8EEJPgKMmq5diPkRqfQBaz-yOQI,2483
 hindsight_api/admin/__init__.py,sha256=RvaczuwTxg6ajc_Jlk0EhVz5JqlNB3T8su060gRQwfs,26
 hindsight_api/admin/cli.py,sha256=A1qkZ_9GWjz1qOIQYnmj-qUN005cIIlpFsvYH7tZdyc,11607
@@ -39,23 +39,23 @@ hindsight_api/alembic/versions/t5o6p7q8r9s0_rename_mental_models_to_observations
 hindsight_api/alembic/versions/u6p7q8r9s0t1_mental_models_text_id.py,sha256=uvil81f-4ag2dIxBXUGKZ5vxkqdNQRpxCWj_iVih09w,1355
 hindsight_api/alembic/versions/v7q8r9s0t1u2_add_max_tokens_to_mental_models.py,sha256=Mw68uW8PK-SaHcYcqb41vWI0R22t70SSasNS2Myeoec,1656
 hindsight_api/api/__init__.py,sha256=npF0AAy8WJhHF5a9ehkNn9_iYLk7RQOk2gdkdFb49Hk,3840
-hindsight_api/api/http.py,sha256=5YFLGWDILApMf4lLxpc72S9EtnOIOvuu8c3K124THPc,133363
-hindsight_api/api/mcp.py,sha256=zV0TmkxKEqwhLIfNAdezYgsZ1PF9Lo8j5_lD73ULpKU,6707
+hindsight_api/api/http.py,sha256=uWQ2P5GiC8tBK1-lbwYxfZgon9tpVgIvLJyp9SeK2Y4,132812
+hindsight_api/api/mcp.py,sha256=4ZxeEa_LHcyFRf1jK60hr4JDLXObOQdnpc3bTLJCdVI,8647
 hindsight_api/engine/__init__.py,sha256=-BwaSwG9fTT_BBO0c_2MBkxG6-tGdclSzIqsgHw4cnw,1633
-hindsight_api/engine/cross_encoder.py,sha256=ecfpFB5zxDxQD6rqVzVE6L3XWb69pcvHKJCFVSFc94c,32365
+hindsight_api/engine/cross_encoder.py,sha256=Q1s-C-JOOJ246Twl1FyYbeXAJnfdXnfhcDpntScYFvQ,32301
 hindsight_api/engine/db_budget.py,sha256=1OmZiuszpuEaYz355QlOqwaupXPd9FrnbyENsFboBkg,8642
 hindsight_api/engine/db_utils.py,sha256=Fq1pXETt8ZPhkWYjrcGbgL6glrwmCGWh3_lYJgHqQPo,3067
-hindsight_api/engine/embeddings.py,sha256=SjX00-D-8PzsmgJaq17mtxkNqXt0q-UVl7JYKnXv2Es,27012
+hindsight_api/engine/embeddings.py,sha256=KvK65y89E4Hxz8gvQR4G6qSGNlGoai6NBIaWdMzoV_A,27054
 hindsight_api/engine/entity_resolver.py,sha256=qVvWJHnbGEfh0iUFtc1dbM3IUNwPMsQsmg2rMgiX2DY,23794
-hindsight_api/engine/interface.py,sha256=rldxkBmp_bqEeTBD713uZeXvrqJB9Ix1L62gazlNEi0,16899
-hindsight_api/engine/llm_wrapper.py,sha256=Mh38zSlNGhsbN0f2VA1JGZ52HRab_ndcKqvEhyajgK0,68084
-hindsight_api/engine/memory_engine.py,sha256=lYWrQYzHib0UPiGNFxe_5QXxkJv14DjiG93SZ1sHo7c,231906
+hindsight_api/engine/interface.py,sha256=wpJUIN-64RFJ_iYNtYWlyR4L-mDO2xijXUFqLD4tkeg,15821
+hindsight_api/engine/llm_wrapper.py,sha256=q0d01bdYCVcW9lwJVNxhw3hAp1Qr4YSwU3vXqM3K80Y,71399
+hindsight_api/engine/memory_engine.py,sha256=NpMG8XwTODJogpumWg1RxajUOFoXv7LJkTcjvP9NNV0,227563
 hindsight_api/engine/query_analyzer.py,sha256=7APe0MjBcUxjivcMlM03PmMk_w5FjWvlEe20yAJlHlc,19741
-hindsight_api/engine/response_models.py,sha256=1fNAFPztlmYfOaoRfwYyrhzdPBO9UL8QHFNXW6Lmjgg,16322
-hindsight_api/engine/task_backend.py,sha256=zDH24tTwIH_59eFpQzepv0KkZXOIVMpmDkrg1Y5khDA,8172
-hindsight_api/engine/utils.py,sha256=OtEFDViKcCpFmKN3Qir8YV4zp0kv7iaREcgDXCkwShw,2089
+hindsight_api/engine/response_models.py,sha256=ZPP80NmEP205erz5qEE8IJ9-c622UHqYo17e5UOiXAE,15578
+hindsight_api/engine/task_backend.py,sha256=FFZnjUsjXrrZwww16ow--J61QIpUFwxLdcmeF1NPoYk,8500
+hindsight_api/engine/utils.py,sha256=k6RcLtwe9XAKDTQRIfgR2zKEdjDLlf72vVeepyK20us,1898
 hindsight_api/engine/consolidation/__init__.py,sha256=qEUPy0R7akNoAooQL1TAt2rVasjvnXTcNzh2zpN0flc,160
-hindsight_api/engine/consolidation/consolidator.py,sha256=c8dHmGGG2XhHYXjXGpSn_dBs_8IwdvZnQx9EWMwzxdc,34471
+hindsight_api/engine/consolidation/consolidator.py,sha256=bP-lPLD1WAo0fgzsRTHhKhJJDXFkRg4vWcVFL_vr-ao,34828
 hindsight_api/engine/consolidation/prompts.py,sha256=UgJJvXeG7bH0h-N0AWlUsmWoYxfJY2gIP_3f9xjCvSc,3422
 hindsight_api/engine/directives/__init__.py,sha256=5ZxaRqZVyJckbGElaI2DMRMBtnj-qYkxRKdnOHBwovA,118
 hindsight_api/engine/directives/models.py,sha256=PKxvmhW1-fjBITAOBu7RKX5Lj61c2jdsTaX8ADelKag,1523
@@ -75,11 +75,11 @@ hindsight_api/engine/retain/deduplication.py,sha256=kqs7I7eIc_ppvgAF9GlzL6fSGuEE
 hindsight_api/engine/retain/embedding_processing.py,sha256=R35oyKYIKjuqC-yZl5Ru56F8xRe0N6KW_9p5PZ9CBi0,1649
 hindsight_api/engine/retain/embedding_utils.py,sha256=uulXIBiA7XNsj16K1VGawR3s5jV-hsAmvmoCi-IodpU,1565
 hindsight_api/engine/retain/entity_processing.py,sha256=0x5b48Im7pWjeqg3xTMIRVhrzd4otc4rSkFBjxgOL9Y,3632
-hindsight_api/engine/retain/fact_extraction.py,sha256=NuuKC0GrCoSjDx0J5p2ejw0UQKXke9io-_kBLoclOac,63943
+hindsight_api/engine/retain/fact_extraction.py,sha256=Im6UAFH5X6DBZqWT68Uf41psOmNP602kPdvBatPIdzI,62763
 hindsight_api/engine/retain/fact_storage.py,sha256=PUdMfNWaGuDA-DodeT3hs8ft81ldzXZedCMXys-sFf4,6690
 hindsight_api/engine/retain/link_creation.py,sha256=KP2kGU2VCymJptgw0hjaSdsjvncBgNp3P_A4OB_qx-w,3082
 hindsight_api/engine/retain/link_utils.py,sha256=eKa9Ecf7Mpqjl4laAEtRilQgu4fbsGWAjg98kdMDsDc,33078
-hindsight_api/engine/retain/orchestrator.py,sha256=URQm9oXFWhLTmQjHlolnyWjcFDusEitn5UVbIvVdcXQ,20480
+hindsight_api/engine/retain/orchestrator.py,sha256=QmuTGj3pLmQe4IROZFbxcHih40oft0u8xLInAeUGI0g,20393
 hindsight_api/engine/retain/types.py,sha256=zNkjqUA6oUAFe9a5SEbZfQC5PSmpYqTyBfgdmyqPpnw,7722
 hindsight_api/engine/search/__init__.py,sha256=YPz_4g7IOabx078Xwg3RBfbOpJ649NRwNfe0gTI9P1U,802
 hindsight_api/engine/search/fusion.py,sha256=cY81BH9U5RyWrPXbQnrDBghtelDMckZWCke9aqMyNnQ,4220
@@ -104,9 +104,9 @@ hindsight_api/extensions/tenant.py,sha256=0LraksQ1gzsOYLEGrx2q2F0or596Ywfo_MqD1F
 hindsight_api/extensions/builtin/__init__.py,sha256=hLx2oFYZ1JtZhTWfab6AYcR02SWP2gIdbEqnZezT8ek,526
 hindsight_api/extensions/builtin/tenant.py,sha256=R7jfNR41deGWqQB5P8Qk5njy1bZgvemcTpkXDRiAZBA,1835
 hindsight_api/worker/__init__.py,sha256=hzpMLvOfgL2KKrrik_9ouvEzCdvJSrH-pj5UdFK63J0,256
-hindsight_api/worker/main.py,sha256=1OrQdHL-6u-311W0XMAoLHOXCu8MOETiQkR0TQ23qh8,9547
-hindsight_api/worker/poller.py,sha256=l-y8xpekKZ7zcGo83osOsbFd_tBi49LqrAJsN-mxiMY,19306
-hindsight_api-0.4.2.dist-info/METADATA,sha256=FNkrW-Qzm3SeAeKVkhV2UAR6yEz6OI0drI7M-aKm_g8,5760
-hindsight_api-0.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hindsight_api-0.4.2.dist-info/entry_points.txt,sha256=1-mxPbRGL_Byf9ZrHYkPW-TEgLYFcwCiSFCxOgI_3vM,206
-hindsight_api-0.4.2.dist-info/RECORD,,
+hindsight_api/worker/main.py,sha256=eE6AmFErNJKGBrLivwceAMo5n73y_e6EUwjQoGo-lhE,9757
+hindsight_api/worker/poller.py,sha256=2jyl5bJPEwgr6T6xgEvdHPGqtXvOIs28v4v38a26sRo,25122
+hindsight_api-0.4.4.dist-info/METADATA,sha256=dX_nPi0cPqnB1mXj95OM9LHD1d7P04SBbYVDz6VM_qU,5794
+hindsight_api-0.4.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_api-0.4.4.dist-info/entry_points.txt,sha256=1-mxPbRGL_Byf9ZrHYkPW-TEgLYFcwCiSFCxOgI_3vM,206
+hindsight_api-0.4.4.dist-info/RECORD,,