[NOTICKET] fix(knowledge): the diff baseline never reached the ingest path

`run_document` called `extract_and_persist` WITHOUT `active_glossary`, so the
glossary diff ran against an empty list and every entry came back
`diff_status="new"`. Only the re-extract path passed the approved set.

The consequence is the thing the review queue exists to make tractable: a
company approves terms from document 1, ingests document 2, and document 2's
terms all read as `new` even where they duplicate or contradict what an expert
already ruled on. Cross-document dedup silently did not fire on the path people
will actually use most.

Invisible in the end-to-end run because there were no approvals yet - all 88
entries showed `new`, which was correct then and would be wrong now.

Fixed at the single point that needs it rather than at the call site:
`extract_and_persist` now fetches `approved_glossary(scope_id)` itself when the
argument is omitted, so no caller can forget it again, and the redundant fetch
in `_run_reextract` is gone. An explicit `[]` still means "diff against
nothing", which is what the tests use.

2 regression tests: the baseline is fetched when the argument is omitted, and an
explicit empty list does NOT trigger a fetch.

Verification: ruff clean on touched paths; `import main` OK; suite 572 passed /
7 skipped (570 + 2 new local tests).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/knowledge_ingest/pipeline.py

@@ -206,9 +206,21 @@ class KnowledgePipeline:
         Also the entry point for re-extracting a stored artifact, which needs no
         parsing at all - prompt retuning is the common case and must not re-pay
         the parser for a byte-identical result.
+
+`active_glossary` defaults to **the tenant's approved entries,
+        fetched here**. Passing it was previously the caller's job and the
+        ingest path forgot, so every entry came back `diff_status="new"`: the
+        diff ran against an empty list, and a second document never showed as
+        duplicating or contradicting what an expert had already approved - which
+        is exactly the cross-document dedup that makes the queue finishable.
+        Fetching it at the single point that needs it means no caller can omit
+        it again. Pass an explicit `[]` to diff against nothing.
         """
         from src.knowledge_extraction.adapter import parsed_doc_from_artifact
 
+        if active_glossary is None:
+            active_glossary = await self._store.approved_glossary(scope_id)
+
         doc = parsed_doc_from_artifact(artifact)
         loop = asyncio.get_running_loop()
 
@@ -242,7 +254,7 @@ class KnowledgePipeline:
                     clustered,
                     filtered,
                     extractor,
-                    active_glossary=active_glossary,
+                    active_glossary=active_glossary or None,
                     branches=BRANCHES,
                 ),
             )

src/knowledge_ingest/service.py

@@ -279,18 +279,17 @@ class IngestService:
 
             result = job.results[0]
             try:
-                # The approved set is passed explicitly rather than read from
-                # wherever the last run wrote, so the duplicate and conflicting
-                # paths are actually reachable. This is the edge that closes the
-                # loop: an expert's approvals become the baseline this run
-                # classifies its candidates against.
-                active = await self._knowledge.approved_glossary(job.scope_id)
+                # The approved set is fetched inside `extract_and_persist` for
+                # The approved set is fetched inside `extract_and_persist` for
+                # BOTH paths - it used to be passed here and forgotten on the
+                # ingest path, which silently disabled cross-document diffing.
+                # This is the edge that closes the loop: an expert's approvals
+                # become the baseline the next run classifies against.
                 n, run_id = await self._pipeline.extract_and_persist(
                     document.artifact,
                     document.id,
                     scope_id=job.scope_id,
                     user_id=job.user_id,
-                    active_glossary=active or None,
                 )
                 result.run_id = run_id
                 result.n_entries = n