ltcai 9.0.0 → 9.2.0

package/lattice_brain/graph/ingest.py

@@ -5,6 +5,20 @@ from __future__ import annotations
 from ._kg_common import *  # noqa: F403,F401
 
 
+def _scoped_slug_id(prefix: str, value: str, workspace_id: Optional[str]) -> str:
+    """Keep legacy IDs unchanged while isolating every newly scoped identity."""
+    slug = _slug(value)
+    if not workspace_id:
+        return f"{prefix}:{slug}"
+    scope = _sha256_text(str(workspace_id))[:12]
+    return f"{prefix}:{scope}:{slug}"
+
+
+def _scoped_hash_id(prefix: str, value: str, workspace_id: Optional[str]) -> str:
+    identity = f"{workspace_id}|{value}" if workspace_id else value
+    return f"{prefix}:{_sha256_text(identity)[:24]}"
+
+
 class KnowledgeGraphIngestMixin:
     def ingest_message(
         self,
@@ -19,12 +33,10 @@ class KnowledgeGraphIngestMixin:
         raw: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         content = str(content or "")
-        digest = _sha256_text(
-            "|".join([role or "", content, conversation_id or "", user_email or ""])
-        )[:24]
         node_type = "AIResponse" if role == "assistant" else "Message"
-        node_id = f"{node_type.lower()}:{digest}"
-        conv_id = f"conversation:{_slug(conversation_id or 'default')}"
+        message_identity = "|".join([role or "", content, conversation_id or "", user_email or ""])
+        node_id = _scoped_hash_id(node_type.lower(), message_identity, workspace_id)
+        conv_id = _scoped_slug_id("conversation", conversation_id or "default", workspace_id)
         metadata = {
             "role": role,
             "source": source,
@@ -58,7 +70,7 @@ class KnowledgeGraphIngestMixin:
             person_id = None
             if user_email or user_nickname:
                 person_key = user_email or user_nickname or "unknown"
-                person_id = f"person:{_slug(person_key)}"
+                person_id = _scoped_slug_id("person", person_key, workspace_id)
                 self._upsert_node(
                     conn,
                     person_id,
@@ -121,7 +133,7 @@ class KnowledgeGraphIngestMixin:
             concept_ids: Dict[str, str] = {}
             for concept in concepts:
                 node_t = _classify_node_type(concept, content)
-                cid = f"{node_t.lower()}:{_slug(concept)}"
+                cid = _scoped_slug_id(node_t.lower(), concept, workspace_id)
                 concept_ids[concept.lower()] = cid
                 self._upsert_node(
                     conn,
@@ -212,7 +224,7 @@ class KnowledgeGraphIngestMixin:
         text = str(
             (extracted or {}).get("content") or (extracted or {}).get("preview") or ""
         )
-        file_id = f"file:{digest[:24]}"
+        file_id = _scoped_hash_id("file", digest, workspace_id)
         metadata = {
             "filename": filename,
             "ext": ext,
@@ -253,7 +265,14 @@ class KnowledgeGraphIngestMixin:
                 owner=owner or uploader,
                 workspace_id=workspace_id,
             )
-            self._ingest_structure_nodes(conn, file_id, filename, doc_meta)
+            self._ingest_structure_nodes(
+                conn,
+                file_id,
+                filename,
+                doc_meta,
+                owner=owner or uploader,
+                workspace_id=workspace_id,
+            )
 
             # ── SOURCE 노드 + indexed_from (v3.6.0, source_type 지정 시) ──────
             if source_type:
@@ -274,7 +293,7 @@ class KnowledgeGraphIngestMixin:
 
             # ── Person 노드 + 동사형 엣지 ─────────────────────────────────────
             if uploader:
-                person_id = f"person:{_slug(uploader)}"
+                person_id = _scoped_slug_id("person", uploader, workspace_id)
                 self._upsert_node(
                     conn,
                     person_id,
@@ -289,7 +308,7 @@ class KnowledgeGraphIngestMixin:
 
             # ── Chat 노드와 연결 ──────────────────────────────────────────────
             if conversation_id:
-                conv_id = f"conversation:{_slug(conversation_id)}"
+                conv_id = _scoped_slug_id("conversation", conversation_id, workspace_id)
                 self._upsert_node(
                     conn,
                     conv_id,
@@ -329,7 +348,7 @@ class KnowledgeGraphIngestMixin:
             concept_ids: Dict[str, str] = {}
             for concept in concepts:
                 node_t = _classify_node_type(concept, full_text)
-                cid = f"{node_t.lower()}:{_slug(concept)}"
+                cid = _scoped_slug_id(node_t.lower(), concept, workspace_id)
                 concept_ids[concept.lower()] = cid
                 self._upsert_node(
                     conn,
@@ -403,6 +422,7 @@ class KnowledgeGraphIngestMixin:
         user_nickname: Optional[str] = None,
         source: Optional[str] = None,
         conversation_id: Optional[str] = None,
+        workspace_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         event_type = str(event_type or "Event")
@@ -414,11 +434,12 @@ class KnowledgeGraphIngestMixin:
             "user_nickname": user_nickname,
             "source": source,
             "conversation_id": conversation_id,
+            "workspace_id": workspace_id,
             "metadata": metadata or {},
             "timestamp": _now(),
         }
-        event_id = f"event:{_sha256_text(_json(payload))[:24]}"
-        conv_id = f"conversation:{_slug(conversation_id or 'default')}"
+        event_id = _scoped_hash_id("event", _json(payload), workspace_id)
+        conv_id = _scoped_slug_id("conversation", conversation_id or "default", workspace_id)
         with self._connect() as conn:
             self._upsert_node(
                 conn,
@@ -428,26 +449,32 @@ class KnowledgeGraphIngestMixin:
                 summary=title,
                 metadata=payload,
                 raw=payload,
+                owner=user_email,
+                workspace_id=workspace_id,
             )
             self._upsert_node(
                 conn,
                 conv_id,
                 "Conversation",
                 conversation_id or "Default conversation",
-                metadata={"source": source},
+                metadata={"source": source, "workspace_id": workspace_id},
+                owner=user_email,
+                workspace_id=workspace_id,
             )
             self._upsert_edge(
                 conn, conv_id, event_id, "has_event", metadata={"source": source}
             )
             if user_email or user_nickname:
                 person_key = user_email or user_nickname or "unknown"
-                person_id = f"person:{_slug(person_key)}"
+                person_id = _scoped_slug_id("person", person_key, workspace_id)
                 self._upsert_node(
                     conn,
                     person_id,
                     "Person",
                     user_nickname or user_email or "Unknown user",
-                    metadata={"email": user_email},
+                    metadata={"email": user_email, "workspace_id": workspace_id},
+                    owner=user_email,
+                    workspace_id=workspace_id,
                 )
                 self._upsert_edge(
                     conn,
@@ -599,7 +626,7 @@ class KnowledgeGraphIngestMixin:
             )
             # ── 소유자(Person) + 동사형 엣지 ────────────────────────────────
             if owner:
-                person_id = f"person:{_slug(owner)}"
+                person_id = _scoped_slug_id("person", owner, workspace_id)
                 self._upsert_node(
                     conn,
                     person_id,
@@ -612,7 +639,7 @@ class KnowledgeGraphIngestMixin:
                 self._upsert_edge(conn, person_id, content_id, "업로드함", weight=1.0)
             # ── 대화 연결 ───────────────────────────────────────────────────
             if conversation_id:
-                conv_id = f"conversation:{_slug(conversation_id)}"
+                conv_id = _scoped_slug_id("conversation", conversation_id, workspace_id)
                 self._upsert_node(
                     conn,
                     conv_id,
@@ -649,7 +676,7 @@ class KnowledgeGraphIngestMixin:
             concept_ids: Dict[str, str] = {}
             for concept in concepts:
                 node_t = _classify_node_type(concept, full_text)
-                cid = f"{node_t.lower()}:{_slug(concept)}"
+                cid = _scoped_slug_id(node_t.lower(), concept, workspace_id)
                 concept_ids[concept.lower()] = cid
                 self._upsert_node(
                     conn,

package/lattice_brain/graph/provenance.py

@@ -200,7 +200,10 @@ class KnowledgeGraphProvenanceMixin:
         }
 
     def export_graph_data(
-        self, *, workspace_id: Optional[str] = None
+        self,
+        *,
+        workspace_id: Optional[str] = None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         """Raw, lossless logical export of the graph (nodes/edges/chunks/sources/
         provenance). Vector embeddings are intentionally omitted — they are
@@ -208,10 +211,11 @@ class KnowledgeGraphProvenanceMixin:
         :meth:`backup_database` for a faithful binary copy incl. embeddings.
 
         ``workspace_id`` REALLY filters (v4): the artifact contains only nodes
-        scoped to that workspace plus legacy-global rows (NULL scope, readable
-        machine-wide by definition), with edges/chunks/provenance restricted to
-        the surviving nodes. Pre-v4 this parameter was stamped into the header
-        while the data exported everything — a header that lied.
+        scoped to that workspace, with edges/chunks/provenance restricted to the
+        surviving nodes. Legacy-global rows require the explicit
+        ``include_legacy_global=True`` migration/compatibility opt-in. Pre-v4
+        this parameter was stamped into the header while the data exported
+        everything — a header that lied.
         """
         with self._connect() as conn:
 
@@ -221,10 +225,13 @@ class KnowledgeGraphProvenanceMixin:
                 ]
 
             if workspace_id:
+                scope_sql = "workspace_id = ?"
+                if include_legacy_global:
+                    scope_sql += " OR workspace_id IS NULL"
                 keep_ids = {
                     row["id"]
                     for row in conn.execute(
-                        "SELECT id FROM nodes_v2 WHERE workspace_id = ? OR workspace_id IS NULL",
+                        f"SELECT id FROM nodes_v2 WHERE {scope_sql}",
                         (workspace_id,),
                     ).fetchall()
                 }

package/lattice_brain/graph/retrieval.py

@@ -93,42 +93,67 @@ class KnowledgeGraphRetrievalMixin:
         }
 
     def workspaces_of(self, node_ids) -> Dict[str, Optional[str]]:
-        """Map node ids to their workspace scope (None = legacy-global)."""
+        """Map known node ids to their workspace scope.
+
+        ``None`` is returned only for a row that is explicitly present in the
+        authoritative v2 projection with a NULL workspace.  Missing ids remain
+        missing, and projection/query failures propagate so callers can fail
+        closed instead of mistaking every candidate for legacy-global data.
+        """
         ids = [str(i) for i in node_ids if i]
         if not ids:
             return {}
         placeholders = ",".join("?" for _ in ids)
         with self._connect() as conn:
-            try:
-                return {
-                    row["id"]: row["workspace_id"]
-                    for row in conn.execute(
-                        f"SELECT id, workspace_id FROM nodes_v2 WHERE id IN ({placeholders})",
-                        ids,
-                    ).fetchall()
-                }
-            except Exception:
-                return {}
+            return {
+                row["id"]: row["workspace_id"]
+                for row in conn.execute(
+                    f"SELECT id, workspace_id FROM nodes_v2 WHERE id IN ({placeholders})",
+                    ids,
+                ).fetchall()
+            }
 
-    def filter_scoped_nodes(self, items, allowed_workspaces, *, id_key: str = "id"):
+    def filter_scoped_nodes(
+        self,
+        items,
+        allowed_workspaces,
+        *,
+        id_key: str = "id",
+        include_legacy_global: bool = False,
+    ):
         """Drop items scoped to a workspace the caller is not a member of.
 
         ``allowed_workspaces=None`` means no scoping (single-user / no-auth
-        mode). Legacy-global rows (no workspace) stay visible to everyone on
-        the machine — the documented pre-v4 compatibility behavior.
+        mode). In scoped/multi-user mode, unknown ids are private and
+        legacy-global rows require the explicit ``include_legacy_global=True``
+        compatibility opt-in.
         """
+        candidates = list(items)
         if allowed_workspaces is None:
-            return list(items)
-        allowed = set(allowed_workspaces)
-        scopes = self.workspaces_of([item.get(id_key) for item in items])
-        return [
-            item
-            for item in items
-            if scopes.get(item.get(id_key)) is None
-            or scopes.get(item.get(id_key)) in allowed
-        ]
+            return candidates
+        allowed = {str(workspace_id) for workspace_id in allowed_workspaces if workspace_id}
+        scopes = self.workspaces_of([item.get(id_key) for item in candidates])
+        visible = []
+        for item in candidates:
+            node_id = str(item.get(id_key) or "")
+            if not node_id or node_id not in scopes:
+                # Unknown/unprojected rows are never treated as public.
+                continue
+            workspace_id = scopes[node_id]
+            if workspace_id is None:
+                if include_legacy_global:
+                    visible.append(item)
+            elif str(workspace_id) in allowed:
+                visible.append(item)
+        return visible
 
-    def graph(self, limit: int = 300, *, allowed_workspaces=None) -> Dict[str, Any]:
+    def graph(
+        self,
+        limit: int = 300,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         limit = max(1, min(int(limit or 300), 2000))
         visible = ",".join(f"'{t}'" for t in self._GRAPH_VISIBLE_TYPES)
         nt, et = self._read_tables()
@@ -179,7 +204,11 @@ class KnowledgeGraphRetrievalMixin:
                 ]
 
         if allowed_workspaces is not None:
-            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            nodes = self.filter_scoped_nodes(
+                nodes,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
             kept_ids = {node["id"] for node in nodes}
             edges = [e for e in edges if e["from"] in kept_ids and e["to"] in kept_ids]
 
@@ -264,7 +293,14 @@ class KnowledgeGraphRetrievalMixin:
             node.pop("_raw_importance", None)
         return {"nodes": nodes, "edges": edges}
 
-    def search(self, query: str, limit: int = 30, *, allowed_workspaces=None) -> Dict[str, Any]:
+    def search(
+        self,
+        query: str,
+        limit: int = 30,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         query = str(query or "").strip()
         q = f"%{query}%"
         limit = max(1, min(int(limit or 30), 100))
@@ -368,15 +404,31 @@ class KnowledgeGraphRetrievalMixin:
                 for row in rows
             ]
         if allowed_workspaces is not None:
-            matches = self.filter_scoped_nodes(matches, allowed_workspaces)
+            matches = self.filter_scoped_nodes(
+                matches,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
         return {"query": query, "matches": matches}
 
-    def context_for_query(self, query: str, limit: int = 6, *, allowed_workspaces=None) -> str:
+    def context_for_query(
+        self,
+        query: str,
+        limit: int = 6,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> str:
         """Return compact graph-backed RAG context for chat generation."""
         query = str(query or "").strip()
         if not query:
             return ""
-        matches = self.search(query, limit, allowed_workspaces=allowed_workspaces).get("matches", [])
+        matches = self.search(
+            query,
+            limit,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        ).get("matches", [])
         if not matches:
             topics = _topic_candidates(query, limit=4)
             if topics:
@@ -414,7 +466,11 @@ class KnowledgeGraphRetrievalMixin:
                     if len(matches) >= limit:
                         break
                 if allowed_workspaces is not None:
-                    matches = self.filter_scoped_nodes(matches, allowed_workspaces)
+                    matches = self.filter_scoped_nodes(
+                        matches,
+                        allowed_workspaces,
+                        include_legacy_global=include_legacy_global,
+                    )
         lines = []
         for match in matches[:limit]:
             meta = match.get("metadata") or {}
@@ -431,9 +487,19 @@ class KnowledgeGraphRetrievalMixin:
             )
         return "\n".join(lines)
 
-    def neighbors(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
+    def neighbors(
+        self,
+        node_id: str,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         """Return direct neighbors (1-hop) of a node."""
-        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+        if allowed_workspaces is not None and not self.filter_scoped_nodes(
+            [{"id": node_id}],
+            allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        ):
             raise ValueError(f"graph node not found: {node_id}")
         nt, et = self._read_tables()
         with self._connect() as conn:
@@ -472,7 +538,11 @@ class KnowledgeGraphRetrievalMixin:
                     )
                 ]
         if allowed_workspaces is not None:
-            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            nodes = self.filter_scoped_nodes(
+                nodes,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
             kept = {node.get("id") for node in nodes}
             edges = [
                 edge for edge in edges
@@ -481,7 +551,13 @@ class KnowledgeGraphRetrievalMixin:
             ]
         return {"node_id": node_id, "neighbors": nodes, "edges": edges}
 
-    def get_node(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
+    def get_node(
+        self,
+        node_id: str,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
@@ -510,7 +586,11 @@ class KnowledgeGraphRetrievalMixin:
             "updated_at": row["updated_at"],
             "degree": degree,
         }
-        if allowed_workspaces is not None and not self.filter_scoped_nodes([node], allowed_workspaces):
+        if allowed_workspaces is not None and not self.filter_scoped_nodes(
+            [node],
+            allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        ):
             raise ValueError(f"graph node not found: {node_id}")
         return node
 
@@ -522,6 +602,7 @@ class KnowledgeGraphRetrievalMixin:
         relationship_type: str = "",
         limit: int = 30,
         allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         query = str(query or "").strip()
         node_id = str(node_id or "").strip()
@@ -591,7 +672,13 @@ class KnowledgeGraphRetrievalMixin:
                     {"id": (rel.get("source") or {}).get("id")},
                     {"id": (rel.get("target") or {}).get("id")},
                 ]
-                if len(self.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                if len(
+                    self.filter_scoped_nodes(
+                        endpoints,
+                        allowed_workspaces,
+                        include_legacy_global=include_legacy_global,
+                    )
+                ) == 2:
                     kept.append(rel)
             relationships = kept
         return {
@@ -602,12 +689,22 @@ class KnowledgeGraphRetrievalMixin:
         }
 
     def traverse(
-        self, node_id: str, *, depth: int = 1, limit: int = 100, allowed_workspaces=None
+        self,
+        node_id: str,
+        *,
+        depth: int = 1,
+        limit: int = 100,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
-        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+        if allowed_workspaces is not None and not self.filter_scoped_nodes(
+            [{"id": node_id}],
+            allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        ):
             raise ValueError(f"graph node not found: {node_id}")
         depth = max(0, min(int(depth or 1), 4))
         limit = max(1, min(int(limit or 100), 500))
@@ -668,7 +765,11 @@ class KnowledgeGraphRetrievalMixin:
             ]
         edges = list(edges_by_id.values())
         if allowed_workspaces is not None:
-            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            nodes = self.filter_scoped_nodes(
+                nodes,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
             kept = {node.get("id") for node in nodes}
             edges = [edge for edge in edges if edge.get("from") in kept and edge.get("to") in kept]
         return {"root": node_id, "depth": depth, "nodes": nodes, "edges": edges}

package/lattice_brain/graph/retrieval_docgen.py

@@ -12,7 +12,12 @@ class KnowledgeGraphDocGenMixin:
     """
 
     def search_for_document_generation(
-        self, query: str, limit: int = 10
+        self,
+        query: str,
+        limit: int = 10,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> List[Dict[str, Any]]:
         """Hybrid retrieval optimized for document generation.
 
@@ -112,7 +117,7 @@ class KnowledgeGraphDocGenMixin:
                 neighbor_concepts = []
                 neighbor_rows = conn.execute(
                     f"""
-                        SELECT n.title, n.type FROM {et} e
+                        SELECT n.id, n.title, n.type FROM {et} e
                         JOIN {nt} n ON n.id = CASE WHEN e.from_node = ? THEN e.to_node ELSE e.from_node END
                         WHERE (e.from_node = ? OR e.to_node = ?)
                           AND n.type IN ('Concept', 'Feature', 'Decision', 'Task')
@@ -121,7 +126,7 @@ class KnowledgeGraphDocGenMixin:
                     (row["id"], row["id"], row["id"]),
                 ).fetchall()
                 for nr in neighbor_rows:
-                    neighbor_concepts.append({"title": nr["title"], "type": nr["type"]})
+                    neighbor_concepts.append({"id": nr["id"], "title": nr["title"], "type": nr["type"]})
 
                 scored_results.append(
                     {
@@ -141,11 +146,28 @@ class KnowledgeGraphDocGenMixin:
                     }
                 )
 
+            if allowed_workspaces is not None:
+                scored_results = self.filter_scoped_nodes(
+                    scored_results,
+                    allowed_workspaces,
+                    include_legacy_global=include_legacy_global,
+                )
+                for item in scored_results:
+                    item["related_concepts"] = self.filter_scoped_nodes(
+                        item.get("related_concepts", []),
+                        allowed_workspaces,
+                        include_legacy_global=include_legacy_global,
+                    )
             scored_results.sort(key=lambda x: x["hybrid_score"], reverse=True)
             return scored_results[:limit]
 
     def multi_hop_context(
-        self, node_ids: List[str], max_hops: int = 2
+        self,
+        node_ids: List[str],
+        max_hops: int = 2,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         """Multi-hop graph traversal from seed nodes for richer context."""
         visited_nodes = set()
@@ -207,4 +229,15 @@ class KnowledgeGraphDocGenMixin:
                                 next_frontier.add(other)
                 frontier = next_frontier
 
+        if allowed_workspaces is not None:
+            all_nodes = self.filter_scoped_nodes(
+                all_nodes,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
+            visible_ids = {node.get("id") for node in all_nodes}
+            all_edges = [
+                edge for edge in all_edges
+                if edge.get("from") in visible_ids and edge.get("to") in visible_ids
+            ]
         return {"nodes": all_nodes, "edges": all_edges}

package/lattice_brain/ingestion.py

@@ -21,11 +21,11 @@ from __future__ import annotations
 
 import hashlib
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from .runtime.hooks import dispatch_tool
+from .utils import utc_now_iso
 
 # Source types that arrive as a file on disk (read via ingest_document).
 FILE_SOURCE_TYPES = frozenset({"file", "local_file", "upload", "pdf"})
@@ -46,10 +46,6 @@ _MEMORY_NODE_TYPES = {"decision": "Decision", "experience": "Experience", "works
 DEFAULT_MAX_TEXT_BYTES = 5 * 1024 * 1024  # 5 MB of extracted text per item
 
 
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
 # --- Large candidate 1 slice: incremental / background ingestion support ---
 @dataclass
 class BackgroundIngestionJob:
@@ -57,7 +53,7 @@ class BackgroundIngestionJob:
     job_id: str
     items: List[IngestionItem]
     status: str = "pending"  # pending | running | done | failed
-    created_at: str = field(default_factory=_now_iso)
+    created_at: str = field(default_factory=utc_now_iso)
     processed: int = 0
     total: int = 0
     errors: List[str] = field(default_factory=list)
@@ -188,7 +184,7 @@ class IngestionPipeline:
                 detail="Knowledge Graph is disabled (LATTICEAI_ENABLE_GRAPH).",
             )
 
-        captured_at = item.captured_at or _now_iso()
+        captured_at = item.captured_at or utc_now_iso()
         owner = item.owner or user_email
         tool_name = f"kg_ingest.{source_type}"
         # Only the keys are read by the hook payload, so this dict is safe/cheap.
@@ -366,6 +362,7 @@ class IngestionPipeline:
             user_email=owner,
             source=meta.get("source") or source_type,
             conversation_id=item.conversation_id,
+            workspace_id=item.workspace_id,
             metadata={**meta, "detail": (item.text or "")[:2000]},
         )
         result.setdefault("node_id", result.get("node_id") or result.get("id"))