ltcai 3.5.0 → 4.0.0

package/knowledge_graph.py

@@ -942,6 +942,31 @@ class KnowledgeGraphStore:
                   error_message TEXT,
                   metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json))
                 );
+                -- v3.6.0 Knowledge Graph First: per-ingestion provenance trail.
+                -- Append-only audit of where every graph node came from, when it
+                -- was captured, how it was processed, and whether it was embedded /
+                -- linked / used by an agent. get_provenance() returns the latest row.
+                CREATE TABLE IF NOT EXISTS ingestion_provenance (
+                  id TEXT PRIMARY KEY,
+                  node_id TEXT NOT NULL,
+                  source_type TEXT NOT NULL,
+                  source_uri TEXT,
+                  content_hash TEXT,
+                  title TEXT,
+                  pipeline TEXT NOT NULL,
+                  owner TEXT,
+                  workspace_id TEXT,
+                  captured_at TEXT,
+                  modified_at TEXT,
+                  embedded INTEGER NOT NULL DEFAULT 0,
+                  linked INTEGER NOT NULL DEFAULT 0,
+                  duplicate INTEGER NOT NULL DEFAULT 0,
+                  agent_used TEXT,
+                  chunk_count INTEGER NOT NULL DEFAULT 0,
+                  permissions_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(permissions_json)),
+                  metadata_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(metadata_json)),
+                  created_at TEXT NOT NULL
+                );
                 CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
                 CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_node);
                 CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_node);
@@ -954,6 +979,10 @@ class KnowledgeGraphStore:
                 CREATE INDEX IF NOT EXISTS idx_vector_embeddings_source ON vector_embeddings(source_node);
                 CREATE INDEX IF NOT EXISTS idx_vector_embeddings_model ON vector_embeddings(embedding_model);
                 CREATE INDEX IF NOT EXISTS idx_vector_index_operations_requested ON vector_index_operations(requested_at);
+                CREATE INDEX IF NOT EXISTS idx_provenance_node ON ingestion_provenance(node_id);
+                CREATE INDEX IF NOT EXISTS idx_provenance_source_type ON ingestion_provenance(source_type);
+                CREATE INDEX IF NOT EXISTS idx_provenance_hash ON ingestion_provenance(content_hash);
+                CREATE INDEX IF NOT EXISTS idx_provenance_created ON ingestion_provenance(created_at);
                 """
             )
             conn.execute(
@@ -961,6 +990,62 @@ class KnowledgeGraphStore:
                 ("schema_version", str(GRAPH_SCHEMA_VERSION)),
             )
         self._init_v2_schema()
+        self._init_fts()
+
+    # ── FTS5 keyword index (v4) ──────────────────────────────────────────
+    # Replaces LIKE '%q%' table scans for keyword search. The trigram
+    # tokenizer is required (not just FTS5): unicode61 indexes whole tokens
+    # and would silently break Korean substring recall ('프로젝트' must match
+    # '프로젝트를'). Without trigram support the store honestly reports
+    # fts_enabled=False and the LIKE path remains authoritative.
+    _FTS_SQL = """
+    CREATE VIRTUAL TABLE IF NOT EXISTS node_fts USING fts5(
+      node_id UNINDEXED, title, summary, metadata, tokenize='trigram'
+    );
+    CREATE TRIGGER IF NOT EXISTS node_fts_ai AFTER INSERT ON nodes BEGIN
+      INSERT INTO node_fts(node_id, title, summary, metadata)
+      VALUES (new.id, new.title, COALESCE(new.summary, ''), new.metadata_json);
+    END;
+    CREATE TRIGGER IF NOT EXISTS node_fts_au AFTER UPDATE ON nodes BEGIN
+      DELETE FROM node_fts WHERE node_id = old.id;
+      INSERT INTO node_fts(node_id, title, summary, metadata)
+      VALUES (new.id, new.title, COALESCE(new.summary, ''), new.metadata_json);
+    END;
+    CREATE TRIGGER IF NOT EXISTS node_fts_ad AFTER DELETE ON nodes BEGIN
+      DELETE FROM node_fts WHERE node_id = old.id;
+    END;
+    """
+
+    def _init_fts(self) -> None:
+        self._fts_enabled = False
+        try:
+            with self._connect() as conn:
+                conn.executescript(self._FTS_SQL)
+                fts_count = conn.execute("SELECT count(*) AS c FROM node_fts").fetchone()["c"]
+                if fts_count == 0:
+                    conn.execute(
+                        "INSERT INTO node_fts(node_id, title, summary, metadata) "
+                        "SELECT id, title, COALESCE(summary, ''), metadata_json FROM nodes"
+                    )
+            self._fts_enabled = True
+        except sqlite3.OperationalError as exc:
+            # FTS5/trigram not compiled into this SQLite build. LIKE search
+            # stays authoritative; the capability is reported, never faked.
+            logging.info("FTS5 trigram index unavailable (%s); keyword search uses LIKE scans.", exc)
+
+    def _fts_match_ids(self, conn: sqlite3.Connection, query: str, limit: int) -> List[str]:
+        """Ranked node ids for a trigram FTS query ('' on any failure)."""
+        if not getattr(self, "_fts_enabled", False) or len(query) < 3:
+            return []
+        escaped = query.replace('"', '""')
+        try:
+            rows = conn.execute(
+                'SELECT node_id FROM node_fts WHERE node_fts MATCH ? ORDER BY rank LIMIT ?',
+                (f'"{escaped}"', limit),
+            ).fetchall()
+        except sqlite3.OperationalError:
+            return []
+        return [row["node_id"] for row in rows]
 
     # SQL views that reconstruct the *exact* legacy row shape on top of the
     # normalized v2 tables, so the read methods run unchanged against either
@@ -1099,26 +1184,40 @@ class KnowledgeGraphStore:
         self, conn: sqlite3.Connection, node_id: str, node_type: str, title: str,
         summary: Optional[str], metadata_json: Optional[str],
         *, created_at: Optional[str] = None, updated_at: Optional[str] = None,
+        owner: Optional[str] = None, workspace_id: Optional[str] = None,
+        visibility: Optional[str] = None,
     ) -> None:
         if KGStoreV2 is None:
             return
         ts = updated_at or _now()
         norm_type = NodeType.from_legacy(node_type).value if NodeType is not None else node_type
+        # Scope resolution: explicit param > metadata hints > legacy-global.
+        # 'legacy' (not 'private') marks unscoped rows — the column default
+        # must never silently privatize previously machine-shared data.
+        meta = _safe_loads(metadata_json) if metadata_json else {}
+        owner = owner or meta.get("user_email") or meta.get("owner") or None
+        workspace_id = workspace_id or meta.get("workspace_id") or None
+        visibility = visibility or ("legacy" if workspace_id is None else "workspace")
         try:
             conn.execute(
                 """
                 INSERT INTO nodes_v2(id, type, legacy_type, label, summary, attrs,
-                                     owner_id, visibility, created_at, updated_at,
-                                     importance_score)
-                VALUES (?, ?, ?, ?, ?, ?, NULL, 'private', ?, ?, 0.0)
+                                     owner_id, workspace_id, visibility,
+                                     created_at, updated_at, importance_score)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0.0)
                 ON CONFLICT(id) DO UPDATE SET
                   type=excluded.type, legacy_type=excluded.legacy_type,
                   label=excluded.label, summary=excluded.summary,
-                  attrs=excluded.attrs, updated_at=excluded.updated_at
+                  attrs=excluded.attrs, updated_at=excluded.updated_at,
+                  owner_id=COALESCE(excluded.owner_id, nodes_v2.owner_id),
+                  workspace_id=COALESCE(excluded.workspace_id, nodes_v2.workspace_id),
+                  visibility=CASE WHEN excluded.visibility != 'legacy'
+                                  THEN excluded.visibility
+                                  ELSE nodes_v2.visibility END
                 """,
                 (node_id, norm_type, node_type, title, summary,
                  metadata_json if metadata_json is not None else "{}",
-                 created_at or ts, ts),
+                 owner, workspace_id, visibility, created_at or ts, ts),
             )
         except Exception as ex:
             logging.debug("knowledge_graph: v2 node projection skipped (%s): %s", node_id, ex)
@@ -1140,8 +1239,7 @@ class KnowledgeGraphStore:
                 INSERT INTO edges_v2(id, source, target, type, legacy_type, weight,
                                      confidence, evidence, metadata, created_by, created_at)
                 VALUES (?, ?, ?, ?, ?, ?, ?, '[]', ?, 'legacy', ?)
-                ON CONFLICT(source, target, legacy_type) DO UPDATE SET
-                  type=excluded.type,
+                ON CONFLICT(source, target, type, legacy_type) DO UPDATE SET
                   weight=max(edges_v2.weight, excluded.weight),
                   confidence=excluded.confidence,
                   metadata=excluded.metadata
@@ -1149,9 +1247,125 @@ class KnowledgeGraphStore:
                 (eid, from_node, to_node, norm_type, edge_type, float(weight),
                  confidence, meta_str, created_at or _now()),
             )
+            # Temporal record: every observation of this relationship is kept
+            # (the UNIQUE upsert + weight=max alone would erase recurrence).
+            row = conn.execute(
+                "SELECT id FROM edges_v2 WHERE source=? AND target=? AND type=? AND legacy_type=?",
+                (from_node, to_node, norm_type, edge_type),
+            ).fetchone()
+            if row is not None:
+                conn.execute(
+                    "INSERT INTO edge_occurrences(edge_id, observed_at, weight, source) VALUES (?, ?, ?, ?)",
+                    (row["id"], created_at or _now(), float(weight),
+                     _safe_loads(meta_str).get("source")),
+                )
         except Exception as ex:
             logging.debug("knowledge_graph: v2 edge projection skipped (%s->%s): %s", from_node, to_node, ex)
 
+    def curate(self, *, max_documents: int = 200, max_new_nodes: int = 8) -> Dict[str, Any]:
+        """On-demand graph curation (T4.4 — graph_curator goes live).
+
+        Runs the curator's gated topic-promotion pipeline over recent content
+        nodes: candidates are clustered, secret-bearing labels are refused,
+        and only multi-source topics above the importance threshold become
+        Topic nodes (with MENTIONS edges back to their sources and a real
+        importance_score in nodes_v2). Explicit and observable — the result
+        reports everything promoted AND everything skipped, with reasons.
+        """
+        from latticeai.core.graph_curator import auto_build_graph_overlay
+
+        content_types = (
+            "Document", "File", "CodeFile", "Message", "AIResponse",
+            "Chat", "Page", "Slide", "Spreadsheet",
+        )
+        nt, _ = self._read_tables()
+        with self._connect() as conn:
+            placeholders = ",".join("?" for _ in content_types)
+            rows = conn.execute(
+                f"""
+                SELECT id, type, title, summary FROM {nt}
+                WHERE type IN ({placeholders})
+                ORDER BY updated_at DESC, id ASC LIMIT ?
+                """,
+                (*content_types, max(1, min(int(max_documents), 2000))),
+            ).fetchall()
+            existing_labels = {
+                str(row["title"] or "").strip().lower()
+                for row in conn.execute(
+                    f"SELECT title FROM {nt} WHERE type IN ('Topic', 'Concept')"
+                ).fetchall()
+            }
+        documents = [
+            {
+                "id": row["id"],
+                "text": f"{row['title']} {row['summary'] or ''}",
+                "kind": "file" if row["type"] in {"Document", "File", "CodeFile", "Spreadsheet"} else "chat",
+            }
+            for row in rows
+        ]
+        overlay = auto_build_graph_overlay(
+            documents,
+            existing_node_labels=existing_labels,
+            max_new_nodes=max(1, min(int(max_new_nodes), 50)),
+        )
+        promoted: List[Dict[str, Any]] = []
+        with self._connect() as conn:
+            valid_ids = {row["id"] for row in rows}
+            for promo in overlay["promotions"]:
+                topic_id = f"topic:{_slug(promo['label'])}"
+                self._upsert_node(
+                    conn, topic_id, "Topic", promo["label"],
+                    metadata={
+                        "curated": True,
+                        "importance": promo["importance"],
+                        "aliases": promo["aliases"],
+                        "source": "graph_curator",
+                    },
+                )
+                conn.execute(
+                    "UPDATE nodes_v2 SET importance_score=? WHERE id=?",
+                    (float(promo["importance"]), topic_id),
+                )
+                linked = 0
+                for source_id in promo["sources"][:10]:
+                    if source_id in valid_ids:
+                        self._upsert_edge(
+                            conn, source_id, topic_id, "MENTIONS",
+                            weight=0.6, metadata={"source": "graph_curator"},
+                        )
+                        linked += 1
+                promoted.append({
+                    "node_id": topic_id,
+                    "label": promo["label"],
+                    "importance": promo["importance"],
+                    "linked_sources": linked,
+                })
+        return {
+            "status": "ok",
+            "documents_scanned": len(documents),
+            "candidates_total": overlay["candidates_total"],
+            "promoted": promoted,
+            "skipped": overlay["skipped"][:50],
+            "skipped_total": len(overlay["skipped"]),
+        }
+
+    def mark_superseded(self, old_node_id: str, new_node_id: str) -> Dict[str, Any]:
+        """Record that ``old_node_id`` was replaced by ``new_node_id``.
+
+        The old node stays queryable (knowledge is durable); readers can follow
+        the revision chain via ``nodes_v2.superseded_by``.
+        """
+        with self._connect() as conn:
+            for node_id in (old_node_id, new_node_id):
+                exists = conn.execute("SELECT 1 FROM nodes_v2 WHERE id=?", (node_id,)).fetchone()
+                if not exists:
+                    raise FileNotFoundError(node_id)
+            conn.execute(
+                "UPDATE nodes_v2 SET superseded_by=?, updated_at=? WHERE id=?",
+                (new_node_id, _now(), old_node_id),
+            )
+        return {"status": "ok", "node_id": old_node_id, "superseded_by": new_node_id}
+
     def _v2_delete_nodes(self, conn: sqlite3.Connection, ids) -> None:
         """Mirror legacy node deletions into v2 (edges_v2 cascade on the FK)."""
         if KGStoreV2 is None:
@@ -1212,6 +1426,9 @@ class KnowledgeGraphStore:
         summary: str = "",
         metadata: Optional[Dict[str, Any]] = None,
         raw: Optional[Dict[str, Any]] = None,
+        owner: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        visibility: Optional[str] = None,
     ) -> str:
         now = _now()
         # Canonical stored values, computed once and shared with the v2
@@ -1234,7 +1451,8 @@ class KnowledgeGraphStore:
         )
         # dual-write: project into the v2 graph on the same transaction
         self._v2_project_node(conn, node_id, node_type, title_s, summary_s, meta_json,
-                              created_at=now, updated_at=now)
+                              created_at=now, updated_at=now,
+                              owner=owner, workspace_id=workspace_id, visibility=visibility)
         if node_type != "Chunk":
             self._upsert_vector_item(
                 conn,
@@ -1255,6 +1473,16 @@ class KnowledgeGraphStore:
         weight: float = 1.0,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> str:
+        # v4 write door: every new edge stores the canonical EdgeType value —
+        # free-string types (e.g. '포함함', '언급함') are normalized here, so no
+        # caller can mint new legacy taxonomy. The original label survives in
+        # metadata.legacy_label for traceability.
+        if EdgeType is not None:
+            canonical = EdgeType.from_legacy(edge_type).value
+            if canonical != edge_type:
+                metadata = dict(metadata or {})
+                metadata.setdefault("legacy_label", edge_type)
+            edge_type = canonical
         edge_id = f"edge:{_sha256_text(f'{from_node}|{edge_type}|{to_node}')[:24]}"
         now = _now()
         meta_json = _json(metadata)   # canonical string shared with the projection
@@ -2703,12 +2931,20 @@ class KnowledgeGraphStore:
         uploader: Optional[str] = None,
         conversation_id: Optional[str] = None,
         extracted: Optional[Dict[str, Any]] = None,
+        source_type: Optional[str] = None,
+        source_uri: Optional[str] = None,
+        captured_at: Optional[str] = None,
+        modified_at: Optional[str] = None,
+        owner: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        permissions: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         path = Path(path)
         data = path.read_bytes()
         digest = _sha256_bytes(data)
         ext = path.suffix.lower()
         filename = original_filename or path.name
+        captured_at = captured_at or _now()
         blob_path = self.blob_dir / digest[:2] / f"{digest}{ext}"
         blob_path.parent.mkdir(parents=True, exist_ok=True)
         if not blob_path.exists():
@@ -2723,8 +2959,16 @@ class KnowledgeGraphStore:
             "mime_type": mime_type,
             "bytes": len(data),
             "sha256": digest,
+            "content_hash": digest,
             "blob_path": str(blob_path),
             "uploader": uploader,
+            "owner": owner or uploader,
+            "workspace_id": workspace_id,
+            "permissions": permissions or {},
+            "source_type": source_type or "file",
+            "source_uri": source_uri or str(path),
+            "captured_at": captured_at,
+            "modified_at": modified_at,
             "conversation_id": conversation_id,
             "extracted": {k: v for k, v in (extracted or {}).items() if k != "content"},
             "structure": doc_meta,
@@ -2732,8 +2976,11 @@ class KnowledgeGraphStore:
         full_text = f"{filename}\n{text}"
         concepts = _extract_concepts(full_text, limit=15)
         triples  = _extract_triples(full_text, concepts)
+        chunk_ids: List[str] = []
+        source_node_id: Optional[str] = None
 
         with self._connect() as conn:
+            duplicate = self._node_exists(conn, file_id)
             # ── Document 노드  (점: 명사 — 파일) ────────────────────────────────
             self._upsert_node(
                 conn, file_id, "Document", filename,
@@ -2742,6 +2989,15 @@ class KnowledgeGraphStore:
             )
             self._ingest_structure_nodes(conn, file_id, filename, doc_meta)
 
+            # ── SOURCE 노드 + indexed_from (v3.6.0, source_type 지정 시) ──────
+            if source_type:
+                source_node_id = self._attach_source_node(
+                    conn, file_id,
+                    source_type=source_type, source_uri=source_uri or str(path),
+                    title=filename, content_hash=digest, captured_at=captured_at,
+                    extra={"owner": owner or uploader, "workspace_id": workspace_id, "ext": ext},
+                )
+
             # ── Person 노드 + 동사형 엣지 ─────────────────────────────────────
             if uploader:
                 person_id = f"person:{_slug(uploader)}"
@@ -2762,6 +3018,7 @@ class KnowledgeGraphStore:
             # ── RAG chunks (검색용, 그래프 비표시) ────────────────────────────
             for index, chunk in enumerate(_chunks(text)):
                 chunk_id = f"chunk:{_sha256_text(f'{file_id}:{index}:{chunk}')[:24]}"
+                chunk_ids.append(chunk_id)
                 self._upsert_node(
                     conn, chunk_id, "Chunk",
                     f"{filename} chunk {index + 1}",
@@ -2816,7 +3073,18 @@ class KnowledgeGraphStore:
                 # 선: Document가 Task/Decision을 "포함함"
                 self._upsert_edge(conn, file_id, sem_id, "포함함", weight=0.9)
 
-        return {"node_id": file_id, "sha256": digest, "metadata": metadata}
+        return {
+            "node_id": file_id,
+            "type": "Document",
+            "sha256": digest,
+            "content_hash": digest,
+            "source_node_id": source_node_id,
+            "chunk_ids": chunk_ids,
+            "chunk_count": len(chunk_ids),
+            "duplicate": duplicate,
+            "captured_at": captured_at,
+            "metadata": metadata,
+        }
 
     def ingest_event(
         self,
@@ -2854,6 +3122,513 @@ class KnowledgeGraphStore:
                 self._upsert_edge(conn, person_id, event_id, "triggered", metadata={"event_type": event_type})
         return {"node_id": event_id, "type": event_type}
 
+    # ── v3.6.0 Knowledge Graph First: unified source ingestion + provenance ──────
+    def _node_exists(self, conn: sqlite3.Connection, node_id: str) -> bool:
+        row = conn.execute("SELECT 1 FROM nodes WHERE id = ?", (node_id,)).fetchone()
+        return row is not None
+
+    def node_is_embedded(self, node_id: str) -> bool:
+        """True when a vector embedding exists for ``node_id`` (RAG-ready)."""
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT 1 FROM vector_embeddings WHERE item_id = ? LIMIT 1",
+                (node_id,),
+            ).fetchone()
+            return row is not None
+
+    def _attach_source_node(
+        self,
+        conn: sqlite3.Connection,
+        content_node_id: str,
+        *,
+        source_type: str,
+        source_uri: Optional[str] = None,
+        title: Optional[str] = None,
+        content_hash: Optional[str] = None,
+        captured_at: Optional[str] = None,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Create the SOURCE node for an ingested item and link it via INDEXED_FROM.
+
+        Every ingested content node points at exactly one SOURCE node, so the
+        graph is always able to explain *where* a node came from. The source id
+        is derived from (source_type, source_uri | content_hash) so re-ingesting
+        the same origin reuses the same SOURCE node (idempotent).
+        """
+        key = source_uri or content_hash or content_node_id
+        source_id = f"source:{_sha256_text(f'{source_type}|{key}')[:24]}"
+        meta = {
+            "source_type": source_type,
+            "source_uri": source_uri,
+            "content_hash": content_hash,
+            "captured_at": captured_at or _now(),
+            **(extra or {}),
+        }
+        label = title or source_uri or source_type
+        self._upsert_node(
+            conn, source_id, "Source", label,
+            summary=str(source_uri or title or source_type)[:400],
+            metadata=meta,
+        )
+        # 선: 콘텐츠 노드가 "이 출처에서 색인됨" (indexed_from → SOURCE)
+        self._upsert_edge(conn, content_node_id, source_id, "indexed_from",
+                          weight=1.0, metadata={"source_type": source_type})
+        return source_id
+
+    def ingest_source(
+        self,
+        *,
+        source_type: str,
+        title: str,
+        text: str,
+        source_uri: Optional[str] = None,
+        owner: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        permissions: Optional[Dict[str, Any]] = None,
+        captured_at: Optional[str] = None,
+        modified_at: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Unified text/web ingestion: one shape for URL, browser tab, note, text.
+
+        Creates a content ``Document`` node (idempotent by content hash), a
+        ``Source`` node linked via ``indexed_from``, RAG chunks, and extracted
+        Concept/Task/Decision nodes — mirroring ingest_document for non-file
+        sources. Returns the full set of ids the caller needs to record
+        provenance, including ``duplicate`` (was the content already indexed).
+        """
+        source_type = str(source_type or "text")
+        text = str(text or "")
+        title = _clean_text(str(title or source_uri or source_type))[:240] or source_type
+        captured_at = captured_at or _now()
+        content_hash = _sha256_text(f"{source_type}|{source_uri or ''}|{text}")
+        content_id = f"webdoc:{content_hash[:24]}"
+        full_text = f"{title}\n{text}"
+        node_meta = {
+            "source_type": source_type,
+            "source_uri": source_uri,
+            "content_hash": content_hash,
+            "title": title,
+            "captured_at": captured_at,
+            "modified_at": modified_at,
+            "owner": owner,
+            "workspace_id": workspace_id,
+            "permissions": permissions or {},
+            "chars": len(text),
+            **(metadata or {}),
+        }
+        concepts = _extract_concepts(full_text, limit=15)
+        triples = _extract_triples(full_text, concepts)
+        chunk_ids: List[str] = []
+
+        with self._connect() as conn:
+            duplicate = self._node_exists(conn, content_id)
+            # ── 콘텐츠 노드 (점: 명사 — 문서) ────────────────────────────────
+            self._upsert_node(
+                conn, content_id, "Document", title,
+                summary=(text or title)[:500],
+                metadata=node_meta, raw=node_meta,
+            )
+            # ── SOURCE 노드 + indexed_from 엣지 (출처 추적) ──────────────────
+            source_node_id = self._attach_source_node(
+                conn, content_id,
+                source_type=source_type, source_uri=source_uri, title=title,
+                content_hash=content_hash, captured_at=captured_at,
+                extra={"owner": owner, "workspace_id": workspace_id},
+            )
+            # ── 소유자(Person) + 동사형 엣지 ────────────────────────────────
+            if owner:
+                person_id = f"person:{_slug(owner)}"
+                self._upsert_node(conn, person_id, "Person", owner, metadata={"email": owner})
+                self._upsert_edge(conn, person_id, content_id, "업로드함", weight=1.0)
+            # ── 대화 연결 ───────────────────────────────────────────────────
+            if conversation_id:
+                conv_id = f"conversation:{_slug(conversation_id)}"
+                self._upsert_node(conn, conv_id, "Chat", conversation_id)
+                self._upsert_edge(conn, conv_id, content_id, "언급함", weight=0.8)
+            # ── RAG 청크 ────────────────────────────────────────────────────
+            for index, chunk in enumerate(_chunks(text)):
+                chunk_id = f"chunk:{_sha256_text(f'{content_id}:{index}:{chunk}')[:24]}"
+                chunk_ids.append(chunk_id)
+                self._upsert_node(
+                    conn, chunk_id, "Chunk", f"{title} chunk {index + 1}",
+                    summary=chunk[:500], metadata={"index": index, "source_node": content_id},
+                )
+                self._upsert_chunk(conn, chunk_id=chunk_id, source_node=content_id,
+                                   text=chunk, metadata={"index": index, "source_node": content_id})
+                self._upsert_edge(conn, content_id, chunk_id, "포함함")
+            # ── Concept / Feature / Error / Code 노드 + 엣지 ────────────────
+            concept_ids: Dict[str, str] = {}
+            for concept in concepts:
+                node_t = _classify_node_type(concept, full_text)
+                cid = f"{node_t.lower()}:{_slug(concept)}"
+                concept_ids[concept.lower()] = cid
+                self._upsert_node(conn, cid, node_t, concept,
+                                  metadata={"auto_extracted": True, "source_type": source_type})
+                self._upsert_edge(conn, content_id, cid, "포함함", weight=0.8)
+            for triple in triples:
+                subj_id = concept_ids.get(triple["subject"].lower())
+                obj_id = concept_ids.get(triple["object"].lower())
+                if subj_id and obj_id and subj_id != obj_id:
+                    self._upsert_edge(conn, subj_id, obj_id, triple["relation"],
+                                      weight=1.0, metadata={"context": triple.get("context", "")[:240]})
+            # ── Task / Decision 노드 ────────────────────────────────────────
+            for item in _semantic_items(text):
+                sem_type = item["type"]
+                sem_title = item["title"]
+                sem_id = f"{sem_type.lower()}:{_sha256_text(f'{content_id}:{sem_type}:{sem_title}')[:24]}"
+                self._upsert_node(conn, sem_id, sem_type, sem_title, summary=item["summary"],
+                                  metadata={"auto_extracted": True, "source_node": content_id}, raw=item)
+                self._upsert_edge(conn, content_id, sem_id, "포함함", weight=0.9)
+
+        return {
+            "node_id": content_id,
+            "type": "Document",
+            "source_node_id": source_node_id,
+            "content_hash": content_hash,
+            "chunk_ids": chunk_ids,
+            "chunk_count": len(chunk_ids),
+            "duplicate": duplicate,
+            "captured_at": captured_at,
+        }
+
+    def record_provenance(
+        self,
+        *,
+        node_id: str,
+        source_type: str,
+        pipeline: str = "unified-ingestion",
+        source_uri: Optional[str] = None,
+        content_hash: Optional[str] = None,
+        title: Optional[str] = None,
+        owner: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        captured_at: Optional[str] = None,
+        modified_at: Optional[str] = None,
+        embedded: bool = False,
+        linked: bool = False,
+        duplicate: bool = False,
+        agent_used: Optional[str] = None,
+        chunk_count: int = 0,
+        permissions: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Append a provenance record for an ingested node (audit trail)."""
+        now = _now()
+        prov_basis = f"{node_id}|{content_hash or ''}|{now}"
+        prov_id = f"prov:{_sha256_text(prov_basis)[:24]}"
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO ingestion_provenance(
+                  id, node_id, source_type, source_uri, content_hash, title, pipeline,
+                  owner, workspace_id, captured_at, modified_at, embedded, linked,
+                  duplicate, agent_used, chunk_count, permissions_json, metadata_json, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    prov_id, node_id, source_type, source_uri, content_hash, title, pipeline,
+                    owner, workspace_id, captured_at, modified_at, 1 if embedded else 0,
+                    1 if linked else 0, 1 if duplicate else 0, agent_used, int(chunk_count or 0),
+                    _json(permissions or {}), _json(metadata or {}), now,
+                ),
+            )
+        return {"id": prov_id, "node_id": node_id, "created_at": now}
+
+    @staticmethod
+    def _provenance_row(row: sqlite3.Row) -> Dict[str, Any]:
+        return {
+            "id": row["id"],
+            "node_id": row["node_id"],
+            "source_type": row["source_type"],
+            "source_uri": row["source_uri"],
+            "content_hash": row["content_hash"],
+            "title": row["title"],
+            "pipeline": row["pipeline"],
+            "owner": row["owner"],
+            "workspace_id": row["workspace_id"],
+            "captured_at": row["captured_at"],
+            "modified_at": row["modified_at"],
+            "embedded": bool(row["embedded"]),
+            "linked": bool(row["linked"]),
+            "duplicate": bool(row["duplicate"]),
+            "agent_used": row["agent_used"],
+            "chunk_count": row["chunk_count"],
+            "permissions": _safe_loads(row["permissions_json"]),
+            "metadata": _safe_loads(row["metadata_json"]),
+            "created_at": row["created_at"],
+        }
+
+    def get_provenance(self, node_id: str) -> Optional[Dict[str, Any]]:
+        """Return the most recent provenance record for a node, or None."""
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT * FROM ingestion_provenance WHERE node_id = ? "
+                "ORDER BY created_at DESC, rowid DESC LIMIT 1",
+                (node_id,),
+            ).fetchone()
+            return self._provenance_row(row) if row else None
+
+    def list_provenance(self, *, limit: int = 100, source_type: Optional[str] = None) -> Dict[str, Any]:
+        """Recent provenance records (newest first), optionally by source_type."""
+        limit = max(1, min(int(limit or 100), 1000))
+        with self._connect() as conn:
+            if source_type:
+                rows = conn.execute(
+                    "SELECT * FROM ingestion_provenance WHERE source_type = ? "
+                    "ORDER BY created_at DESC, rowid DESC LIMIT ?",
+                    (source_type, limit),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT * FROM ingestion_provenance "
+                    "ORDER BY created_at DESC, rowid DESC LIMIT ?",
+                    (limit,),
+                ).fetchall()
+            return {"items": [self._provenance_row(r) for r in rows], "count": len(rows)}
+
+    def provenance_coverage(self) -> Dict[str, Any]:
+        """How much of the brain is explainable: nodes with vs without
+        provenance, per node type — the honesty metric for 'every source goes
+        through the pipeline'. Pre-v4 nodes ingested before provenance existed
+        legitimately count as uncovered."""
+        nt, _ = self._read_tables()
+        with self._connect() as conn:
+            total = conn.execute(f"SELECT COUNT(*) FROM {nt}").fetchone()[0]
+            covered = conn.execute(
+                f"SELECT COUNT(*) FROM {nt} WHERE id IN (SELECT DISTINCT node_id FROM ingestion_provenance)"
+            ).fetchone()[0]
+            uncovered_by_type = {
+                row["type"]: row["c"]
+                for row in conn.execute(
+                    f"""
+                    SELECT type, COUNT(*) AS c FROM {nt}
+                    WHERE id NOT IN (SELECT DISTINCT node_id FROM ingestion_provenance)
+                    GROUP BY type ORDER BY c DESC LIMIT 20
+                    """
+                ).fetchall()
+            }
+            by_source = {
+                row["source_type"]: row["c"]
+                for row in conn.execute(
+                    "SELECT source_type, COUNT(*) AS c FROM ingestion_provenance GROUP BY source_type"
+                ).fetchall()
+            }
+        return {
+            "total_nodes": total,
+            "nodes_with_provenance": covered,
+            "coverage_ratio": round(covered / total, 4) if total else None,
+            "uncovered_by_type": uncovered_by_type,
+            "provenance_by_source_type": by_source,
+        }
+
+    def provenance_stats(self) -> Dict[str, Any]:
+        """Aggregate provenance counts for the Knowledge Graph status surface."""
+        with self._connect() as conn:
+            total = conn.execute("SELECT COUNT(*) AS c FROM ingestion_provenance").fetchone()["c"]
+            by_source = {
+                r["source_type"]: r["c"]
+                for r in conn.execute(
+                    "SELECT source_type, COUNT(*) AS c FROM ingestion_provenance GROUP BY source_type"
+                ).fetchall()
+            }
+            embedded = conn.execute(
+                "SELECT COUNT(*) AS c FROM ingestion_provenance WHERE embedded = 1"
+            ).fetchone()["c"]
+            duplicates = conn.execute(
+                "SELECT COUNT(*) AS c FROM ingestion_provenance WHERE duplicate = 1"
+            ).fetchone()["c"]
+            last = conn.execute(
+                "SELECT created_at FROM ingestion_provenance ORDER BY created_at DESC LIMIT 1"
+            ).fetchone()
+        return {
+            "total": total,
+            "by_source_type": by_source,
+            "embedded": embedded,
+            "duplicates": duplicates,
+            "last_ingested_at": last["created_at"] if last else None,
+        }
+
+    # ── v3.6.0 portability: logical export / import + binary backup ──────────────
+    def schema_versions(self) -> Dict[str, Any]:
+        """Versions an exporter stamps and an importer validates against."""
+        try:
+            from kg_schema import EMBED_DIM as _EMBED_DIM, KG_SCHEMA_V2_VERSION as _V2
+        except Exception:  # pragma: no cover - kg_schema always importable in practice
+            _EMBED_DIM, _V2 = 1024, 2
+        return {
+            "graph_schema_version": GRAPH_SCHEMA_VERSION,
+            "kg_v2_schema_version": _V2,
+            "projection_version": _PROJECTION_VERSION,
+            "embed_dim": _EMBED_DIM,
+        }
+
+    def export_graph_data(self, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        """Raw, lossless logical export of the graph (nodes/edges/chunks/sources/
+        provenance). Vector embeddings are intentionally omitted — they are
+        re-derived on import — so the artifact stays portable and small. Use
+        :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.
+        """
+        with self._connect() as conn:
+            def rows(table: str):
+                return [dict(r) for r in conn.execute(f"SELECT * FROM {table}").fetchall()]
+
+            if workspace_id:
+                keep_ids = {
+                    row["id"]
+                    for row in conn.execute(
+                        "SELECT id FROM nodes_v2 WHERE workspace_id = ? OR workspace_id IS NULL",
+                        (workspace_id,),
+                    ).fetchall()
+                }
+                nodes = [n for n in rows("nodes") if n["id"] in keep_ids]
+                edges = [
+                    e for e in rows("edges")
+                    if e["from_node"] in keep_ids and e["to_node"] in keep_ids
+                ]
+                chunks = [c for c in rows("chunks") if c["source_node"] in keep_ids]
+                provenance = [p for p in rows("ingestion_provenance") if p["node_id"] in keep_ids]
+                data = {
+                    "nodes": nodes,
+                    "edges": edges,
+                    "chunks": chunks,
+                    "knowledge_sources": rows("knowledge_sources"),
+                    "provenance": provenance,
+                }
+            else:
+                data = {
+                    "nodes": rows("nodes"),
+                    "edges": rows("edges"),
+                    "chunks": rows("chunks"),
+                    "knowledge_sources": rows("knowledge_sources"),
+                    "provenance": rows("ingestion_provenance"),
+                }
+        data["counts"] = {k: len(v) for k, v in data.items()}
+        return data
+
+    def import_graph_data(
+        self, data: Dict[str, Any], *, mode: str = "merge", dry_run: bool = False
+    ) -> Dict[str, Any]:
+        """Import a logical export back into the store.
+
+        ``mode='merge'`` upserts on top of existing data (id collisions update);
+        ``mode='replace'`` clears the graph first. ``dry_run=True`` reports the
+        plan without writing. Refuses artifacts from a NEWER graph schema than
+        this build.
+        """
+        nodes = data.get("nodes") or []
+        edges = data.get("edges") or []
+        chunks = data.get("chunks") or []
+        sources = data.get("knowledge_sources") or []
+        provenance = data.get("provenance") or []
+
+        header = data.get("header") or {}
+        incoming_schema = header.get("graph_schema_version")
+        if isinstance(incoming_schema, int) and incoming_schema > GRAPH_SCHEMA_VERSION:
+            raise ValueError(
+                f"Artifact graph_schema_version {incoming_schema} is newer than this "
+                f"build ({GRAPH_SCHEMA_VERSION}); refusing to import."
+            )
+
+        plan = {
+            "mode": mode,
+            "nodes": len(nodes),
+            "edges": len(edges),
+            "chunks": len(chunks),
+            "knowledge_sources": len(sources),
+            "provenance": len(provenance),
+        }
+        if dry_run:
+            plan["dry_run"] = True
+            return plan
+
+        if mode == "replace":
+            self.clear_all()
+
+        with self._connect() as conn:
+            for n in nodes:
+                self._upsert_node(
+                    conn, n["id"], n["type"], n.get("title") or "",
+                    summary=n.get("summary") or "",
+                    metadata=_safe_loads(n.get("metadata_json")),
+                    raw=_safe_loads(n.get("raw_json")),
+                )
+            for c in chunks:
+                self._upsert_chunk(
+                    conn, chunk_id=c["id"], source_node=c["source_node"],
+                    text=c.get("text") or "", metadata=_safe_loads(c.get("metadata_json")),
+                )
+            for e in edges:
+                self._upsert_edge(
+                    conn, e["from_node"], e["to_node"], e["type"],
+                    weight=float(e.get("weight") or 1.0),
+                    metadata=_safe_loads(e.get("metadata_json")),
+                )
+            for s in sources:
+                conn.execute(
+                    """
+                    INSERT OR REPLACE INTO knowledge_sources(
+                      id, root_path, os_type, drive_id, label, status, include_ocr,
+                      watch_enabled, consent_json, created_at, updated_at, last_scanned_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        s["id"], s["root_path"], s["os_type"], s.get("drive_id"), s.get("label"),
+                        s.get("status") or "active", int(s.get("include_ocr") or 0),
+                        int(s.get("watch_enabled") or 0), s.get("consent_json") or "{}",
+                        s.get("created_at") or _now(), s.get("updated_at") or _now(),
+                        s.get("last_scanned_at"),
+                    ),
+                )
+            for p in provenance:
+                conn.execute(
+                    """
+                    INSERT OR REPLACE INTO ingestion_provenance(
+                      id, node_id, source_type, source_uri, content_hash, title, pipeline,
+                      owner, workspace_id, captured_at, modified_at, embedded, linked,
+                      duplicate, agent_used, chunk_count, permissions_json, metadata_json, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        p["id"], p["node_id"], p["source_type"], p.get("source_uri"),
+                        p.get("content_hash"), p.get("title"), p.get("pipeline") or "import",
+                        p.get("owner"), p.get("workspace_id"), p.get("captured_at"),
+                        p.get("modified_at"), int(p.get("embedded") or 0), int(p.get("linked") or 0),
+                        int(p.get("duplicate") or 0), p.get("agent_used"), int(p.get("chunk_count") or 0),
+                        p.get("permissions_json") or "{}", p.get("metadata_json") or "{}",
+                        p.get("created_at") or _now(),
+                    ),
+                )
+        plan["imported"] = True
+        return plan
+
+    def backup_database(self, dest_path) -> Path:
+        """Write a clean, standalone snapshot of the live DB to ``dest_path``.
+
+        Uses ``VACUUM INTO`` (after a full WAL checkpoint) so the snapshot is a
+        defragmented, rollback-journal-mode database with no companion -wal/-shm
+        — which restores cleanly by a plain file copy. Captures all data incl.
+        the vector_embeddings BLOBs.
+        """
+        dest = Path(dest_path)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        if dest.exists():
+            dest.unlink()  # VACUUM INTO requires the target to not exist
+        conn = self._connect()
+        try:
+            conn.execute("PRAGMA wal_checkpoint(FULL)")
+            conn.execute("VACUUM INTO ?", (str(dest),))
+        finally:
+            conn.close()
+        return dest
+
     def _ingest_structure_nodes(
         self,
         conn: sqlite3.Connection,
@@ -3044,6 +3819,13 @@ class KnowledgeGraphStore:
         "Feature",    # 소프트웨어 기능
         "Task",       # 할 일
         "Decision",   # 결정 사항
+        # v3.6.0 Knowledge Graph First — 1급 엔티티를 그래프에 노출
+        "Source",       # 수집 출처 (파일/URL/브라우저 탭/git)
+        "Repository",   # git 저장소
+        "Meeting",      # 회의
+        "Organization", # 조직
+        "Workflow",     # 워크플로우
+        "Agent",        # 에이전트
     )
 
     def list_documents(self, limit: int = 200) -> Dict[str, Any]:
@@ -3091,7 +3873,40 @@ class KnowledgeGraphStore:
             "generated_at": datetime.now().isoformat(timespec="seconds"),
         }
 
-    def graph(self, limit: int = 300) -> Dict[str, Any]:
+    def workspaces_of(self, node_ids) -> Dict[str, Optional[str]]:
+        """Map node ids to their workspace scope (None = legacy-global)."""
+        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 {}
+
+    def filter_scoped_nodes(self, items, allowed_workspaces, *, id_key: str = "id"):
+        """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.
+        """
+        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
+        ]
+
+    def graph(self, limit: int = 300, *, allowed_workspaces=None) -> 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()
@@ -3141,6 +3956,11 @@ class KnowledgeGraphStore:
                     for row in edge_rows
                 ]
 
+        if allowed_workspaces is not None:
+            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            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]
+
         degree_map: Dict[str, int] = {}
         now = datetime.now()
         node_by_id = {node["id"]: node for node in nodes}
@@ -3216,16 +4036,32 @@ class KnowledgeGraphStore:
         with self._connect() as conn:
             rows = []
             if query:
-                rows = conn.execute(
-                    f"""
-                    SELECT id, type, title, summary, metadata_json, updated_at
-                    FROM {nt}
-                    WHERE title LIKE ? OR summary LIKE ? OR metadata_json LIKE ?
-                    ORDER BY updated_at DESC, id ASC
-                    LIMIT ?
-                    """,
-                    (q, q, q, limit),
-                ).fetchall()
+                fts_ids = self._fts_match_ids(conn, query, limit)
+                if fts_ids:
+                    placeholders = ",".join("?" for _ in fts_ids)
+                    by_id = {
+                        row["id"]: row
+                        for row in conn.execute(
+                            f"""
+                            SELECT id, type, title, summary, metadata_json, updated_at
+                            FROM {nt} WHERE id IN ({placeholders})
+                            """,
+                            fts_ids,
+                        ).fetchall()
+                    }
+                    # Preserve FTS bm25 rank order.
+                    rows = [by_id[i] for i in fts_ids if i in by_id]
+                else:
+                    rows = conn.execute(
+                        f"""
+                        SELECT id, type, title, summary, metadata_json, updated_at
+                        FROM {nt}
+                        WHERE title LIKE ? OR summary LIKE ? OR metadata_json LIKE ?
+                        ORDER BY updated_at DESC, id ASC
+                        LIMIT ?
+                        """,
+                        (q, q, q, limit),
+                    ).fetchall()
 
             if len(rows) < limit:
                 terms = _topic_candidates(query, limit=8)
@@ -3260,6 +4096,10 @@ class KnowledgeGraphStore:
                 } else 0
                 return (hits, type_boost, row["updated_at"] or "")
 
+            # Deterministic contract: rows with equal relevance order by id ASC
+            # (stable sort preserves the pre-sort under reverse=True), matching
+            # the legacy LIKE path regardless of FTS bm25 tie ordering.
+            rows = sorted(rows, key=lambda r: r["id"])
             rows = sorted(rows, key=score, reverse=True)[:limit]
         return {
             "query": query,
@@ -3744,6 +4584,9 @@ class KnowledgeGraphStore:
                 "backend": "sqlite",
                 "embedding_model": self._embedding_model.model_id,
                 "embedding_dim": self._embedding_model.dim,
+                # Honest capability report: trigram FTS5 keyword index, or
+                # LIKE-scan fallback when this SQLite build lacks it.
+                "fts_enabled": bool(getattr(self, "_fts_enabled", False)),
             },
             "source_items": len(source_items),
             "indexed_items": sum(vector_counts.values()),
@@ -3847,21 +4690,26 @@ class KnowledgeGraphStore:
             return {"status": "skipped", "removed_nodes": 0}
         conv_id = f"conversation:{_slug(conversation_id)}"
         with self._connect() as conn:
+            # Edge rows may carry the legacy lowercase label (pre-v4) or the
+            # canonical EdgeType value (v4 write door) — match both.
             direct_ids = [
                 row["to_node"]
                 for row in conn.execute(
-                    "SELECT to_node FROM edges WHERE from_node=? AND type='contains'",
+                    "SELECT to_node FROM edges WHERE from_node=? AND type IN ('contains', 'CONTAINS')",
                     (conv_id,),
                 )
             ]
             remove_ids = set(direct_ids)
+            child_types = [
+                "has_chunk", "implies", "contains_signal", "has_page",
+                "has_slide", "has_sheet", "contains_image",
+            ]
+            child_types += [t.upper() for t in child_types]
+            placeholders = ",".join("?" for _ in child_types)
             for source_id in list(direct_ids):
                 for row in conn.execute(
-                    """
-                    SELECT to_node FROM edges
-                    WHERE from_node=? AND type IN ('has_chunk', 'implies', 'contains_signal', 'has_page', 'has_slide', 'has_sheet', 'contains_image')
-                    """,
-                    (source_id,),
+                    f"SELECT to_node FROM edges WHERE from_node=? AND type IN ({placeholders})",
+                    (source_id, *child_types),
                 ):
                     remove_ids.add(row["to_node"])
             remove_ids.add(conv_id)