iatoolkit 2.72.1__tar.gz → 2.73.0__tar.gz

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

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

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

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

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

@@ -192,6 +192,97 @@ def filter_llm_models(company_short_name: str, user_identifier: str | None, defa
     return default_model, allowed
 
 
+def stamp(company_short_name: str) -> str | None:
+    """A value that changes whenever the company's groups, members or grants change.
+
+    A person's chat context is built once and cached; when this changes, it is rebuilt
+    so the tools, SQL schema and collections it describes follow the new access."""
+    decider = Access._decider
+    hook = getattr(decider, "stamp", None) if decider is not None else None
+    if not callable(hook):
+        return None
+    try:
+        return hook(company_short_name)
+    except Exception as exc:
+        logging.warning("Access stamp of %s not read: %s", company_short_name, exc)
+        return None
+
+
+def sql_table_filter(company_short_name: str, user_identifier: str | None):
+    """`fn(database, table) -> bool` for the SQL schema shown to this person, or None.
+
+    Some SQL sources hold resources of their own (enterprise's knowledge tables): the
+    decider names their resource type, and each table needs level 1 over it."""
+    decider = Access._decider
+    hook = getattr(decider, "sql_table_resource", None) if decider is not None else None
+    if not user_identifier or not callable(hook):
+        return None
+
+    def allowed(database: str, table: str) -> bool:
+        resource_type = hook(company_short_name, database)
+        return not resource_type or can(company_short_name, user_identifier, USE, resource_type, table)
+    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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → iatoolkit-2.73.0}/src/iatoolkit/services/company_context_service.py

@@ -53,6 +53,7 @@ class CompanyContextService:
         include_yaml_context: bool = True,
         selected_context_files: List[str] | None = None,
         allowed_databases: List[str] | None = None,
+        table_filter=None,
     ) -> dict[str, str]:
         """
         Builds the full context by aggregating three sources:
@@ -81,7 +82,8 @@ class CompanyContextService:
             try:
                 # allowed_databases: the sources this person may query (BL-010); None is all.
                 sql_context, db_tables = self._get_sql_enriched_context(company_short_name,
-                                                                        allowed_databases=allowed_databases)
+                                                                        allowed_databases=allowed_databases,
+                                                                        table_filter=table_filter)
                 sql_context = sql_context.strip()
                 sql_source_table_scopes = self._get_sql_source_table_scopes(company_short_name)
             except Exception as e:
@@ -138,11 +140,13 @@ class CompanyContextService:
             )
         return files
 
-    def get_sql_context(self, company_short_name: str, allowed_databases: List[str] | None = None) -> str:
+    def get_sql_context(self, company_short_name: str, allowed_databases: List[str] | None = None,
+                        table_filter=None) -> str:
         try:
             sql_context, _ = self._get_sql_enriched_context(
                 company_short_name,
                 allowed_databases=allowed_databases,
+                table_filter=table_filter,
             )
             return sql_context
         except Exception as e:
@@ -177,7 +181,8 @@ class CompanyContextService:
             return False
         return bool(cls._table_name_candidates(table_name) & allowed_tables)
 
-    def _get_sql_enriched_context(self, company_short_name: str, allowed_databases: List[str] | None = None):
+    def _get_sql_enriched_context(self, company_short_name: str, allowed_databases: List[str] | None = None,
+                                  table_filter=None):
         """
         Generates the SQL context for the LLM using the enriched schema logic.
         It iterates over configured databases, fetches their enriched structure,
@@ -221,6 +226,15 @@ class CompanyContextService:
                     }
                     if not enriched_structure:
                         continue
+                if table_filter is not None:
+                    # Tables the person may not query (enterprise's knowledge tables, BL-010).
+                    enriched_structure = {
+                        table_name: table_data
+                        for table_name, table_data in enriched_structure.items()
+                        if table_filter(db_name, table_name)
+                    }
+                    if not enriched_structure:
+                        continue
 
                 # 2. Build Header for this Database
                 dialect = self.sql_service.get_database_dialect(company_short_name, db_name)

{iatoolkit-2.72.1 → iatoolkit-2.73.0}/src/iatoolkit/services/context_builder_service.py

@@ -19,6 +19,7 @@ from iatoolkit.services.prompt_service import PromptService
 from iatoolkit.services.structured_output_service import StructuredOutputService
 from iatoolkit.common.util import Utility
 from iatoolkit.repositories.models import Company, PromptResourceType
+from iatoolkit.common import access
 
 
 class ContextBuilderService:
@@ -227,7 +228,8 @@ class ContextBuilderService:
         # sources and collections this person may use (BL-010, Fase 2).
         allowed_databases, allowed_collections = self._access_restrictions(company_short_name, user_identifier)
         company_context_blocks = self.company_context_service.get_company_context_blocks(
-            company_short_name, allowed_databases=allowed_databases)
+            company_short_name, allowed_databases=allowed_databases,
+            table_filter=access.sql_table_filter(company_short_name, user_identifier))
         collection_context = "" if allowed_collections == [] else self._build_collection_context(
             company_short_name, collection_names=allowed_collections)
 
@@ -386,6 +388,7 @@ class ContextBuilderService:
             sql_context = self.company_context_service.get_sql_context(
                 company_short_name,
                 allowed_databases=sql_sources,
+                table_filter=access.sql_table_filter(company_short_name, user_identifier),
             )
 
         collection_context = ""
@@ -399,6 +402,7 @@ class ContextBuilderService:
         company_context_blocks = self.company_context_service.get_company_context_blocks(
             company_short_name,
             allowed_databases=allowed_databases,
+            table_filter=access.sql_table_filter(company_short_name, user_identifier),
             include_sql_context=bool(company_context_policy.get("sql_context")),
             include_yaml_context=bool(company_context_policy.get("yaml_context")),
         )

{iatoolkit-2.72.1 → iatoolkit-2.73.0}/src/iatoolkit/services/knowledge_base_service.py

@@ -610,7 +610,11 @@ class KnowledgeBaseService:
             else:
                 query = query.filter(Document.status == status)
 
-        if collection:
+        if isinstance(collection, (list, tuple, set)):
+            # Several collections: those a person may see (BL-010). An empty list is none.
+            names = [str(c).strip().lower() for c in collection if str(c or "").strip()]
+            query = query.join(Document.collection_type).filter(func.lower(CollectionType.name).in_(names or [""]))
+        elif collection:
             normalized_collection = str(collection).strip().lower()
             query = query.join(Document.collection_type).filter(
                 func.lower(CollectionType.name) == normalized_collection

{iatoolkit-2.72.1 → 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: