iatoolkit 2.72.2__tar.gz → 2.73.0__tar.gz

{iatoolkit-2.72.2/src/iatoolkit.egg-info → iatoolkit-2.73.0}/PKG-INFO

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

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/common/access.py

@@ -224,6 +224,65 @@ def sql_table_filter(company_short_name: str, user_identifier: str | None):
     return allowed
 
 
+# ---------------------------------------------------------------------- audiences
+# Who may see a piece of Memoria content (BL-010, Fase 3). An audience key is None
+# (the whole company) or names what decides it: "memory_folder:<id>", "group:<key>".
+
+def audience_visible(company_short_name: str, user_identifier: str | None, audience_key: str | None) -> bool:
+    if not audience_key:
+        return True
+    decider = Access._decider
+    hook = getattr(decider, "audience_visible", None) if decider is not None else None
+    if not callable(hook):
+        return True
+    try:
+        return bool(hook(company_short_name, user_identifier, audience_key))
+    except Exception as exc:
+        logging.warning("Audience %s for %s not resolved: %s", audience_key, user_identifier, exc)
+        return False
+
+
+def visible_audiences(company_short_name: str, user_identifier: str | None) -> list[str] | None:
+    """The restricted audiences a person sees; None when they see every one (or nothing is restricted).
+
+    The whole company's content (audience None) is always visible besides these."""
+    decider = Access._decider
+    hook = getattr(decider, "visible_audiences", None) if decider is not None else None
+    if not callable(hook):
+        return None
+    try:
+        return hook(company_short_name, user_identifier)
+    except Exception as exc:
+        logging.warning("Visible audiences of %s not resolved: %s", user_identifier, exc)
+        return []
+
+
+def audience_label(company_short_name: str, audience_key: str | None) -> str | None:
+    """The name people see for an audience (the folder's or group's name); None for the whole company."""
+    if not audience_key:
+        return None
+    decider = Access._decider
+    hook = getattr(decider, "audience_label", None) if decider is not None else None
+    try:
+        return (hook(company_short_name, audience_key) if callable(hook) else None) or audience_key
+    except Exception:
+        return audience_key
+
+
+def audience_for_folder(company_short_name: str, folder_id) -> str | None:
+    """The audience new content from a Memoria folder takes: its own when the folder is restricted."""
+    decider = Access._decider
+    hook = getattr(decider, "audience_for_folder", None) if decider is not None else None
+    if not callable(hook) or folder_id in (None, ""):
+        return None
+    try:
+        return hook(company_short_name, folder_id)
+    except Exception as exc:
+        # Unknown: the folder's own audience, the restrictive side.
+        logging.warning("Audience of folder %s not resolved: %s", folder_id, exc)
+        return f"memory_folder:{folder_id}"
+
+
 def person_can(company_short_name: str, auth_result: dict | None, level: int, resource_type: str = "company",
                resource_key: str | None = None) -> bool:
     """A signed-in person's access, from an AuthService result.

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/locales/en.yaml

@@ -794,6 +794,7 @@ ui:
     access_add_group: "Add group"
     access_reset: "Back to company access"
     access_saved: "Access updated."
+    access_memory_restricted: "What Memoria knows from this folder ({count} pages) is now seen only by those with access to it."
     access_group: "Group"
     access_level: "Level"
     team_invite_user: "Invite user"

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/locales/es.yaml

@@ -808,6 +808,7 @@ ui:
     access_add_group: "Agregar grupo"
     access_reset: "Volver al acceso de la empresa"
     access_saved: "Acceso actualizado."
+    access_memory_restricted: "Lo que Memoria sabe de esta carpeta ({count} páginas) ahora solo lo ven quienes tienen acceso a ella."
     access_group: "Grupo"
     access_level: "Nivel"
     team_invite_user: "Invitar usuario"

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/repositories/knowledge_wiki_repo.py

@@ -299,7 +299,7 @@ class KnowledgeWikiRepo:
     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]]:
+                            candidates: int = 40, audience_keys: list | None = None) -> 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
@@ -313,6 +313,15 @@ class KnowledgeWikiRepo:
         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}
+        # Audiences (BL-010, Fase 3): only pages whose audience is listed, None being the
+        # whole company. Filtered here, before the limit, not after the ranking.
+        audience_sql = ""
+        if audience_keys is not None:
+            keys = [k for k in audience_keys if k]
+            clauses = (["p.audience_key IS NULL"] if None in audience_keys else []) + \
+                (["p.audience_key = ANY(:audience_keys)"] if keys else [])
+            audience_sql = f" AND ({' OR '.join(clauses) or 'FALSE'})"
+            params["audience_keys"] = keys
         branches = [f"""
                 SELECT page_id, ROW_NUMBER() OVER (ORDER BY text_rank DESC, page_id ASC) AS rank
                 FROM (
@@ -320,7 +329,7 @@ class KnowledgeWikiRepo:
                     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
+                    WHERE i.wiki_id = ANY(:wiki_ids) AND p.status::text <> :archived{audience_sql}
                       AND {tsvector} @@ terms.q
                     ORDER BY text_rank DESC
                     LIMIT :candidates
@@ -336,7 +345,7 @@ class KnowledgeWikiRepo:
                            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
+                    WHERE i.wiki_id = ANY(:wiki_ids) AND p.status::text <> :archived{audience_sql}
                       AND i.embedding IS NOT NULL AND vector_dims(i.embedding) = {dims}
                     ORDER BY distance ASC
                     LIMIT :candidates

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/repositories/memory_repo.py

@@ -109,12 +109,21 @@ class MemoryRepo:
             .all()
         )
 
-    def list_recent_items(self, company_id: int, limit: int = 25) -> list[MemoryItem]:
+    def list_recent_items(self, company_id: int, limit: int = 25, audience_keys: list | None = None) -> list[MemoryItem]:
+        """The company's latest items; with `audience_keys`, only those of captures of those
+        audiences (None in the list is the whole company; BL-010, Fase 3)."""
         if not company_id:
             return []
+        query = self.session.query(MemoryItem).filter(MemoryItem.company_id == company_id)
+        if audience_keys is not None:
+            from sqlalchemy import false, or_
+            keys = [k for k in audience_keys if k]
+            clauses = ([MemoryCapture.audience_key.is_(None)] if None in audience_keys else []) + \
+                ([MemoryCapture.audience_key.in_(keys)] if keys else [])
+            query = query.join(MemoryCapture, MemoryCapture.id == MemoryItem.capture_id) \
+                .filter(or_(*clauses) if clauses else false())
         return (
-            self.session.query(MemoryItem)
-            .filter_by(company_id=company_id)
+            query
             .order_by(MemoryItem.created_at.desc(), MemoryItem.id.desc())
             .limit(limit)
             .all()

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/repositories/models.py

@@ -527,6 +527,10 @@ class MemoryCapture(Base):
     title = Column(String, nullable=True)
     status = Column(Enum(MemoryCaptureStatus), nullable=False, default=MemoryCaptureStatus.PENDING)
     meta = Column(JSON_NATIVE, nullable=True)
+    # Who may see what this capture teaches (BL-010, Fase 3): NULL is the whole company,
+    # "memory_folder:<id>" a folder with its own access. The compiler writes it only into
+    # pages of the same audience. Migration: migrations/2026-10-18-memoria-audiencia.sql
+    audience_key = Column(String(255), nullable=True)
     compile_error = Column(Text, nullable=True)
     last_compiled_at = Column(DateTime, nullable=True)
     created_at = Column(DateTime, default=datetime.now, nullable=False)
@@ -859,6 +863,9 @@ class KnowledgeWikiPage(Base):
     # An empty list denies the page under access control, which is why the sync
     # writes them from the wiki's access manifest and never from frontmatter.
     access_tags = Column(JSON_NATIVE, nullable=False, default=list)
+    # A Memoria page's audience (BL-010, Fase 3): NULL is the whole company. A page never
+    # mixes audiences. Migration: migrations/2026-10-18-memoria-audiencia.sql
+    audience_key = Column(String(255), nullable=True)
     owner = Column(String, nullable=True)
     source_meta = Column(JSON_NATIVE, nullable=False, default=dict)
     last_synced_at = Column(DateTime, nullable=True)

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/services/memory_compiler_service.py

@@ -26,11 +26,12 @@ from iatoolkit.repositories.models import (
     Company, MemoryCapture, MemoryCaptureStatus, MemoryConflict, MemoryItem, MemoryItemStatus, MemoryItemType, VSDoc,
 )
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.services.memory_sources import MemorySourceRegistry, register_core_sources
+from iatoolkit.services.memory_sources import VISIBILITY_FOLDER, MemorySourceRegistry, register_core_sources
 from iatoolkit.services.memory_wiki_service import MemoryWikiService
 from iatoolkit.services.storage_service import StorageService
 from iatoolkit.services.system_agent_runner import SystemAgentDisabled, SystemAgentRunner
 from iatoolkit.services.tenant_wiki_service import TenantWikiService
+from iatoolkit.common import access
 
 
 class MemoryCompilerService:
@@ -222,6 +223,14 @@ class MemoryCompilerService:
     def _compile_single_capture(self, company: Company, capture: MemoryCapture, items: list[MemoryItem]) -> bool:
         """Reads the capture with the step its source declares (memory_sources)."""
         source = MemorySourceRegistry.for_capture(dict(capture.meta or {}))
+        if source.visibility == VISIBILITY_FOLDER and not getattr(capture, "audience_key", None):
+            # A document saved before its folder was restricted (or before audiences
+            # existed) takes the folder's audience now: the restrictive side.
+            folder_id = (dict(capture.meta or {}).get("source") or {}).get("folder_id")
+            audience = access.audience_for_folder(company.short_name, folder_id)
+            if audience:
+                capture.audience_key = audience
+                self.memory_repo.save_capture(capture)
         return getattr(self, source.handler)(company, capture, items)
 
     def _compile_person_capture(self, company: Company, capture: MemoryCapture, items: list[MemoryItem]) -> bool:
@@ -244,6 +253,7 @@ class MemoryCompilerService:
                 compiled,
                 candidates,
                 edited_by=capture.user_identifier,
+                audience_key=self._audience(capture)[0],
                 default_title=self._default_page_title(capture, items),
                 revision_metadata={
                     "source": self.COMPILER_SOURCE,
@@ -282,7 +292,8 @@ class MemoryCompilerService:
                     *,
                     edited_by: str,
                     default_title: str,
-                    revision_metadata: dict) -> dict:
+                    revision_metadata: dict,
+                    audience_key: str | None = None) -> dict:
         """Creates or updates the page the model returned; the wiki's response (it may say the page changed)."""
         target = self._resolve_target(compiled, candidates)
         title = str(compiled.get("title") or (target or {}).get("title") or default_title).strip()
@@ -298,6 +309,7 @@ class MemoryCompilerService:
                 edited_by=edited_by,
                 change_summary=change_summary,
                 revision_metadata=revision_metadata,
+                audience_key=audience_key,
             )
         return self.memory_wiki_service.update_page(
             company.short_name,
@@ -356,7 +368,7 @@ class MemoryCompilerService:
         touched: list[int] = []
         for index, (part_text, read) in enumerate(readers, start=1):
             for attempt in range(1, self.MAX_SAVE_ATTEMPTS + 1):
-                candidates = self._document_candidates(company, source, part_text, touched)
+                candidates = self._document_candidates(company, source, part_text, touched, capture)
                 answer = read(candidates)
                 if answer is None:
                     raise RuntimeError(f"the model could not read part {index} of {len(readers)}")
@@ -367,6 +379,7 @@ class MemoryCompilerService:
                     response = self._write_page(
                         company, compiled, candidates,
                         edited_by=capture.user_identifier,
+                        audience_key=self._audience(capture)[0],
                         default_title=label,
                         revision_metadata=revision_metadata,
                     )
@@ -535,30 +548,35 @@ class MemoryCompilerService:
             parts.append("\n\n".join(current))
         return parts
 
-    def _document_candidates(self, company: Company, source: dict, part_text: str, touched: list[int]) -> list[dict]:
+    def _document_candidates(self, company: Company, source: dict, part_text: str, touched: list[int],
+                             capture: MemoryCapture | None = None) -> list[dict]:
         """The pages this document already wrote first, then the ones its part is most likely about."""
+        audience = self._audience(capture) if capture is not None else [None]
         ordered: list[int] = list(touched)
         card = source.get("card") or {}
         query = " ".join(part for part in (
             str(source.get("label") or ""), str(card.get("summary") or ""), part_text[:300],
         ) if part).strip()
         if query:
-            for result in self.memory_wiki_service.search_pages(company.short_name, query, limit=self.MAX_CANDIDATE_PAGES):
+            for result in self.memory_wiki_service.search_pages(company.short_name, query, limit=self.MAX_CANDIDATE_PAGES,
+                                                                audience_keys=audience):
                 if result.get("id") not in ordered:
                     ordered.append(result.get("id"))
         candidates = []
         for page_id in ordered[:self.MAX_CANDIDATE_PAGES + len(touched)]:
-            page = self.memory_wiki_service.get_page(company.short_name, page_id)
+            page = self.memory_wiki_service.get_page(company.short_name, page_id, audience_keys=audience)
             if page:
                 candidates.append(page)
         return candidates
 
-    def _wiki_context(self, company: Company, candidates: list[dict]) -> dict:
+    def _wiki_context(self, company: Company, candidates: list[dict], capture: MemoryCapture | None = None) -> dict:
         return {
             "wiki_schema": str(self.memory_wiki_service.read_schema() or "")[:7000],
             "page_index": [
                 {"page_id": entry.get("id"), "title": entry.get("title"), "summary": entry.get("summary")}
-                for entry in (self.memory_wiki_service.list_pages(company.short_name) or [])[:self.MAX_INDEX_ENTRIES_IN_PROMPT]
+                for entry in (self.memory_wiki_service.list_pages(
+                    company.short_name, audience_keys=self._audience(capture) if capture is not None else [None]) or []
+                )[:self.MAX_INDEX_ENTRIES_IN_PROMPT]
             ],
             "candidate_pages": [
                 {"page_id": page.get("id"), "title": page.get("title"),
@@ -576,7 +594,7 @@ class MemoryCompilerService:
                               captured_on: str):
         return self._ingest_with_llm(
             company, capture, self._agent_for(capture) or self.DOCUMENT_AGENT,
-            {"source": source, "part": part, "captured_on": captured_on, **self._wiki_context(company, candidates)},
+            {"source": source, "part": part, "captured_on": captured_on, **self._wiki_context(company, candidates, capture)},
             question=f"Read memory document {source.get('label')} (part {part['index']} of {part['total']})",
         )
 
@@ -589,7 +607,7 @@ class MemoryCompilerService:
                                captured_on: str):
         return self._ingest_with_llm(
             company, capture, self.IMAGE_AGENT,
-            {"source": source, "captured_on": captured_on, **self._wiki_context(company, candidates)},
+            {"source": source, "captured_on": captured_on, **self._wiki_context(company, candidates, capture)},
             question=f"Look at memory image {source.get('label')}",
             images=images,
         )
@@ -776,6 +794,11 @@ class MemoryCompilerService:
         capture.last_compiled_at = datetime.now()
         self.memory_repo.save_capture(capture)
 
+    @staticmethod
+    def _audience(capture: MemoryCapture) -> list:
+        """The one audience a capture compiles into (BL-010, Fase 3): it sees and writes only its pages."""
+        return [getattr(capture, "audience_key", None) or None]
+
     def _load_candidate_pages(self, company: Company, capture: MemoryCapture, items: list[MemoryItem]) -> list[dict]:
         """Pages the capture most likely belongs to, read in full (markdown and checksum)."""
         ordered_ids: list[int] = []
@@ -788,15 +811,17 @@ class MemoryCompilerService:
         for page_id in self.memory_repo.list_page_ids_for_items([item.id for item in items if getattr(item, "id", None)]):
             add(page_id)
         query = self._memory_capture_query(capture, items)
+        audience = self._audience(capture)
         if query:
-            for result in self.memory_wiki_service.search_pages(company.short_name, query, limit=self.MAX_CANDIDATE_PAGES):
+            for result in self.memory_wiki_service.search_pages(company.short_name, query, limit=self.MAX_CANDIDATE_PAGES,
+                                                                audience_keys=audience):
                 add(result.get("id"))
 
         candidates = []
         for page_id in ordered_ids:
             if len(candidates) >= self.MAX_CANDIDATE_PAGES:
                 break
-            page = self.memory_wiki_service.get_page(company.short_name, page_id)
+            page = self.memory_wiki_service.get_page(company.short_name, page_id, audience_keys=audience)
             if page:
                 candidates.append(page)
         return candidates
@@ -827,7 +852,7 @@ class MemoryCompilerService:
             author=author,
             captured_on=captured_on,
             wiki_schema=self.memory_wiki_service.read_schema(),
-            index_entries=self.memory_wiki_service.list_pages(company.short_name),
+            index_entries=self.memory_wiki_service.list_pages(company.short_name, audience_keys=self._audience(capture)),
         )
         native_pdf_attachments = self._build_capture_native_pdf_attachments(company.short_name, items)
         try:

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/services/memory_service.py

@@ -32,6 +32,7 @@ from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.services.memory_compiler_service import MemoryCompilerService
 from iatoolkit.services.memory_wiki_service import MemoryWikiService
 from iatoolkit.services.storage_service import StorageService
+from iatoolkit.common import access
 
 
 class MemoryService:
@@ -110,7 +111,9 @@ class MemoryService:
                      capture_text: str | None = None,
                      new_items: list[dict] | None = None,
                      title: str | None = None,
-                     meta: dict | None = None) -> dict:
+                     meta: dict | None = None,
+                     audience_key: str | None = None) -> dict:
+        """`audience_key` (BL-010, Fase 3): who may see what it teaches; None is the whole company."""
         company = self.profile_repo.get_company_by_short_name(company_short_name)
         if not company:
             return {"status": "error", "error_message": "company not found"}
@@ -123,6 +126,7 @@ class MemoryService:
             title=(title or capture_text or "")[:200] or None,
             status=MemoryCaptureStatus.PENDING,
             meta=dict(meta or {}),
+            audience_key=audience_key or None,
         )
         self.memory_repo.create_capture(capture)
 
@@ -166,7 +170,8 @@ class MemoryService:
                               path: str = "",
                               author: str | None = None,
                               source_meta: dict | None = None,
-                              kind: str | None = None) -> dict:
+                              kind: str | None = None,
+                              audience_key: str | None = None) -> dict:
         """
         A RAG document that feeds the wiki (BL-014), queued as a capture so the
         compiler reads it whole, part by part (`memory_document_ingest`; a
@@ -177,10 +182,14 @@ class MemoryService:
         reads the document's fragments from the RAG when it gets to it.
         """
         label = str(label or "").strip() or f"Documento {document_id}"
+        # A document of a restricted folder teaches only that folder's audience (BL-010, Fase 3).
+        if audience_key is None:
+            audience_key = access.audience_for_folder(company_short_name, (source_meta or {}).get("folder_id"))
         return self.save_capture(
             company_short_name=company_short_name,
             user_identifier=author or self.DOCUMENT_SOURCE_IDENTITY,
             title=label,
+            audience_key=audience_key,
             new_items=[{
                 "item_type": "file",
                 "title": label,
@@ -216,13 +225,17 @@ class MemoryService:
         company = self.profile_repo.get_company_by_short_name(company_short_name)
         if not company:
             return {"status": "error", "error_message": "company not found"}
-        if not self.memory_repo.list_page_ids_for_document(company.id, document_id):
+        page_ids = self.memory_repo.list_page_ids_for_document(company.id, document_id)
+        if not page_ids:
             return {"status": "skipped", "reason": "no page cites this document"}
         label = str(label or "").strip() or f"Documento {document_id}"
+        # The pages that cite it share an audience: the mark runs in it.
+        first_page = self.memory_wiki_service.get_page(company_short_name, page_ids[0]) or {}
         return self.save_capture(
             company_short_name=company_short_name,
             user_identifier=removed_by or self.DOCUMENT_SOURCE_IDENTITY,
             title=label,
+            audience_key=first_page.get("audience_key"),
             new_items=[{
                 "item_type": "note",
                 "title": label,
@@ -335,6 +348,46 @@ class MemoryService:
             "capture": self.serialize_capture(capture, refreshed_items, company_short_name=company_short_name),
         }
 
+    @staticmethod
+    def audiences_for(company_short_name: str, user_identifier: str | None) -> list | None:
+        """The audiences a person may read (BL-010, Fase 3): the whole company (None) plus the
+        restricted ones they see; None when nothing is filtered (administration, core alone)."""
+        if not access.Access.registered():
+            return None
+        visible = access.visible_audiences(company_short_name, user_identifier)
+        return None if visible is None else [None, *visible]
+
+    def restrict_document_pages(self, company_short_name: str, document_ids, audience_key: str) -> int:
+        """A folder became restricted (BL-010, Fase 3): the company pages that cite its documents
+        move to its audience, so what they say stops reaching the whole company. The page keeps
+        its path; how many moved is returned."""
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company or not audience_key:
+            return 0
+        page_ids = set()
+        for document_id in {int(d) for d in document_ids or [] if d}:
+            page_ids.update(self.memory_repo.list_page_ids_for_document(company.id, document_id))
+        moved = 0
+        for page_id in sorted(page_ids):
+            page = self.memory_wiki_service.get_page(company_short_name, page_id, audience_keys=[None])
+            if page is None:
+                continue
+            if self.memory_wiki_service.set_page_audience(company_short_name, page_id, audience_key):
+                moved += 1
+        if moved:
+            logging.info("Memoria: %s company pages of %s moved to audience %s", moved, company_short_name, audience_key)
+        return moved
+
+    def delete_audience_pages(self, company_short_name: str, audience_key: str, deleted_by: str | None = None) -> int:
+        """The audience is gone (its folder was deleted): its pages go with it. How many were deleted."""
+        if not audience_key:
+            return 0
+        deleted = 0
+        for page in self.memory_wiki_service.list_audience_pages(company_short_name, audience_key):
+            result = self.memory_wiki_service.delete_page(company_short_name, page=page, edited_by=deleted_by)
+            deleted += 1 if result.get("status") == "success" else 0
+        return deleted
+
     def get_memory_dashboard(self, company_short_name: str, user_identifier: str) -> dict:
         """What the chat's Memoria panel shows: the user's own captures and the company's pages."""
         self._compile_on_demand(company_short_name)
@@ -351,11 +404,16 @@ class MemoryService:
             "status": "success",
             "captures": serialized_captures,
             "recent_items": serialized_captures,
-            "pages": self.list_pages(company_short_name),
+            "pages": self.list_pages(company_short_name, user_identifier=user_identifier),
         }
 
-    def list_pages(self, company_short_name: str) -> list[dict]:
-        return [self.serialize_page(entry) for entry in self.memory_wiki_service.list_pages(company_short_name)]
+    def list_pages(self, company_short_name: str, user_identifier: str | None = None,
+                   audience_keys: list | None = None) -> list[dict]:
+        """The pages; with a person, those of the audiences they may read."""
+        if audience_keys is None and user_identifier:
+            audience_keys = self.audiences_for(company_short_name, user_identifier)
+        return [self.serialize_page(entry)
+                for entry in self.memory_wiki_service.list_pages(company_short_name, audience_keys=audience_keys)]
 
     def search_pages(self,
                      company_short_name: str,
@@ -368,9 +426,11 @@ class MemoryService:
         if not company:
             return {"status": "error", "results": [], "error_message": "company not found"}
 
+        audiences = self.audiences_for(company_short_name, user_identifier)
         results = []
         source_items_by_page_id = {}
-        for entry in self.memory_wiki_service.search_pages(company_short_name, query, limit=limit):
+        for entry in self.memory_wiki_service.search_pages(company_short_name, query, limit=limit,
+                                                           audience_keys=audiences):
             page_id = entry.get("id")
             source_items = self._load_page_source_items(company.id, page_id)
             source_items_by_page_id[page_id] = source_items
@@ -399,6 +459,7 @@ class MemoryService:
             normalized_query=normalized_query,
             query_tokens=self._tokenize(query),
             limit=limit,
+            audience_keys=audiences,
         )
 
         response = {
@@ -441,7 +502,9 @@ class MemoryService:
         if not company:
             return {"status": "error", "error_message": "company not found"}
 
-        page = self.memory_wiki_service.get_page(company_short_name, page_id)
+        # A page of an audience the person may not read is "not found" (BL-010, Fase 3).
+        page = self.memory_wiki_service.get_page(company_short_name, page_id,
+                                                 audience_keys=self.audiences_for(company_short_name, user_identifier))
         if not page:
             return {"status": "error", "error_message": "page not found"}
 
@@ -489,12 +552,16 @@ class MemoryService:
         text = str(instruction or "").strip()
         if not text:
             return {"status": "error", "error_message": "write what to correct or add"}
-        if not self.memory_wiki_service.get_page(company_short_name, page_id):
+        page = self.memory_wiki_service.get_page(company_short_name, page_id,
+                                                 audience_keys=self.audiences_for(company_short_name, user_identifier))
+        if not page:
             return {"status": "error", "error_message": "page not found"}
         response = self.save_capture(
             company_short_name=company_short_name,
             user_identifier=user_identifier,
             capture_text=text,
+            # A correction lives in its page's audience (BL-010, Fase 3).
+            audience_key=page.get("audience_key"),
             title=f"Corrección: {text}"[:200],
             new_items=[{"item_type": "note", "content_text": text, "source_meta": {"origin": "page_correction"}}],
             meta={
@@ -782,8 +849,9 @@ class MemoryService:
                           company_id: int,
                           normalized_query: str,
                           query_tokens: list[str],
-                          limit: int) -> list[dict]:
-        items = self.memory_repo.list_recent_items(company_id, limit=max(limit * 12, 60))
+                          limit: int,
+                          audience_keys: list | None = None) -> list[dict]:
+        items = self.memory_repo.list_recent_items(company_id, limit=max(limit * 12, 60), audience_keys=audience_keys)
         ranked = []
         for item in items:
             score = self._score_memory_item_match(normalized_query, query_tokens, item)

{iatoolkit-2.72.2 → iatoolkit-2.73.0}/src/iatoolkit/services/memory_sources.py

@@ -20,8 +20,10 @@ over three services. A source now declares, in one place:
   version is read; "add": both stay, as two people saying things);
 - `on_removal`: what its removal does ("mark_obsolete": its lines are marked,
   never erased; "none");
-- `visibility`: who may read what it teaches. "company" for every source today;
-  the field is where Fase 4 (BL-010) will declare restricted sources.
+- `visibility`: who may read what it teaches: "company" (people, corrections in the
+  page's audience) or "folder" (a document: its folder's audience when restricted).
+  The capture carries the audience (`audience_key`) and the compiler writes it only
+  into pages of that audience (BL-010, Fase 3).
 
 A new source registers here (`MemorySourceRegistry.register`) instead of adding
 another branch to the compiler.
@@ -36,6 +38,8 @@ VERSION_ADD = "add"
 REMOVAL_MARK_OBSOLETE = "mark_obsolete"
 REMOVAL_NONE = "none"
 VISIBILITY_COMPANY = "company"
+# What it teaches is for its folder's audience when the folder is restricted (BL-010, Fase 3).
+VISIBILITY_FOLDER = "folder"
 
 
 @dataclass(frozen=True)
@@ -93,7 +97,7 @@ def register_core_sources(*, compiler_agent: str, correction_agent: str, documen
     MemorySourceRegistry.register(MemorySource(
         key="document", mode=document_mode, handler="_ingest_document", agent=document_agent,
         kind_agents={meeting_kind: meeting_agent},
-        on_new_version=VERSION_REPLACE, on_removal=REMOVAL_MARK_OBSOLETE,
+        on_new_version=VERSION_REPLACE, on_removal=REMOVAL_MARK_OBSOLETE, visibility=VISIBILITY_FOLDER,
         description="A document of a Memoria folder (Drive or uploaded), or a meeting transcript.",
     ))
     MemorySourceRegistry.register(MemorySource(