iatoolkit 2.67.0__tar.gz → 2.68.0__tar.gz

{iatoolkit-2.67.0/src/iatoolkit.egg-info → iatoolkit-2.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.67.0
+Version: 2.68.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.67.0"
+__version__ = "2.68.0"
 
 # Expose main classes and functions at the top level of the package
 

iatoolkit-2.68.0/src/iatoolkit/common/memory_tools.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""What "used the Memoria" means, in one place (Fase 2 of the Memoria architecture review).
+
+Before, five modules each kept their own list of Memoria tools, so the hourly
+question review, Impacto and the prompts counted different things.
+"""
+
+# Looking for knowledge: a page search or a document search.
+SEARCH_TOOLS = frozenset({"iat_memory_search", "iat_document_search"})
+# Reading what a search found.
+READ_TOOLS = frozenset({"iat_memory_get_page", "iat_document_read", "iat_document_list"})
+# Every tool whose use is a use of the company's knowledge (usage events, Impacto).
+KNOWLEDGE_TOOLS = SEARCH_TOOLS | READ_TOOLS
+
+PAGE_SEARCH_TOOL = "iat_memory_search"
+PAGE_READ_TOOL = "iat_memory_get_page"
+DOCUMENT_SEARCH_TOOL = "iat_document_search"
+DOCUMENT_READ_TOOL = "iat_document_read"
+
+CHANNEL_CHAT = "chat"
+CHANNEL_MCP = "mcp"

iatoolkit-2.68.0/src/iatoolkit/repositories/advisory_lock.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""One Postgres advisory lock helper for everything that runs once per key across workers.
+
+A Postgres advisory lock belongs to the *database connection* that took it. An
+ORM session hands its connection back to the pool on every commit, so a lock
+taken through the session can end up held by a pooled connection nobody owns,
+and released (or not) through another one. This helper always takes and
+releases the lock on its own dedicated connection, for exactly the `with` block.
+
+On SQLite (tests) there is no advisory lock: the block runs as if it held it.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+from sqlalchemy import text
+
+
+@contextmanager
+def advisory_lock(db_manager, namespace: int, key: int, *, wait: bool = True):
+    """
+    Holds the two-key advisory lock (namespace, key) for the block and yields
+    whether it is held: always True when `wait` (it blocks until it gets it);
+    with `wait=False`, False when someone else holds it (the block should skip).
+    """
+    if db_manager.get_dialect() not in ("postgresql", "postgres"):
+        yield True
+        return
+    params = {"namespace": int(namespace), "key": int(key)}
+    connection = db_manager.get_connection()
+    try:
+        if wait:
+            connection.execute(text("SELECT pg_advisory_lock(:namespace, :key)"), params)
+            held = True
+        else:
+            held = bool(connection.execute(text("SELECT pg_try_advisory_lock(:namespace, :key)"), params).scalar())
+        try:
+            yield held
+        finally:
+            if held:
+                connection.execute(text("SELECT pg_advisory_unlock(:namespace, :key)"), params)
+    finally:
+        connection.close()

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/repositories/knowledge_wiki_repo.py

@@ -5,15 +5,17 @@
 
 from __future__ import annotations
 
+import hashlib
 from datetime import datetime
 
 from injector import inject
-from sqlalchemy import or_
+from sqlalchemy import or_, text
 
 from iatoolkit.repositories.database_manager import DatabaseManager
 from iatoolkit.repositories.models import (
     KnowledgeWiki,
     KnowledgeWikiPage,
+    KnowledgeWikiPageIndex,
     KnowledgeWikiPageRevision,
     KnowledgeWikiPageStatus,
     KnowledgeWikiStatus,
@@ -117,6 +119,16 @@ class KnowledgeWikiRepo:
             .first()
         )
 
+    def get_pages_by_ids(self, wiki_ids: list[int], page_ids: list[int]) -> dict[int, KnowledgeWikiPage]:
+        if not wiki_ids or not page_ids:
+            return {}
+        pages = (
+            self.session.query(KnowledgeWikiPage)
+            .filter(KnowledgeWikiPage.wiki_id.in_(list(wiki_ids)), KnowledgeWikiPage.id.in_(list(page_ids)))
+            .all()
+        )
+        return {page.id: page for page in pages}
+
     def get_page_by_slug(self, wiki_id: int, slug: str) -> KnowledgeWikiPage | None:
         if not wiki_id or not slug:
             return None
@@ -203,21 +215,143 @@ class KnowledgeWikiRepo:
             )
             self.session.add(page)
         self.session.commit()
+        self.index_page(page)
         return page
 
     def save_page(self, page: KnowledgeWikiPage) -> KnowledgeWikiPage:
         self.session.add(page)
         self.session.commit()
+        self.index_page(page)
         return page
 
     def delete_page(self, wiki_id: int, path: str) -> KnowledgeWikiPage | None:
         page = self.get_page_by_path(wiki_id, path)
         if page is None:
             return None
+        self.session.query(KnowledgeWikiPageIndex).filter(KnowledgeWikiPageIndex.page_id == page.id).delete()
         self.session.delete(page)
         self.session.commit()
         return page
 
+    # =====================================================================
+    # Search index (iat_knowledge_wiki_page_index)
+    # =====================================================================
+
+    # What the word branch searches; the meaning branch embeds the same text, cut.
+    INDEX_TEXT_CHARS = 60000
+
+    @classmethod
+    def page_search_text(cls, page: KnowledgeWikiPage) -> str:
+        parts = [page.title or "", page.summary or "", " ".join(str(t) for t in (page.tags or [])), page.body_text or ""]
+        return "\n".join(part.strip() for part in parts if str(part or "").strip())[:cls.INDEX_TEXT_CHARS]
+
+    def index_page(self, page: KnowledgeWikiPage) -> KnowledgeWikiPageIndex:
+        """Writes the page's search text; a changed text clears the embedding so it is computed again."""
+        search_text = self.page_search_text(page)
+        content_hash = hashlib.sha256(search_text.encode("utf-8")).hexdigest()
+        row = self.session.query(KnowledgeWikiPageIndex).filter(KnowledgeWikiPageIndex.page_id == page.id).first()
+        if row is None:
+            row = KnowledgeWikiPageIndex(page_id=page.id, wiki_id=page.wiki_id, company_id=page.company_id)
+            self.session.add(row)
+        elif row.content_hash == content_hash and row.wiki_id == page.wiki_id:
+            return row
+        row.wiki_id = page.wiki_id
+        row.search_text = search_text
+        row.content_hash = content_hash
+        if row.embedded_hash != content_hash:
+            row.embedding = None
+            row.embedded_hash = None
+        self.session.commit()
+        return row
+
+    def list_pages_to_embed(self, limit: int = 100, company_id: int | None = None) -> list[KnowledgeWikiPageIndex]:
+        query = (
+            self.session.query(KnowledgeWikiPageIndex)
+            .join(KnowledgeWikiPage, KnowledgeWikiPage.id == KnowledgeWikiPageIndex.page_id)
+            .filter(KnowledgeWikiPage.status != KnowledgeWikiPageStatus.ARCHIVED)
+            .filter(or_(KnowledgeWikiPageIndex.embedded_hash.is_(None),
+                        KnowledgeWikiPageIndex.embedded_hash != KnowledgeWikiPageIndex.content_hash))
+        )
+        if company_id:
+            query = query.filter(KnowledgeWikiPageIndex.company_id == company_id)
+        return query.order_by(KnowledgeWikiPageIndex.updated_at.asc()).limit(limit).all()
+
+    def list_unindexed_pages(self, limit: int = 500) -> list[KnowledgeWikiPage]:
+        """Pages written before the index existed (the backfill)."""
+        return (
+            self.session.query(KnowledgeWikiPage)
+            .outerjoin(KnowledgeWikiPageIndex, KnowledgeWikiPageIndex.page_id == KnowledgeWikiPage.id)
+            .filter(KnowledgeWikiPageIndex.id.is_(None))
+            .filter(KnowledgeWikiPage.status != KnowledgeWikiPageStatus.ARCHIVED)
+            .limit(limit)
+            .all()
+        )
+
+    def set_page_embedding(self, row: KnowledgeWikiPageIndex, embedding: list[float], embedded_hash: str) -> None:
+        row.embedding = embedding
+        row.embedded_hash = embedded_hash
+        self.session.commit()
+
+    def is_postgres(self) -> bool:
+        bind = self.session.get_bind()
+        return getattr(getattr(bind, "dialect", None), "name", "") == "postgresql"
+
+    RRF_K = 60
+
+    def hybrid_search_pages(self, wiki_ids: list[int], query_text: str, query_embedding: list[float] | None,
+                            candidates: int = 40) -> list[tuple[int, float]]:
+        """
+        (page_id, rrf_score) of the best pages of these wikis, best first: by
+        words (Postgres full text, 'simple', terms OR'ed, the GIN index) and, when
+        there is a query embedding, by meaning (pages whose embedding has its
+        size), fused by Reciprocal Rank Fusion. Archived pages are left out.
+        Postgres only.
+        """
+        if not wiki_ids:
+            return []
+        tsvector = "to_tsvector('simple'::regconfig, i.search_text)"
+        tsquery = "replace(plainto_tsquery('simple'::regconfig, :text_terms)::text, ' & ', ' | ')::tsquery"
+        params = {"wiki_ids": list(wiki_ids), "text_terms": query_text or "", "candidates": int(candidates),
+                  "archived": KnowledgeWikiPageStatus.ARCHIVED.name}
+        branches = [f"""
+                SELECT page_id, ROW_NUMBER() OVER (ORDER BY text_rank DESC, page_id ASC) AS rank
+                FROM (
+                    SELECT i.page_id, ts_rank_cd({tsvector}, terms.q) AS text_rank
+                    FROM iat_knowledge_wiki_page_index i
+                    JOIN iat_knowledge_wiki_pages p ON p.id = i.page_id,
+                         (SELECT {tsquery} AS q) terms
+                    WHERE i.wiki_id = ANY(:wiki_ids) AND p.status::text <> :archived
+                      AND {tsvector} @@ terms.q
+                    ORDER BY text_rank DESC
+                    LIMIT :candidates
+                ) words"""]
+        if query_embedding:
+            dims = len(query_embedding)
+            if 0 < dims <= 2000:
+                params["query_embedding"] = str(list(query_embedding))
+                branches.append(f"""
+                SELECT page_id, ROW_NUMBER() OVER (ORDER BY distance ASC, page_id ASC) AS rank
+                FROM (
+                    SELECT i.page_id,
+                           i.embedding::vector({dims}) <=> CAST(:query_embedding AS vector({dims})) AS distance
+                    FROM iat_knowledge_wiki_page_index i
+                    JOIN iat_knowledge_wiki_pages p ON p.id = i.page_id
+                    WHERE i.wiki_id = ANY(:wiki_ids) AND p.status::text <> :archived
+                      AND i.embedding IS NOT NULL AND vector_dims(i.embedding) = {dims}
+                    ORDER BY distance ASC
+                    LIMIT :candidates
+                ) meaning""")
+        union = " UNION ALL ".join(f"({branch})" for branch in branches)
+        sql = f"""
+            SELECT page_id, SUM(1.0 / ({self.RRF_K} + rank)) AS rrf_score
+            FROM ({union}) hits
+            GROUP BY page_id
+            ORDER BY rrf_score DESC, page_id ASC
+            LIMIT :candidates
+        """
+        rows = self.session.execute(text(sql), params).fetchall()
+        return [(int(row[0]), float(row[1])) for row in rows]
+
     def create_page_revision(
         self,
         *,

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/repositories/memory_question_repo.py

@@ -51,6 +51,29 @@ class MemoryQuestionRepo:
             .all()
         )
 
+    def claim_open(self, company_id: int, question_id: int, status: str, resolved_by: str, resolved_at) -> bool:
+        """Resolves the question only if it is still open, in one UPDATE: of two people answering at
+        once, exactly one wins (Fase 0, R17). Commits."""
+        claimed = (
+            self.session.query(MemoryQuestion)
+            .filter(MemoryQuestion.company_id == company_id, MemoryQuestion.id == question_id,
+                    MemoryQuestion.status == MemoryQuestion.STATUS_OPEN)
+            .update({MemoryQuestion.status: status, MemoryQuestion.resolved_by: resolved_by,
+                     MemoryQuestion.resolved_at: resolved_at}, synchronize_session=False)
+        )
+        self.commit()
+        return bool(claimed)
+
+    def reopen(self, company_id: int, question_id: int) -> None:
+        """Undoes a claim whose answer could not be saved."""
+        (
+            self.session.query(MemoryQuestion)
+            .filter(MemoryQuestion.company_id == company_id, MemoryQuestion.id == question_id)
+            .update({MemoryQuestion.status: MemoryQuestion.STATUS_OPEN, MemoryQuestion.resolved_by: None,
+                     MemoryQuestion.resolved_at: None}, synchronize_session=False)
+        )
+        self.commit()
+
     def get_question(self, company_id: int, question_id: int) -> MemoryQuestion | None:
         return (
             self.session.query(MemoryQuestion)

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/repositories/memory_repo.py

@@ -131,6 +131,19 @@ class MemoryRepo:
             .all()
         )
 
+    def list_failed_captures(self, company_id: int, failed_before, limit: int = 50) -> list[MemoryCapture]:
+        """Captures whose compilation failed before `failed_before`, oldest first (to retry them)."""
+        if not company_id:
+            return []
+        return (
+            self.session.query(MemoryCapture)
+            .filter_by(company_id=company_id, status=MemoryCaptureStatus.FAILED)
+            .filter(MemoryCapture.updated_at < failed_before)
+            .order_by(MemoryCapture.updated_at.asc(), MemoryCapture.id.asc())
+            .limit(limit)
+            .all()
+        )
+
     def add_page_sources(self, company_id: int, wiki_page_id: int, item_ids: list[int]) -> None:
         """Links items to a wiki page, keeping the links it already has."""
         if not company_id or not wiki_page_id:

iatoolkit-2.68.0/src/iatoolkit/repositories/memory_usage_repo.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from __future__ import annotations
+
+from collections import Counter
+from datetime import datetime
+
+from injector import inject
+from sqlalchemy import case, func
+
+from iatoolkit.common import memory_tools
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.repositories.models import MemoryUsageEvent
+
+
+class MemoryUsageRepo:
+    """iat_memory_usage_events: one row per use of the company's knowledge (Fase 2)."""
+
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.session = db_manager.get_session()
+
+    def add(self, event: MemoryUsageEvent) -> None:
+        self.session.add(event)
+        self.session.commit()
+
+    def rollback(self) -> None:
+        self.session.rollback()
+
+    def summarize(self, company_id: int, start: datetime, end: datetime) -> dict:
+        """What the company's knowledge was used for in [start, end), by tool, channel and day."""
+        base = (
+            self.session.query(MemoryUsageEvent)
+            .filter(MemoryUsageEvent.company_id == company_id,
+                    MemoryUsageEvent.created_at >= start, MemoryUsageEvent.created_at < end)
+        )
+        searches = found = 0
+        by_channel: Counter = Counter()
+        by_day: Counter = Counter()
+        found_flag = case((MemoryUsageEvent.results > 0, 1), else_=0)
+        day = func.date(MemoryUsageEvent.created_at)
+        rows = (
+            base.with_entities(MemoryUsageEvent.channel, day, found_flag, func.count(MemoryUsageEvent.id))
+            .filter(MemoryUsageEvent.tool.in_(list(memory_tools.SEARCH_TOOLS)))
+            .group_by(MemoryUsageEvent.channel, day, found_flag)
+            .all()
+        )
+        for channel, event_day, was_found, count in rows:
+            searches += count
+            if was_found:
+                found += count
+            by_channel[channel] += count
+            by_day[str(event_day)] += count
+        page_reads = Counter({str(page_id): count for page_id, count in (
+            base.with_entities(MemoryUsageEvent.page_id, func.count(MemoryUsageEvent.id))
+            .filter(MemoryUsageEvent.tool == memory_tools.PAGE_READ_TOOL, MemoryUsageEvent.page_id.isnot(None))
+            .group_by(MemoryUsageEvent.page_id).all()
+        )})
+        document_reads = Counter({str(document_id): count for document_id, count in (
+            base.with_entities(MemoryUsageEvent.document_id, func.count(MemoryUsageEvent.id))
+            .filter(MemoryUsageEvent.tool == memory_tools.DOCUMENT_READ_TOOL, MemoryUsageEvent.document_id.isnot(None))
+            .group_by(MemoryUsageEvent.document_id).all()
+        )})
+        return {"searches": searches, "searches_found": found, "by_channel": dict(by_channel),
+                "by_day": dict(by_day), "page_reads": page_reads, "document_reads": document_reads}

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/repositories/models.py

@@ -871,6 +871,69 @@ class KnowledgeWikiPage(Base):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
 
+class MemoryUsageEvent(Base):
+    """
+    One use of the company's knowledge (Fase 2): a page or document search, or
+    a read of what it found, from the chat or an MCP client. Written by the tool
+    handlers (core) and the MCP backend (enterprise); Impacto and the
+    recognition read these instead of `iat_queries`.
+    """
+    __tablename__ = "iat_memory_usage_events"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    company_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_companies.id", ondelete="CASCADE"), nullable=False)
+    created_at = Column(DateTime, default=datetime.now, nullable=False)
+    user_identifier = Column(String, nullable=True)
+    channel = Column(String(16), nullable=False, default="chat")
+    tool = Column(String(64), nullable=False)
+    # Searches: what was asked and how much came back. Reads: what was read.
+    query = Column(String(300), nullable=True)
+    results = Column(Integer, nullable=False, default=0)
+    page_id = Column(Integer, nullable=True)
+    document_id = Column(Integer, nullable=True)
+
+    __table_args__ = (
+        Index("ix_iat_memory_usage_events_company_created", "company_id", "created_at"),
+    )
+
+
+class KnowledgeWikiPageIndex(Base):
+    """
+    The search index of a wiki page (Fase 1 of the Memoria architecture review):
+    the text to search and its embedding, so `search_pages` is one hybrid SQL
+    query (words + meaning, fused by RRF, as the RAG) instead of scoring every
+    page in Python.
+
+    Its own table, so `iat_knowledge_wiki_pages` keeps its shape and create_all()
+    builds this one with its index (no migration). The text is written with the
+    page (KnowledgeWikiRepo); the embedding afterwards (WikiPageIndexService),
+    and it is cleared whenever the text changes. A page without an embedding is
+    still found by its words.
+    """
+    __tablename__ = "iat_knowledge_wiki_page_index"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    page_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_knowledge_wiki_pages.id", ondelete="CASCADE"),
+                     nullable=False, unique=True)
+    wiki_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_knowledge_wikis.id", ondelete="CASCADE"),
+                     nullable=False, index=True)
+    company_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_companies.id", ondelete="CASCADE"), nullable=False)
+    search_text = Column(Text, nullable=False, default="")
+    content_hash = Column(String(64), nullable=False, default="")
+    # Dynamic size, as iat_vsdocs: whatever the company's embedding model returns.
+    embedding = Column(Vector, nullable=True)
+    embedded_hash = Column(String(64), nullable=True)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False)
+
+    __table_args__ = (
+        Index(
+            "ix_iat_knowledge_wiki_page_index_text_simple_tsv",
+            func.to_tsvector(literal_column("'simple'::regconfig"), search_text),
+            postgresql_using="gin",
+        ).ddl_if(dialect="postgresql"),
+    )
+
+
 class KnowledgeWikiPageRevision(Base):
     """Immutable audit snapshot for a manual tenant wiki page change."""
     __tablename__ = "iat_knowledge_wiki_page_revisions"

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/services/dispatcher_service.py

@@ -3,6 +3,7 @@
 #
 # IAToolkit is open source software.
 
+from iatoolkit.common import memory_tools
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.inference_service import InferenceService
@@ -88,6 +89,19 @@ class Dispatcher:
     def clear_tool_execution_hook(cls):
         cls._tool_execution_hook = None
 
+    @staticmethod
+    def _record_knowledge_use(company_short_name, function_name, arguments, result, user_identifier, runtime_source):
+        """Fase 2: one usage event per search or read of the company's knowledge (best effort)."""
+        try:
+            from iatoolkit import current_iatoolkit
+            from iatoolkit.services.memory_usage_service import MemoryUsageService
+
+            current_iatoolkit().get_injector().get(MemoryUsageService).record(
+                company_short_name, function_name, arguments, result, user_identifier=user_identifier,
+                channel=str(runtime_source or memory_tools.CHANNEL_CHAT))
+        except Exception as exc:
+            logging.warning("Memoria usage event skipped for %s: %s", function_name, exc)
+
     @classmethod
     def register_tool_type_handler(cls, tool_type: str, handler):
         """
@@ -292,7 +306,13 @@ class Dispatcher:
             handler_kwargs = dict(kwargs)
             if user_identifier and function_name in self.USER_SCOPED_SYSTEM_TOOLS:
                 handler_kwargs["user_identifier"] = user_identifier
-            return handler(company_short_name, **handler_kwargs)
+            result = handler(company_short_name, **handler_kwargs)
+            # An evaluation replaying an agent is not a use of the company's knowledge.
+            if (function_name in memory_tools.KNOWLEDGE_TOOLS
+                    and str(runtime_source or "").strip().lower() != EVALUATION_REQUEST_SOURCE):
+                self._record_knowledge_use(company_short_name, function_name, kwargs, result,
+                                           user_identifier, runtime_source)
+            return result
 
         elif tool_def.tool_type == 'INFERENCE':
             # Delegate to Inference Service with DB config

{iatoolkit-2.67.0 → iatoolkit-2.68.0}/src/iatoolkit/services/memory_compiler_service.py

@@ -15,8 +15,9 @@ from html import unescape
 
 import requests
 from injector import inject
-from sqlalchemy import text
 
+from iatoolkit.common.url_safety import fetch_with_safe_redirects
+from iatoolkit.repositories.advisory_lock import advisory_lock
 from iatoolkit.repositories.database_manager import DatabaseManager
 from iatoolkit.repositories.document_repo import DocumentRepo
 from iatoolkit.repositories.memory_repo import MemoryRepo
@@ -64,6 +65,8 @@ class MemoryCompilerService:
     # A document of the RAG that feeds the wiki (BL-014): read whole, part by part.
     DOCUMENT_MODE = "document"
     DOCUMENT_AGENT = "memory_document_ingest"
+    # A saved link is read up to this much (its title and the start of its text).
+    LINK_FETCH_MAX_BYTES = 512 * 1024
     # A meeting transcript (BL-015): decisions, procedures and owners, not the conversation.
     MEETING_AGENT = "memory_meeting_ingest"
     MEETING_KIND = "meeting"
@@ -153,24 +156,8 @@ class MemoryCompilerService:
         so the many commits made while compiling cannot release it early. Other
         databases (SQLite in tests and local runs) have no concurrent compilers.
         """
-        if self.db_manager.get_dialect() not in ("postgresql", "postgres"):
+        with advisory_lock(self.db_manager, self.ADVISORY_LOCK_NAMESPACE, company_id):
             yield
-            return
-        connection = self.db_manager.get_connection()
-        try:
-            connection.execute(
-                text("SELECT pg_advisory_lock(:namespace, :company_id)"),
-                {"namespace": self.ADVISORY_LOCK_NAMESPACE, "company_id": int(company_id)},
-            )
-            try:
-                yield
-            finally:
-                connection.execute(
-                    text("SELECT pg_advisory_unlock(:namespace, :company_id)"),
-                    {"namespace": self.ADVISORY_LOCK_NAMESPACE, "company_id": int(company_id)},
-                )
-        finally:
-            connection.close()
 
     def _agent_for(self, capture: MemoryCapture) -> str:
         mode = dict(capture.meta or {}).get("mode")
@@ -1019,9 +1006,15 @@ class MemoryCompilerService:
             return
 
         try:
-            response = requests.get(item.source_url, timeout=8, headers={"User-Agent": "IAToolkit Memory/1.0"})
+            # A link a person saved: never a private, loopback or metadata address,
+            # and every redirect checked the same way (SSRF).
+            response = fetch_with_safe_redirects(
+                item.source_url, allowed_schemes=("http", "https"), label="Memory link",
+                timeout=8, stream=True, headers={"User-Agent": "IAToolkit Memory/1.0"})
             response.raise_for_status()
-            html = response.text
+            raw = response.raw.read(self.LINK_FETCH_MAX_BYTES, decode_content=True)
+            response.close()
+            html = raw.decode(response.encoding or "utf-8", errors="replace")
         except Exception as exc:
             logging.warning("Could not fetch memory link %s: %s", item.source_url, exc)
             return