confluence-knowledge 0.5.2__tar.gz → 0.5.4__tar.gz

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confluence-knowledge
-Version: 0.5.2
+Version: 0.5.4
 Summary: Local, GET-only Confluence subtree indexer + grounded-Q&A MCP service
 License: MIT
 Project-URL: Repository, https://github.com/nkunal1992/agents

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "confluence-knowledge"
-version = "0.5.2"
+version = "0.5.4"
 description = "Local, GET-only Confluence subtree indexer + grounded-Q&A MCP service"
 readme = "README.md"
 requires-python = ">=3.11"

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/crawl.py

@@ -172,6 +172,9 @@ class Crawler:
 
         queue: list[str] = job["queue"]
         errors: list[str] = job["errors"]
+        # pages that fail with deny/gone errors are meant to drop out of the
+        # snapshot; transient failures keep their previously-indexed content
+        keep_failed: set[str] = set()
 
         # Mid-crawl model change: already-embedded pages live in the OLD
         # vector space — finishing this job would publish a mixed-dimension
@@ -216,6 +219,9 @@ class Crawler:
                 page = self._page(pid)
             except AccessError as e:
                 errors.append(f"page {pid}: {e}")
+                if not any(m in str(e) for m in
+                           ("401", "403", "404", "permission", "not found")):
+                    keep_failed.add(pid)
                 continue
             if pid != job["root_page"]:
                 anc = page.get("ancestors") or []
@@ -250,7 +256,7 @@ class Crawler:
             self.index.save_job(job_id, "running", queue, errors)
             state = "running"
         else:
-            self.index.publish(seen)
+            self.index.publish(seen | keep_failed)
             self.index.set_model_id(_MODEL_ID)
             self.index.save_job(job_id, "done", [], errors)
             state = "done"

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/extract.py

@@ -38,6 +38,28 @@ def _table_to_text(tbl) -> str:
     return "\n".join(out)
 
 
+def split_table_text(t: str) -> list[str]:
+    """An oversized table becomes several ≤MAX_WORDS chunks, each carrying
+    the header line — one unbounded chunk would exceed the embedder and the
+    reranker's token limits and silently lose its tail rows."""
+    if len(t.split()) <= MAX_WORDS:
+        return [t]
+    lines = t.split("\n")
+    header, rows = lines[0], lines[1:]
+    hw = len(header.split())
+    segs, buf, w = [], [], hw + 2
+    for r in rows:
+        rw = len(r.split())
+        if buf and w + rw > MAX_WORDS:
+            segs.append(header + "\n" + "\n".join(buf))
+            buf, w = [], hw + 2
+        buf.append(r)
+        w += rw
+    if buf:
+        segs.append(header + "\n" + "\n".join(buf))
+    return segs
+
+
 def extract_chunks(storage_html: str) -> tuple[list[Chunk], list[str]]:
     """Return (chunks, extraction warnings)."""
     soup = BeautifulSoup(storage_html, "html.parser")  # stdlib parser; no ext entities
@@ -110,8 +132,9 @@ def extract_chunks(storage_html: str) -> tuple[list[Chunk], list[str]]:
         elif el.name == "table":
             flush()
             t = _table_to_text(el)
-            if t:
-                chunks.append(Chunk(t, " > ".join(heading_path), "table", len(chunks)))
+            for seg in split_table_text(t):
+                chunks.append(Chunk(seg, " > ".join(heading_path), "table",
+                                    len(chunks)))
         else:
             buf.append(el.get_text(" ", strip=True))
     flush()

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/extract_files.py

@@ -12,7 +12,7 @@ import csv
 import io
 import zipfile
 
-from .extract import Chunk, extract_chunks
+from .extract import Chunk, extract_chunks, split_table_text
 from .settings import SetupError
 
 MAX_FILE_WORDS = 200_000   # ~1MB of text — beyond that, index metadata only
@@ -111,7 +111,9 @@ def _docx_chunks(data: bytes) -> list[Chunk]:
                 header, *body = rows
                 t = "\n".join([f"Table — columns: {header}"]
                               + [f"row {i}: {r}" for i, r in enumerate(body, 1)])
-                chunks.extend(_text_chunks(t, " > ".join(heading), "table"))
+                for seg in split_table_text(t):
+                    chunks.append(Chunk(seg, " > ".join(heading), "table",
+                                        len(chunks)))
     flush()
     return chunks
 
@@ -157,7 +159,9 @@ def _xlsx_chunks(data: bytes) -> list[Chunk]:
         header, *body = rows
         text = "\n".join([f"Table — columns: {header}"]
                          + [f"row {i}: {r}" for i, r in enumerate(body, 1)])
-        chunks.extend(_text_chunks(text, f"Sheet: {ws.title}", "table"))
+        for seg in split_table_text(text):
+            chunks.append(Chunk(seg, f"Sheet: {ws.title}", "table",
+                                len(chunks)))
     wb.close()
     return chunks
 
@@ -191,7 +195,8 @@ def _csv_chunks(data: bytes) -> list[Chunk]:
     header, *body = rows
     out = "\n".join([f"Table — columns: {' | '.join(header)}"]
                     + [f"row {i}: {' | '.join(r)}" for i, r in enumerate(body, 1)])
-    return _text_chunks(out, "", "table")
+    return [Chunk(seg, "", "table", i)
+            for i, seg in enumerate(split_table_text(out))]
 
 
 def extract_file_chunks(filename: str, data: bytes) -> tuple[list[Chunk], list[str]]:

confluence_knowledge-0.5.4/src/confluence_knowledge/feedback.py

@@ -0,0 +1,91 @@
+"""Per-scope human-feedback store — colleague corrections keyed by query
+embedding. Local-first: one JSON file per scope under the index dir;
+`clean` removes them along with the index (documented semantics).
+
+Design rules (from issue #107): corrections are disclosed ALONGSIDE
+documentation — "the docs say X, but a colleague correction says Y" —
+never silently override, never silently dropped.
+"""
+
+import json
+import os
+import tempfile
+import time
+from pathlib import Path
+
+import numpy as np
+
+# measured on real bge-m3: identical question 1.00, close paraphrase ~0.77,
+# same-topic different-intent ~0.68, unrelated ~0.39 → 0.75 catches natural
+# rephrases without leaking across topics
+DEFAULT_MIN_SIM = 0.75
+
+
+class FeedbackStore:
+    """JSON list under the index dir; same integrity discipline as Index
+    (tolerant load, atomic writes)."""
+
+    def __init__(self, index_root: Path, scope_key: str, cli: str):
+        self.path = index_root / f"{scope_key}.feedback.json"
+        env_key = cli.upper().replace("-", "_") + "_FEEDBACK_MIN_SIM"
+        self.min_sim = float(os.environ.get(
+            env_key, os.environ.get("KNOWLEDGE_FEEDBACK_MIN_SIM",
+                                    DEFAULT_MIN_SIM)))
+        self._entries = self._load()
+
+    def _load(self) -> list[dict]:
+        if not self.path.exists():
+            return []
+        try:
+            data = json.loads(self.path.read_text())
+            return data if isinstance(data, list) else []
+        except (json.JSONDecodeError, OSError):
+            return []  # corrupt file → start fresh, don't crash the server
+
+    def _save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=self.path.parent, suffix=".tmp")
+        with os.fdopen(fd, "w") as f:
+            json.dump(self._entries, f)
+        os.replace(tmp, self.path)  # atomic — a crash mid-write can't corrupt
+
+    def add(self, question: str, qvec: np.ndarray, correction: str,
+            note: str = "") -> dict:
+        entry = {"id": f"fb{len(self._entries):04d}",
+                 "question": question,
+                 "qvec": qvec.astype(np.float32).tolist(),
+                 "correction": correction, "note": note,
+                 "ts": int(time.time())}
+        self._entries.append(entry)
+        self._save()
+        return entry
+
+    def match(self, qvec: np.ndarray, k: int = 3) -> list[dict]:
+        """Cosine-similar corrections ≥ min_sim (default 0.75 — catches
+        paraphrases without leaking across topics), best first."""
+        if not self._entries:
+            return []
+        mat = np.array([e["qvec"] for e in self._entries], dtype=np.float32)
+        q = qvec / (np.linalg.norm(qvec) + 1e-9)
+        m = mat / (np.linalg.norm(mat, axis=1, keepdims=True) + 1e-9)
+        sims = m @ q
+        out = []
+        for i in np.argsort(-sims):
+            if sims[i] < self.min_sim or len(out) >= k:
+                break
+            e = dict(self._entries[int(i)])
+            e.pop("qvec", None)
+            e["similarity"] = float(sims[i])
+            e["age_days"] = int((time.time() - e["ts"]) / 86400)
+            out.append(e)
+        return out
+
+    def report(self) -> dict:
+        """Aggregate view for 'which pages keep getting corrected' — the
+        agent summarizes these as outdated/confusing doc candidates."""
+        out = []
+        for e in self._entries:
+            out.append({"question": e["question"], "correction": e["correction"],
+                        "note": e["note"], "age_days":
+                        int((time.time() - e["ts"]) / 86400)})
+        return {"count": len(out), "corrections": out}

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/index.py

@@ -195,7 +195,9 @@ class Index:
                             (model_id,))
 
     def publish(self, seen_page_ids: set[str]) -> None:
-        """Atomically make exactly the crawled page set the active snapshot."""
+        """Atomically make exactly the crawled page set the active snapshot.
+        Content belonging to pages no longer seen is DELETED — inactive rows
+        are unreachable forever anyway and would otherwise bloat every table."""
         with self.lock, self.db:
             self.db.execute("UPDATE pages SET active=0")
             self.db.execute("UPDATE chunks SET active=0")
@@ -204,6 +206,20 @@ class Index:
                 ids = list(seen_page_ids)
                 self.db.execute(f"UPDATE pages SET active=1 WHERE page_id IN ({q})", ids)
                 self.db.execute(f"UPDATE chunks SET active=1 WHERE page_id IN ({q})", ids)
+            # gc: drop chunks (and their retrieval rows) of inactive pages,
+            # then the inactive page rows themselves
+            dead_chunks = [r[0] for r in self.db.execute(
+                "SELECT chunk_id FROM chunks WHERE page_id IN "
+                "(SELECT page_id FROM pages WHERE active=0)")]
+            if dead_chunks:
+                q = ",".join("?" * len(dead_chunks))
+                for t in ("chunks_fts", "vectors", "sparse_vectors"):
+                    self.db.execute(
+                        f"DELETE FROM {t} WHERE chunk_id IN ({q})",
+                        dead_chunks)
+                self.db.execute(f"DELETE FROM chunks WHERE chunk_id IN ({q})",
+                                dead_chunks)
+            self.db.execute("DELETE FROM pages WHERE active=0")
 
     # ---- query ----
     def active_pages(self) -> dict[str, dict]:

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/retrieval.py

@@ -39,7 +39,8 @@ MODEL_MARKER = f"{EMBED_MODEL_ID}+{SPARSE_MODEL_ID}"
 TOP_K_RETRIEVE = 30
 TOP_K_EVIDENCE = 8
 RERANK_MAX = 25          # bounds cross-encoder latency on CPU
-MIN_RERANK_SCORE = 0.3   # sigmoid floor — below this a hit is "least bad"
+MIN_RERANK_SCORE = 0.02  # noise floor — real reranker zeros junk at ~0.00
+LOW_CONFIDENCE_SCORE = 0.3  # below this the hit is surfaced but flagged
 MAX_SEARCHABLE_CHUNKS = 100_000  # whole-index search is O(n) in RAM
 EMBED_MAX_TOKENS = 512   # quantized model input cap (chunks stay under)
 RERANK_MAX_TOKENS = 512
@@ -374,11 +375,14 @@ def retrieve(index: Index, query: str, embedder: LocalEmbedder,
         evidence = []
         for i in order:
             if scores[i] < MIN_RERANK_SCORE:
-                # below the floor the reranker is only ranking "least bad" —
-                # surfacing it would ground the answer on noise
+                # below the noise floor the reranker is only ranking "least
+                # bad" — surfacing it would ground the answer on junk
                 continue
             c = dict(scored[i])
             c["rerank_score"] = float(scores[i])
+            # borderline matches are surfaced but flagged — the agent can
+            # caveat instead of answering on silently-weak evidence
+            c["low_confidence"] = bool(scores[i] < LOW_CONFIDENCE_SCORE)
             evidence.append(c)
     else:
         evidence = [dict(c, rerank_score=None) for c in candidates[:TOP_K_EVIDENCE]]

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge/server.py

@@ -16,6 +16,7 @@ from mcp.server.fastmcp import FastMCP
 from .auth import get_credential
 from .client import AccessError, ConfluenceClient, SecurityException, make_client
 from .crawl import Crawler
+from .feedback import FeedbackStore
 from .index import Index
 from .retrieval import (
     MODEL_MARKER as EMBED_MODEL_ID,
@@ -40,9 +41,10 @@ mcp = FastMCP("confluence-knowledge")
 
 # in-process caches (per server lifetime)
 _scopes: dict[str, dict] = {}
-_evidence_sets: dict[str, list[dict]] = {}
+_evidence_sets: dict[str, dict] = {}  # set_id → {scope, ev}
 _indexes: dict[str, Index] = {}  # one connection per DB for the server lifetime
 _clients: dict[str, ConfluenceClient] = {}  # one HTTP pool per credential
+_feedback: dict[str, FeedbackStore] = {}  # per-scope correction stores
 _EMBEDDER = None
 _RERANKER = None
 _SPARSE = None
@@ -85,6 +87,14 @@ def _index_for(scope_key: str) -> Index:
     return idx
 
 
+def _feedback_for(scope_key: str) -> FeedbackStore:
+    st = _feedback.get(scope_key)
+    if st is None:
+        st = _feedback[scope_key] = FeedbackStore(
+            workspace_index_root(_workdir()), scope_key, "confluence-knowledge")
+    return st
+
+
 def _embedder():
     global _EMBEDDER
     with _model_lock:
@@ -331,17 +341,27 @@ def search(scope_handle: str, question: str) -> dict:
         return {"evidence": [], "coverage": "stale_model",
                 "note": "this index was built with an older embedding model "
                         "— run start_crawl once to rebuild it, then search again"}
-    ev = retrieve(idx, question, _embedder(), _reranker(), sparse=_sparse())
+    emb = _embedder()
+    ev = retrieve(idx, question, emb, _reranker(), sparse=_sparse())
+    # colleague corrections matching this question ride along — the agent
+    # must disclose them, so they're part of the response, not a separate call
+    corrections = _feedback_for(s["key"]).match(emb.embed([question])[0])
     set_id = f"ev:{len(_evidence_sets)}:{s['key'][:8]}"
-    _evidence_sets[set_id] = ev
+    # bound the session cache — sets are never reused after the turn ends
+    while len(_evidence_sets) >= 32:
+        _evidence_sets.pop(next(iter(_evidence_sets)))
+    _evidence_sets[set_id] = {"scope": s["key"], "ev": ev}
     return {
         "evidence_set": set_id,
         "coverage": _coverage(idx),
         "as_of": st["as_of"],
+        "user_corrections": corrections,
         "evidence": [
             {"chunk_id": e["chunk_id"], "page_title": e["page_title"],
              "page_url": e["page_url"], "heading": e["heading"],
-             "score": e.get("rerank_score"), "text": e["text"][:2000]}
+             "score": e.get("rerank_score"), "text": e["text"][:12000],
+             "low_confidence": e.get("low_confidence", False),
+             "truncated": len(e["text"]) > 12000}
             for e in ev
         ],
     }
@@ -364,15 +384,38 @@ def get_evidence(scope_handle: str, chunk_ids: list[str]) -> dict:
     return {"chunks": out}
 
 
+@mcp.tool()
+def submit_feedback(scope_handle: str, question: str, correction: str,
+                    note: str = "") -> dict:
+    """Store a colleague correction — disclosed alongside the docs on
+    similar future questions (never overrides them)."""
+    s = _scope(scope_handle)
+    if not _models_loaded(0):
+        return {"stored": False, "note": LOADING_NOTE}
+    qvec = _embedder().embed([question])[0]
+    entry = _feedback_for(s["key"]).add(question, qvec, correction, note)
+    return {"stored": entry["id"],
+            "note": "will be disclosed on similar questions"}
+
+
+@mcp.tool()
+def feedback_report(scope_handle: str) -> dict:
+    """Aggregated corrections — which topics keep getting corrected points
+    at outdated/confusing documentation."""
+    s = _scope(scope_handle)
+    return _feedback_for(s["key"]).report()
+
+
 @mcp.tool()
 def verify_citations(scope_handle: str, evidence_set: str,
                      mappings: list[dict]) -> dict:
-    _scope(scope_handle)
-    ev = _evidence_sets.get(evidence_set)
-    if ev is None or not evidence_set.endswith(_scopes[scope_handle]["key"][:8]):
+    s = _scope(scope_handle)  # binds or SetupError — never KeyError below
+    rec = _evidence_sets.get(evidence_set)
+    # full 24-char scope key — the key[:8] suffix in the id is cosmetic
+    if rec is None or rec["scope"] != s["key"]:
         raise SecurityException(
             "unknown or cross-scope evidence set — run search again and cite its evidence_set")
-    return check_citations(ev, mappings)
+    return check_citations(rec["ev"], mappings)
 
 
 def main() -> None:

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confluence-knowledge
-Version: 0.5.2
+Version: 0.5.4
 Summary: Local, GET-only Confluence subtree indexer + grounded-Q&A MCP service
 License: MIT
 Project-URL: Repository, https://github.com/nkunal1992/agents

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/src/confluence_knowledge.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/confluence_knowledge/client.py
 src/confluence_knowledge/crawl.py
 src/confluence_knowledge/extract.py
 src/confluence_knowledge/extract_files.py
+src/confluence_knowledge/feedback.py
 src/confluence_knowledge/health.py
 src/confluence_knowledge/index.py
 src/confluence_knowledge/models.lock.json
@@ -25,6 +26,7 @@ tests/test_agent_doc_consistency.py
 tests/test_client_get_only.py
 tests/test_crawl.py
 tests/test_extract.py
+tests/test_feedback.py
 tests/test_health_checks.py
 tests/test_index.py
 tests/test_prepare_models.py

{confluence_knowledge-0.5.2 → confluence_knowledge-0.5.4}/tests/test_agent_doc_consistency.py

@@ -32,3 +32,21 @@ def test_agent_references_repo_files_that_exist():
     doc = AGENT.read_text()
     for m in re.findall(r"prompts/([\w.-]+)", doc):
         assert (REPO / "prompts" / m).exists(), f"agent references missing prompts/{m}"
+
+
+def test_agent_frontmatter_tools_exist():
+    """Every tool named in the agent's frontmatter must be a real
+    @mcp.tool() in the server source."""
+    if not AGENT.exists():
+        import pytest
+        pytest.skip("agent file not in this checkout layout")
+    doc = AGENT.read_text()
+    tools_line = re.search(r'tools:\s*\[([^\]]+)\]', doc).group(1)
+    declared = {t.strip().strip('"').split("/")[1]
+                for t in tools_line.split(",")
+                if "confluence-knowledge/" in t}
+    srv = (Path(__file__).parents[1] / "src" /
+           "confluence_knowledge" / "server.py").read_text()
+    real = set(re.findall(r"@mcp\.tool\(\)\s*\ndef\s+(\w+)", srv))
+    missing = declared - real
+    assert not missing, f"agent frontmatter names tools not in server: {missing}"

confluence_knowledge-0.5.4/tests/test_feedback.py

@@ -0,0 +1,106 @@
+"""FeedbackStore: per-scope corrections, threshold matching, integrity."""
+
+import numpy as np
+
+from confluence_knowledge.feedback import FeedbackStore
+
+
+def _v(seed: int) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    v = rng.random(16).astype(np.float32)
+    return v / np.linalg.norm(v)
+
+
+def test_add_and_match(tmp_path):
+    st = FeedbackStore(tmp_path, "scope1", "ck-test")
+    st.add("password policy?", _v(1), "it is actually 16 chars")
+    hits = st.match(_v(1))
+    assert len(hits) == 1 and hits[0]["correction"].startswith("it is")
+    assert "qvec" not in hits[0] and hits[0]["similarity"] >= 0.85
+
+
+def test_threshold_rejects_unrelated(tmp_path):
+    st = FeedbackStore(tmp_path, "scope1", "ck-test")
+    st.add("password policy?", _v(1), "correction")
+    # orthogonal vector — sim 0.0 (16-dim random vectors can collide at >0.75)
+    q = np.zeros(16, dtype=np.float32)
+    q[7] = 1.0
+    stored = np.array([np.array(e["qvec"]) for e in st._entries])
+    assert float(q @ stored[0]) < 0.75
+    assert st.match(q) == []
+
+
+def test_scopes_isolated(tmp_path):
+    a = FeedbackStore(tmp_path, "scopeA", "ck-test")
+    b = FeedbackStore(tmp_path, "scopeB", "ck-test")
+    a.add("q", _v(1), "for A only")
+    assert b.match(_v(1)) == []
+    assert a.path.name != b.path.name
+
+
+def test_corrupt_file_tolerated(tmp_path):
+    (tmp_path / "scope1.feedback.json").write_text("{not json!!")
+    st = FeedbackStore(tmp_path, "scope1", "ck-test")
+    assert st.report()["count"] == 0  # loads empty, doesn't crash
+
+
+def test_persists_across_instances(tmp_path):
+    FeedbackStore(tmp_path, "s", "ck-test").add("q", _v(2), "corr")
+    st = FeedbackStore(tmp_path, "s", "ck-test")
+    assert st.report()["count"] == 1
+
+
+def test_report_shape(tmp_path):
+    st = FeedbackStore(tmp_path, "s", "ck-test")
+    st.add("q1", _v(1), "c1", note="why")
+    r = st.report()
+    assert r["count"] == 1
+    assert r["corrections"][0]["note"] == "why"
+    assert "qvec" not in r["corrections"][0]
+
+
+def test_search_injects_corrections(tmp_path, monkeypatch):
+    """submit_feedback → a similar question's search carries it through."""
+    from confluence_knowledge import server
+    from confluence_knowledge.extract import Chunk
+    from confluence_knowledge.index import Index
+    server._scopes.clear()
+    server._feedback.clear()
+    server._evidence_sets.clear()
+    monkeypatch.setenv("CONF_KNOWLEDGE_WORKDIR", str(tmp_path))
+    monkeypatch.setenv("CONF_KNOWLEDGE_HOME", str(tmp_path / "home"))
+    (tmp_path / "home").mkdir()
+
+    s = {"key": "k123", "profile": None, "root": "r"}
+    server._scopes["scope:k:r"] = s
+
+    # index with one page so search doesn't early-return "empty"
+    idx = Index(tmp_path / ".conf_knowledge_index" / "k123.db")
+    c = Chunk(text="old answer text", heading_path="", kind="text",
+              ordinal=0, chunk_id="p1:0:0")
+    idx.upsert_page({"page_id": "p1", "parent_id": None, "title": "P",
+                     "url": "u", "level": 0, "version": "", "warnings": ""},
+                    [c], vecs=None, sparse=None)
+    idx.publish({"p1"})
+
+    import rag.conftest as rc
+    emb = rc.HashEmbedder()
+    monkeypatch.setattr(server, "_embedder", lambda: emb)
+    monkeypatch.setattr(server, "_reranker", lambda: None)
+    monkeypatch.setattr(server, "_sparse", lambda: None)
+    monkeypatch.setattr(server, "_models_loaded", lambda _w: True)
+    monkeypatch.setattr(server, "_index_for", lambda k: idx)
+    monkeypatch.setattr(server, "_feedback_for",
+                        lambda k: server._feedback.setdefault(
+                            k, server.FeedbackStore(
+                                tmp_path / ".conf_knowledge_index",
+                                k, "confluence-knowledge")))
+
+    server.submit_feedback("scope:k:r", "what is the password policy",
+                           "14 is wrong, it's 16")
+    res = server.search("scope:k:r", "what is the password policy")
+    assert res["user_corrections"] and \
+        res["user_corrections"][0]["correction"] == "14 is wrong, it's 16"
+    # unrelated question → no injection
+    res2 = server.search("scope:k:r", "zebra quantum xyzzy nonsense")
+    assert res2["user_corrections"] == []