gaard-api 0.2.17__tar.gz → 0.2.19__tar.gz

{gaard_api-0.2.17/src/gaard_api.egg-info → gaard_api-0.2.19}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.2.17
+Version: 0.2.19
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: gaard-core==0.2.17
-Requires-Dist: gaard-connectors==0.2.17
-Requires-Dist: gaard-llm==0.2.17
+Requires-Dist: gaard-core==0.2.19
+Requires-Dist: gaard-connectors==0.2.19
+Requires-Dist: gaard-llm==0.2.19
 Requires-Dist: gaard-plugin-api<0.3.0,>=0.2.17
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.30.0

{gaard_api-0.2.17 → gaard_api-0.2.19}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gaard-api"
-version = "0.2.17"
+version = "0.2.19"
 description = "GAARD backend web services providing admin interface"
 readme = "README.md"
 requires-python = ">=3.11"
 
 dependencies = [
-    "gaard-core==0.2.17",
-    "gaard-connectors==0.2.17",
-    "gaard-llm==0.2.17",
+    "gaard-core==0.2.19",
+    "gaard-connectors==0.2.19",
+    "gaard-llm==0.2.19",
     "gaard-plugin-api>=0.2.17,<0.3.0",
     "fastapi>=0.111.0",
     "uvicorn[standard]>=0.30.0",

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/admin/database.py

@@ -252,6 +252,19 @@ def seed_prompts(session: Session) -> None:
             continue
 
         if existing.updated_by != "system":
+            if existing.prompt_key == "sql_generation":
+                # Replace only the shipped LIMIT rules, preserving administrator customizations.
+                updated_prompt = existing.system_prompt.replace(
+                    "Add LIMIT {max_rows} when the query may return many rows.",
+                    "{row_limit_instruction}",
+                ).replace(
+                    "Do not add LIMIT to pure aggregate queries that return a single row, "
+                    "unless it is already useful for the dialect or safety.",
+                    "Do not add a row limit to pure aggregate queries that return a single row.",
+                )
+                if updated_prompt != existing.system_prompt:
+                    existing.system_prompt = updated_prompt
+                    existing.version += 1
             continue
 
         changed = any(

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/admin/defaults.py

@@ -28,8 +28,8 @@ Query construction rules:
 3. If the user asks for both a total and a breakdown, prefer one SELECT statement that returns grouped rows or conditional aggregate columns.
 4. Do not solve one user question by generating multiple separate SELECT statements.
 5. Prefer explicit column names over SELECT *.
-6. Add LIMIT {max_rows} when the query may return many rows.
-7. Do not add LIMIT to pure aggregate queries that return a single row, unless it is already useful for the dialect or safety.
+6. {row_limit_instruction}
+7. Do not add a row limit to pure aggregate queries that return a single row.
 8. Use clear aliases for computed expressions.
 9. If the question is ambiguous, choose the most likely interpretation based on the schema, column names, descriptions and data rules.
 

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/admin/prompt_runtime.py

@@ -4,6 +4,7 @@ from gaard_core.errors import ConfigurationError
 from gaard_core.json_utils import json_dumps
 from gaard_core.prompt_compiler.models import CompiledPrompt, SqlGenerationPromptRequest
 from gaard_core.prompt_compiler.schema_formatter import SchemaPromptFormatter
+from gaard_core.prompt_compiler.sql_generation_prompt import sql_row_limit_instruction
 from gaard_core.query_pipeline.models import (
     ConversationContextDecision,
     QueryRequest,
@@ -29,12 +30,14 @@ class MetadataSqlGenerationPromptCompiler:
         system_prompt = self.prompt_template.system_prompt.format(
             dialect=request.dialect,
             max_rows=request.max_rows,
+            row_limit_instruction=sql_row_limit_instruction(request.dialect, request.max_rows),
         )
         user_prompt = self.prompt_template.user_prompt_template.format(
             schema=formatted_schema,
             question=request.question,
             dialect=request.dialect,
             max_rows=request.max_rows,
+            row_limit_instruction=sql_row_limit_instruction(request.dialect, request.max_rows),
         )
 
         return CompiledPrompt(

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/admin/services.py

@@ -1747,6 +1747,14 @@ def upsert_llm_business_logic_suggestion(
             )
         )
 
+    if existing is None:
+        existing = session.scalar(
+            select(BusinessLogicSuggestion).where(
+                BusinessLogicSuggestion.connector_id == connector.id,
+                BusinessLogicSuggestion.rule_text == lesson.rule_text,
+            )
+        )
+
     if existing is None:
         existing = BusinessLogicSuggestion(
             connector_id=connector.id,
@@ -1769,6 +1777,10 @@ def upsert_llm_business_logic_suggestion(
         return existing
 
     existing.source_audit_id = audit_log.id
+    # Re-observing an error must not revoke approval or overwrite reviewed content.
+    if existing.enabled:
+        return existing
+
     existing.status = BUSINESS_LOGIC_STATUS_PENDING
     existing.safety = BUSINESS_LOGIC_SAFETY_REVIEW
     existing.enabled = False
@@ -1839,10 +1851,19 @@ def upsert_analysis_business_logic_suggestion(
         session.flush()
         return existing
 
+    should_enable = auto_enable or existing.enabled
     existing.source_audit_id = source_audit_id
-    existing.status = BUSINESS_LOGIC_STATUS_ACTIVE if auto_enable else BUSINESS_LOGIC_STATUS_PENDING
-    existing.safety = BUSINESS_LOGIC_SAFETY_SAFE if auto_enable else BUSINESS_LOGIC_SAFETY_REVIEW
-    existing.enabled = auto_enable
+    existing.status = (
+        BUSINESS_LOGIC_STATUS_ACTIVE
+        if should_enable
+        else BUSINESS_LOGIC_STATUS_PENDING
+    )
+    existing.safety = (
+        BUSINESS_LOGIC_SAFETY_SAFE
+        if should_enable
+        else BUSINESS_LOGIC_SAFETY_REVIEW
+    )
+    existing.enabled = should_enable
     existing.error_category = normalized_type
     existing.title = normalized_title
     existing.rule_text = normalized_rule
@@ -1863,9 +1884,12 @@ def record_business_logic_learning_suggestion(
     metadata["failed_identifier"] = lesson.failed_identifier
     metadata["repaired_identifier"] = lesson.repaired_identifier
     metadata["business_logic_learning"] = {
-        "status": "pending_approval",
+        "status": BUSINESS_LOGIC_STATUS_ACTIVE if suggestion.enabled else "pending_approval",
         "suggestion_id": suggestion.id,
         "message": (
+            "This error matches an already approved business logic rule. "
+            "The rule remains active."
+            if suggestion.enabled else
             "Nauczyłem się propozycji rozwiązania tego błędu, ale musisz ją "
             "zatwierdzić w Sugestiach logiki biznesowej."
         ),

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/analysis_findings.py

@@ -186,6 +186,46 @@ def create_analysis_finding(
     return finding
 
 
+def get_analysis_finding_for_business_logic_suggestion(
+    session: Session,
+    *,
+    investigation_id: str,
+    owner_user_id: str,
+    business_logic_suggestion_id: int,
+) -> AnalysisFinding | None:
+    return session.scalar(
+        select(AnalysisFinding)
+        .where(
+            AnalysisFinding.investigation_id == investigation_id,
+            AnalysisFinding.owner_user_id == owner_user_id,
+            AnalysisFinding.business_logic_suggestion_id == business_logic_suggestion_id,
+        )
+        .order_by(AnalysisFinding.id.asc())
+    )
+
+
+def refresh_analysis_finding_observation(
+    finding: AnalysisFinding,
+    *,
+    statement: str,
+    finding_type: str,
+    confidence: float,
+    critique: str,
+    scope: dict[str, Any],
+    evidence_refs: list[str],
+) -> AnalysisFinding:
+    finding.statement = remove_thinking_blocks(statement).strip()[:4_000]
+    finding.finding_type = (finding_type.strip() or "finding")[:100]
+    finding.confidence = max(0.0, min(1.0, float(confidence)))
+    finding.critique = remove_thinking_blocks(critique).strip()[:4_000]
+    finding.scope_json = json_dumps(scope)
+    finding.evidence_refs_json = json_dumps(
+        unique_texts(text_list(finding.evidence_refs_json) + evidence_refs)
+    )
+    finding.contract_version = FINDING_CONTRACT_VERSION
+    return finding
+
+
 def get_owned_analysis_finding(
     session: Session,
     *,

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/api/v1/analysis.py

@@ -45,10 +45,12 @@ from gaard_api.analysis_findings import (
     create_analysis_finding,
     create_radar_finding_decision,
     format_working_knowledge,
+    get_analysis_finding_for_business_logic_suggestion,
     get_owned_analysis_finding,
     list_active_analysis_findings,
     list_owned_analysis_findings,
     record_finding_usage,
+    refresh_analysis_finding_observation,
     serialize_analysis_finding,
     serialize_finding_decision,
     serialize_working_knowledge_item,
@@ -1221,22 +1223,42 @@ def save_business_logic_finding(
             auto_enable=runtime_config.analysis_auto_enable_business_logic,
             actor=f"analysis:{session_id}",
         )
-        finding_record = create_analysis_finding(
+        critique = first_non_empty(
+            finding.critique,
+            "Confirmed only by evidence from this investigation and datasource.",
+        )
+        scope = finding_scope(finding, connector.connector_key, context)
+        evidence_refs = finding_evidence_refs(finding, context)
+        finding_record = get_analysis_finding_for_business_logic_suggestion(
             session,
             investigation_id=session_id,
             owner_user_id=record.user_id,
-            connector_id=connector.id,
             business_logic_suggestion_id=suggestion.id,
-            statement=statement,
-            finding_type=finding.knowledge_type,
-            confidence=finding.confidence,
-            critique=first_non_empty(
-                finding.critique,
-                "Confirmed only by evidence from this investigation and datasource.",
-            ),
-            scope=finding_scope(finding, connector.connector_key, context),
-            evidence_refs=finding_evidence_refs(finding, context),
         )
+        if finding_record is None:
+            finding_record = create_analysis_finding(
+                session,
+                investigation_id=session_id,
+                owner_user_id=record.user_id,
+                connector_id=connector.id,
+                business_logic_suggestion_id=suggestion.id,
+                statement=statement,
+                finding_type=finding.knowledge_type,
+                confidence=finding.confidence,
+                critique=critique,
+                scope=scope,
+                evidence_refs=evidence_refs,
+            )
+        else:
+            refresh_analysis_finding_observation(
+                finding_record,
+                statement=statement,
+                finding_type=finding.knowledge_type,
+                confidence=finding.confidence,
+                critique=critique,
+                scope=scope,
+                evidence_refs=evidence_refs,
+            )
         session.commit()
         finding_payload = serialize_analysis_finding(finding_record)
         return {

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api/main.py

@@ -40,7 +40,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 
 app = FastAPI(
     title="GAARD API",
-    version="0.2.17",
+    version="0.2.19",
     description="Self-hosted AI SQL Gateway for governed natural-language access to relational data.",
     lifespan=lifespan,
 )

{gaard_api-0.2.17 → gaard_api-0.2.19/src/gaard_api.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.2.17
+Version: 0.2.19
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: gaard-core==0.2.17
-Requires-Dist: gaard-connectors==0.2.17
-Requires-Dist: gaard-llm==0.2.17
+Requires-Dist: gaard-core==0.2.19
+Requires-Dist: gaard-connectors==0.2.19
+Requires-Dist: gaard-llm==0.2.19
 Requires-Dist: gaard-plugin-api<0.3.0,>=0.2.17
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.30.0

{gaard_api-0.2.17 → gaard_api-0.2.19}/src/gaard_api.egg-info/requires.txt

@@ -1,6 +1,6 @@
-gaard-core==0.2.17
-gaard-connectors==0.2.17
-gaard-llm==0.2.17
+gaard-core==0.2.19
+gaard-connectors==0.2.19
+gaard-llm==0.2.19
 gaard-plugin-api<0.3.0,>=0.2.17
 fastapi>=0.111.0
 uvicorn[standard]>=0.30.0

{gaard_api-0.2.17 → gaard_api-0.2.19}/tests/test_admin_api.py

@@ -11,7 +11,7 @@ import pytest
 from fastapi.testclient import TestClient
 from gaard_connectors import ConnectorNotFoundError, create_builtin_connector_registry
 from gaard_connectors.odbc.connection_string import parse_odbc_connection_string
-from gaard_core.errors import LlmProviderError, QueryPipelineStepError
+from gaard_core.errors import LlmProviderError, QueryExecutionError, QueryPipelineStepError
 from gaard_core.query_pipeline.mock_sql_generator import MockSqlGenerator
 from gaard_core.query_pipeline.models import (
     GeneratedSql,
@@ -19,6 +19,7 @@ from gaard_core.query_pipeline.models import (
     QueryIntentClassification,
     QueryIntentDecision,
     QueryRequest,
+    QueryResult,
 )
 from gaard_llm.providers.models import ChatCompletionRequest, ChatCompletionResponse
 from openpyxl import Workbook
@@ -1518,6 +1519,49 @@ def test_system_seeded_mock_runtime_modes_are_migrated_to_current_defaults(
     reset_metadata_store_for_tests()
 
 
+@pytest.mark.parametrize("updated_by", ["system", "admin"])
+def test_legacy_limit_prompt_is_upgraded_without_losing_customizations(
+    admin_client: TestClient,
+    updated_by: str,
+) -> None:
+    from gaard_core.prompt_compiler.models import SqlGenerationPromptRequest
+
+    from gaard_api.admin.prompt_runtime import MetadataSqlGenerationPromptCompiler
+
+    with create_session() as session:
+        prompt = session.scalar(
+            select(PromptTemplate).where(PromptTemplate.prompt_key == "sql_generation")
+        )
+        assert prompt is not None
+        prompt.system_prompt = (
+            "You must generate SQL for the {dialect} dialect.\n"
+            "6. Add LIMIT {max_rows} when the query may return many rows.\n"
+            "7. Do not add LIMIT to pure aggregate queries that return a single row, "
+            "unless it is already useful for the dialect or safety.\n"
+            "Custom rule: use the reporting schema."
+        )
+        prompt.updated_by = updated_by
+        prompt.version = 7
+        session.commit()
+        seed_prompts(session)
+        session.commit()
+        assert prompt.version == 8
+        if updated_by == "admin":
+            assert "Custom rule: use the reporting schema." in prompt.system_prompt
+            assert prompt.updated_by == "admin"
+        compiled = MetadataSqlGenerationPromptCompiler(prompt).compile(
+            SqlGenerationPromptRequest(
+                question="What is in abc?", formatted_schema="Table: abc",
+                dialect="tsql", max_rows=100,
+            )
+        )
+        assert "TOP (100)" in compiled.system_prompt
+        assert "LIMIT 100" not in compiled.system_prompt
+        seed_prompts(session)
+        session.commit()
+        assert prompt.version == 8
+
+
 def test_investigation_prompts_are_not_seeded(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -5481,6 +5525,21 @@ def test_sql_error_creates_datasource_scoped_business_logic_suggestion(
     assert edited["enabled"] is True
     assert "customer project orders" in get_active_business_logic_prompt_safe(connector_id)
 
+    repeated_response = admin_client.post(
+        "/api/v1/query", headers=headers,
+        json={"question": "Ktory pracownik zrealizowal najwiecej projektow", "user_id": "alice"},
+    )
+    assert repeated_response.status_code == 400
+    repeated_items = admin_client.get(
+        "/api/v1/admin/business-logic-suggestions", headers=headers,
+    ).json()["items"]
+    assert len(repeated_items) == 1
+    assert repeated_items[0]["id"] == edited["id"]
+    assert repeated_items[0]["enabled"] is True
+    assert repeated_items[0]["status"] == "active"
+    assert repeated_items[0]["title"] == edited["title"]
+    assert repeated_items[0]["rule_text"] == edited["rule_text"]
+
     empty_edit_response = admin_client.put(
         f"/api/v1/admin/business-logic-suggestions/{suggestions[0]['id']}",
         headers=headers,
@@ -5498,6 +5557,103 @@ def test_sql_error_creates_datasource_scoped_business_logic_suggestion(
     assert delete_response.json()["status"] == "deleted"
 
 
+@pytest.mark.parametrize("with_identifiers", [True, False])
+def test_mssql_sql_error_learning_preserves_manual_approval(
+    admin_client: TestClient,
+    monkeypatch: pytest.MonkeyPatch,
+    with_identifiers: bool,
+) -> None:
+    from gaard_api.api.v1 import query as query_api
+
+    headers = auth_headers(admin_client)
+    rule = "Use SELECT TOP (100) for row limits on this datasource; never use LIMIT."
+    stub_business_logic_learning_llm(monkeypatch, {
+        "create_suggestion": True, "error_category": "sql.dialect",
+        "title": "Use TOP instead of LIMIT", "rule_text": rule,
+        "failed_identifier": "LIMIT" if with_identifiers else "",
+        "repaired_identifier": "TOP" if with_identifiers else "",
+        "confidence": 0.95,
+    })
+    with create_session() as session:
+        for connector in session.scalars(select(DatasourceConnector)):
+            connector.active = False
+        connector = DatasourceConnector(
+            connector_key="mssql_abc", name="MSSQL ABC", database_type="mssql",
+            database_url="mssql+pyodbc://example.test/abc", sql_dialect="tsql", active=True,
+        )
+        session.add(connector)
+        session.flush()
+        session.add(DatasourceSchemaCache(
+            connector_id=connector.id, schema_json='{"tables":[]}',
+            table_settings_json="{}", formatted_schema="Table: abc\nColumns:\n- id: INTEGER",
+        ))
+        set_setting(session, "gaard_sql_generation_mode", "llm", "test")
+        set_setting(session, "gaard_intent_classification_mode", "mock", "test")
+        session.commit()
+
+    requests: list[ChatCompletionRequest] = []
+
+    class SqlClient:
+        def create_chat_completion(self, request: ChatCompletionRequest) -> ChatCompletionResponse:
+            requests.append(request)
+            sql = (
+                "SELECT * FROM abc LIMIT 100" if len(requests) <= 2
+                else "SELECT TOP (100) * FROM abc"
+            )
+            return ChatCompletionResponse(content=sql)
+
+    class MssqlExecutor:
+        def execute(self, sql: str) -> QueryResult:
+            if "LIMIT" in sql:
+                raise QueryExecutionError(
+                    "Incorrect syntax near LIMIT.", sql=sql,
+                    error_detail="[SQL Server] Incorrect syntax near 'LIMIT'.",
+                )
+            return QueryResult(columns=["id"], rows=[{"id": 1}])
+
+    monkeypatch.setattr(query_api, "create_llm_client", lambda config: SqlClient())
+    monkeypatch.setattr(
+        query_api, "create_datasource_executor", lambda *args, **kwargs: MssqlExecutor(),
+    )
+    payload = {"question": "What is in table abc?", "interpret": False}
+    assert admin_client.post("/api/v1/query", headers=headers, json=payload).status_code == 400
+    first = admin_client.get(
+        "/api/v1/admin/business-logic-suggestions", headers=headers,
+    ).json()["items"]
+    assert len(first) == 1 and first[0]["status"] == "pending"
+    suggestion_id = first[0]["id"]
+    approved = admin_client.put(
+        f"/api/v1/admin/business-logic-suggestions/{suggestion_id}",
+        headers=headers, json={"enabled": True},
+    )
+    assert approved.status_code == 200
+    assert approved.json()["item"]["status"] == "active"
+
+    # Force the model to repeat its error, even with the approved rule in its prompt.
+    assert admin_client.post("/api/v1/query", headers=headers, json=payload).status_code == 400
+    repeated = admin_client.get(
+        "/api/v1/admin/business-logic-suggestions", headers=headers,
+    ).json()["items"]
+    assert len(repeated) == 1
+    assert repeated[0]["id"] == suggestion_id
+    assert repeated[0]["enabled"] is True
+    assert repeated[0]["status"] == "active"
+    assert repeated[0]["updated_by"] == "admin"
+    assert rule in requests[1].messages[1].content
+    assert "tsql" in requests[1].messages[0].content
+    assert "TOP (100)" in requests[1].messages[0].content
+    assert "Add LIMIT" not in requests[1].messages[0].content
+    audit = admin_client.get(
+        "/api/v1/admin/audit/data-queries?audit_type=sql_error", headers=headers,
+    ).json()["items"][0]
+    assert audit["metadata"]["business_logic_learning"]["status"] == "active"
+
+    success = admin_client.post("/api/v1/query", headers=headers, json=payload)
+    assert success.status_code == 200
+    assert success.json()["sql"] == "SELECT TOP (100) * FROM abc"
+    assert rule in requests[2].messages[1].content
+
+
 def test_missing_column_sql_error_creates_business_logic_suggestion(
     admin_client: TestClient,
     tmp_path: Path,

{gaard_api-0.2.17 → gaard_api-0.2.19}/tests/test_analysis_api.py

@@ -376,6 +376,146 @@ def test_analysis_database_step_can_record_business_logic_suggestion(
         assert suggestions[0].error_category == "analysis.dictionary_value"
 
 
+def test_repeated_analysis_finding_preserves_review_decisions(
+    analysis_client: TestClient,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    headers = auth_headers(analysis_client)
+    connector = create_active_default_datasource()
+
+    def repeated_finding() -> analysis_module.AnalysisBusinessLogicFinding:
+        return analysis_module.AnalysisBusinessLogicFinding(
+            create_suggestion=True,
+            knowledge_type="semantic_mapping",
+            title="Cardiology dictionary mapping",
+            rule_text="The dictionary value for cardiology is cardiology.",
+            statement="The dictionary value for cardiology is cardiology.",
+            confidence=0.94,
+            critique="The mapping is confirmed only in the current datasource.",
+            scope={"entity": "specialization", "field": "specialization_name"},
+            evidence_refs=["query:dictionary-check"],
+        )
+
+    class RepeatedFindingPlanner:
+        def __init__(self) -> None:
+            self.calls = 0
+            self.working_knowledge_seen: list[list[dict[str, Any]]] = []
+
+        def decide(
+            self, request: Any, datasource_context: Any, context: dict[str, Any]
+        ) -> analysis_module.AnalysisPlannerDecision:
+            self.calls += 1
+            self.working_knowledge_seen.append(list(context.get("working_knowledge") or []))
+            return analysis_module.AnalysisPlannerDecision(
+                action=analysis_module.AnalysisAction.ASK_USER,
+                visible_question=f"Review mapping attempt {self.calls}.",
+                visible_reasoning="The same semantic mapping was observed again.",
+                user_question="Continue after review.",
+                business_logic=repeated_finding(),
+            )
+
+    planner = RepeatedFindingPlanner()
+    monkeypatch.setattr(analysis_module, "create_analysis_planner", lambda: planner)
+
+    response = analysis_client.post(
+        "/api/v1/analysis/stream",
+        headers=headers,
+        json={"question": "Find the cardiology dictionary value.", "user_id": "spoofed"},
+    )
+    assert response.status_code == 200
+    events = parse_ndjson(response.text)
+    session_id = events[0]["session_id"]
+    first_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in events
+        if item["event"] == "business_logic_suggestion"
+    )
+    finding_id = first_suggestion["finding_id"]
+
+    radar_decision_payload = {
+        "finding_id": finding_id,
+        "decision": "accept_for_investigation",
+        "confidence": 0.93,
+        "verdict": "The observed values explain the terminology lookup.",
+        "scope": {
+            "investigation_id": session_id,
+            "radar_run_id": "radar-repeat-1",
+        },
+        "evidence_refs": ["query:dictionary-check"],
+    }
+    accepted_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/finding-decisions",
+        headers=headers,
+        json=radar_decision_payload,
+    )
+    assert accepted_response.status_code == 200
+    assert accepted_response.json()["accepted"] is True
+
+    repeat_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/messages/stream",
+        headers=headers,
+        json={"message": "Continue."},
+    )
+    assert repeat_response.status_code == 200
+    repeat_events = parse_ndjson(repeat_response.text)
+    repeated_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in repeat_events
+        if item["event"] == "business_logic_suggestion"
+    )
+    assert repeated_suggestion["finding_id"] == finding_id
+    assert repeated_suggestion["finding"]["status"] == "accepted_for_investigation"
+    assert planner.working_knowledge_seen[-1][0]["finding_id"] == finding_id
+
+    persistent_response = analysis_client.put(
+        f"/api/v1/analysis/{session_id}/findings/{finding_id}/decision",
+        headers=headers,
+        json={
+            "finding_id": finding_id,
+            "decision": "accept_as_persistent_business_logic",
+            "confidence": 0.93,
+            "verdict": "An administrator approved this as durable logic.",
+            "scope": {"investigation_id": session_id},
+            "evidence_refs": ["query:dictionary-check"],
+        },
+    )
+    assert persistent_response.status_code == 200
+
+    repeat_after_persistent_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/messages/stream",
+        headers=headers,
+        json={"message": "Continue again."},
+    )
+    assert repeat_after_persistent_response.status_code == 200
+    repeat_after_persistent_events = parse_ndjson(repeat_after_persistent_response.text)
+    repeated_persistent_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in repeat_after_persistent_events
+        if item["event"] == "business_logic_suggestion"
+    )
+    assert repeated_persistent_suggestion["finding_id"] == finding_id
+    assert repeated_persistent_suggestion["finding"]["status"] == (
+        "accepted_as_persistent_business_logic"
+    )
+
+    with create_session() as session:
+        findings = list(
+            session.scalars(
+                select(AnalysisFinding).where(
+                    AnalysisFinding.investigation_id == session_id
+                )
+            )
+        )
+        assert len(findings) == 1
+        assert findings[0].finding_id == finding_id
+        assert findings[0].decision == "accept_as_persistent_business_logic"
+        assert findings[0].status == "accepted_as_persistent_business_logic"
+        suggestions = list_business_logic_suggestions(session, connector.id)
+        assert len(suggestions) == 1
+        assert suggestions[0].enabled is True
+        assert suggestions[0].status == "active"
+
+
 def test_investigation_finding_review_lifecycle_and_scoped_working_knowledge(
     analysis_client: TestClient,
     monkeypatch: pytest.MonkeyPatch,