ltcai 9.7.0 → 9.8.0

package/latticeai/api/chat_stream.py

@@ -52,8 +52,14 @@ async def stream_chat(
     history_meta: Optional[Dict[str, Any]] = None,
     model_id: Optional[str] = None,
     workspace_id: Optional[str] = None,
+    context_quality: Optional[Dict[str, Any]] = None,
 ) -> AsyncIterator[str]:
-    """Stream model chunks and persist exactly one finalized answer."""
+    """Stream model chunks and persist exactly one finalized answer.
+
+    ``context_quality`` (v9.8.0, additive) is echoed on the final trailer
+    event alongside the answer trace so streaming clients receive the same
+    honest RAG signal as the non-streaming JSON response.
+    """
 
     full_response = ""
     stream_error: Optional[str] = None
@@ -106,6 +112,8 @@ async def stream_chat(
     trailer: Dict[str, Any] = {"chunk": "", "model": model_id}
     if trace_record:
         trailer.update({"trace_id": trace_record["id"], "trace": trace_record})
+    if context_quality is not None:
+        trailer["context_quality"] = context_quality
     if stream_error:
         trailer["error"] = stream_error
     yield f"data: {json.dumps(trailer, ensure_ascii=False)}\n\n"

package/latticeai/api/local_files.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Optional
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 from fastapi.responses import FileResponse
 from pydantic import BaseModel
 
@@ -37,6 +37,18 @@ class LocalWriteRequest(BaseModel):
     approval_token: Optional[str] = None
 
 
+class FolderIngestRequest(BaseModel):
+    path: str
+    recursive: bool = True
+    background: bool = False
+    workspace_id: Optional[str] = None
+    # Local filesystem reads follow the standard approval dance (same as
+    # /local/read and /knowledge-graph/local/index): the first call returns a
+    # permission_required payload with an approval token.
+    approved: bool = False
+    approval_token: Optional[str] = None
+
+
 def create_local_files_router(
     *,
     require_user,
@@ -194,6 +206,107 @@ def create_local_files_router(
             raise HTTPException(status_code=404, detail="File not found")
         return FileResponse(str(target))
 
+    # ── v9.8.0 ingestion jobs API (frozen paths — consumed by the frontend) ───
+    def _require_pipeline():
+        if ingestion_pipeline is None or not ingestion_pipeline.available():
+            raise HTTPException(status_code=503, detail="Knowledge Graph ingestion is disabled.")
+
+    def _ingestion_write_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
+        header = request.headers.get("X-Workspace-Id")
+        header = header.strip() if header and header.strip() else None
+        supplied = [value for value in (body_workspace, header) if value]
+        if len(set(supplied)) > 1:
+            raise HTTPException(status_code=403, detail="Workspace selectors must match.")
+        requested = supplied[0] if supplied else None
+        if workspace_service is None:
+            return requested
+        try:
+            return workspace_service.resolve_write_scope(requested, user or None)
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+
+    @router.get("/api/ingestion/jobs")
+    async def ingestion_jobs(request: Request, limit: int = 20):
+        """Recent background ingestion jobs (newest first)."""
+        require_user(request)
+        _require_pipeline()
+        limit = max(1, min(int(limit or 20), 100))
+        return {"jobs": ingestion_pipeline.list_background_jobs(limit=limit)}
+
+    @router.get("/api/ingestion/jobs/{job_id}")
+    async def ingestion_job_detail(job_id: str, request: Request):
+        """One job with its progress counters and (capped) error records."""
+        require_user(request)
+        _require_pipeline()
+        job = ingestion_pipeline.get_background_job(job_id)
+        if job is None:
+            raise HTTPException(status_code=404, detail="ingestion job not found")
+        return job.as_dict()
+
+    @router.post("/api/ingestion/jobs/{job_id}/resume")
+    async def ingestion_job_resume(job_id: str, request: Request, background_tasks: BackgroundTasks):
+        """Resume an interrupted/partial/failed job from its remaining items."""
+        user = require_user(request)
+        _require_pipeline()
+        job = ingestion_pipeline.get_background_job(job_id)
+        if job is None:
+            raise HTTPException(status_code=404, detail="ingestion job not found")
+        if job.status == "running":
+            return {"status": "already_running", "job_id": job_id, "job": job.as_dict()}
+        remaining = len(job.remaining_indices())
+        if remaining == 0 and job.status == "completed":
+            return {"status": "nothing_to_resume", "job_id": job_id, "job": job.as_dict()}
+        background_tasks.add_task(
+            ingestion_pipeline.resume_background_job, job_id, user_email=user or None,
+        )
+        return {
+            "status": "resuming",
+            "job_id": job_id,
+            "remaining": remaining,
+            "job": job.as_dict(),
+        }
+
+    @router.post("/api/ingestion/folder")
+    async def ingestion_folder(req: FolderIngestRequest, request: Request, background_tasks: BackgroundTasks):
+        """Ingest a local folder through the unified pipeline.
+
+        Reads local disk, so it follows the same approval dance as
+        ``/local/read`` and ``/knowledge-graph/local/index``: without
+        ``approved`` + ``approval_token`` the response is a
+        ``permission_required`` payload. ``background=true`` schedules a job
+        (summary includes ``job_id``) and executes it after the response.
+        """
+        current_user = permission_gateway.require_local_user(request)
+        _require_pipeline()
+        workspace_id = _ingestion_write_workspace(request, req.workspace_id, current_user)
+        path = (req.path or "").strip()
+        if not path:
+            raise HTTPException(status_code=400, detail="path is required.")
+        if not req.approved:
+            return permission_gateway.local_permission_response(path, "read", current_user)
+        permission_gateway.require_local_approval(
+            token=req.approval_token,
+            path=path,
+            action="read",
+            user_email=current_user,
+        )
+        summary = ingestion_pipeline.ingest_folder(
+            path,
+            recursive=req.recursive,
+            background=req.background,
+            owner=current_user or None,
+            workspace_id=workspace_id,
+            user_email=current_user or None,
+        )
+        job_id = summary.get("job_id")
+        if req.background and job_id:
+            # Execute after the response is sent; progress is visible via
+            # GET /api/ingestion/jobs/{job_id}.
+            background_tasks.add_task(
+                ingestion_pipeline.run_background_job, job_id, user_email=current_user or None,
+            )
+        return summary
+
     @router.post("/local/write")
     async def local_write_endpoint(req: LocalWriteRequest, request: Request):
         current_user = permission_gateway.require_local_user(request)
@@ -238,4 +351,9 @@ def create_local_files_router(
     return router
 
 
-__all__ = ["LocalAccessRequest", "LocalWriteRequest", "create_local_files_router"]
+__all__ = [
+    "FolderIngestRequest",
+    "LocalAccessRequest",
+    "LocalWriteRequest",
+    "create_local_files_router",
+]

package/latticeai/core/agent_eval.py

@@ -52,6 +52,24 @@ _GOVERNED_WRITE_POLICY = {
     "destructive": False, "sandbox": "workspace", "rollback": "git",
 }
 
+# Deterministic Brain-port fixtures. Grounding scenarios assert their final
+# message against these exact values (node ids, concepts, snippets), so a
+# response that was not derived from the tool result — a hallucination in
+# loop terms — cannot pass.
+_EVAL_INGEST_RESULT = {
+    "ok": True,
+    "node_id": "node-ing-1",
+    "concepts": ["mlx", "quantization"],
+    "relations": [{"from": "mlx", "to": "quantization", "type": "related_to"}],
+}
+_EVAL_SEARCH_RESULT = {
+    "ok": True,
+    "matches": [
+        {"id": "node-42", "title": "Q3 roadmap", "snippet": "ship v9.8 by August"}
+    ],
+    "count": 1,
+}
+
 
 class _EvalChangeGovernor:
     """Deterministic stand-in for ChangeProposalService's governor port.
@@ -99,6 +117,11 @@ class Scenario:
     expect_tool_calls: List[str] = field(default_factory=list)
     # Wire a change governor so governed tools follow the proposal path.
     use_governor: bool = False
+    # Substrings the final user-facing message must contain. Grounding
+    # scenarios point these at tokens that only exist in the fake tool port's
+    # canned results (node ids, snippets, proposal ids), so an answer that is
+    # not grounded in the retrieved/executed evidence fails the scenario.
+    expect_final_contains: List[str] = field(default_factory=list)
     max_steps: int = 8
 
 
@@ -136,6 +159,12 @@ def _build_deps(
         if name in ("write_file", "generate_file") and not args.get("path"):
             raise ToolError(f"{name} requires args.path")
         tool_log.append({"name": name, "args": args})
+        # Brain ports return canned, stable payloads so grounding scenarios
+        # can assert the final answer cites what was actually retrieved.
+        if name == "knowledge_graph_ingest":
+            return dict(_EVAL_INGEST_RESULT)
+        if name == "knowledge_graph_search":
+            return dict(_EVAL_SEARCH_RESULT)
         return {"ok": True, "path": args.get("path", "")}
 
     def policy_for(name: str, args: dict) -> dict:
@@ -157,6 +186,8 @@ def _build_deps(
             "write_file": write_policy,
             "read_file": dict(_AUTO_POLICY),
             "generate_file": dict(_AUTO_POLICY),
+            "knowledge_graph_ingest": dict(_AUTO_POLICY),
+            "knowledge_graph_search": dict(_AUTO_POLICY),
             "delete_everything": dict(_DESTRUCTIVE_POLICY),
         },
         file_create_actions=frozenset({"write_file", "generate_file"}),
@@ -333,6 +364,95 @@ def default_scenarios() -> List[Scenario]:
             expect_tool_outcomes={"proposed": 1, "ok": 1},
             expect_tool_calls=["write_file"],
         ),
+        # ── brain ingestion ─────────────────────────────────────────────
+        Scenario(
+            name="ingestion-chain-confirms-save",
+            replies=[
+                '{"action": "plan", "goal": "ingest web article into the Brain", '
+                '"steps": [{"action": "knowledge_graph_ingest"}]}',
+                # Weak-model dressing (think block) around a clean ingest call.
+                "<think>save the text first, then confirm with the node id</think>\n"
+                '{"thoughts": "ingest the pasted article", '
+                '"action": "knowledge_graph_ingest", "args": {"source": "web", '
+                '"url": "https://example.com/mlx-notes", '
+                '"text": "MLX quantization notes"}}',
+                # Confirmation cites the node id the ingest port returned —
+                # the loop must carry the tool result into the final turn.
+                '{"action": "final", "message": "Saved to the Brain as node-ing-1."}',
+                _PASS,
+            ],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["knowledge_graph_ingest"],
+            expect_final_contains=["node-ing-1"],
+        ),
+        # ── concept extraction ──────────────────────────────────────────
+        Scenario(
+            name="concept-extraction-reflected-in-answer",
+            replies=[
+                '{"action": "plan", "goal": "ingest the note and report extracted concepts", '
+                '"steps": [{"action": "knowledge_graph_ingest"}]}',
+                '{"thoughts": "ingest the file so the pipeline extracts concepts", '
+                '"action": "knowledge_graph_ingest", "args": {"source": "file", '
+                '"path": "notes/mlx.md", "text": "quantization on MLX"}}',
+                # The confirmation must surface what the pipeline extracted
+                # (concepts + relation), not merely say "done".
+                '{"action": "final", "message": "Ingested notes/mlx.md - extracted '
+                'concepts mlx and quantization (mlx -> quantization, related_to)."}',
+                _PASS,
+            ],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["knowledge_graph_ingest"],
+            expect_final_contains=["mlx", "quantization", "related_to"],
+        ),
+        # ── RAG-grounded answer ─────────────────────────────────────────
+        Scenario(
+            name="rag-grounded-answer-cites-retrieval",
+            replies=[
+                '{"action": "plan", "goal": "answer from the Brain, not from priors", '
+                '"steps": [{"action": "knowledge_graph_search"}]}',
+                '{"thoughts": "retrieve evidence before answering", '
+                '"action": "knowledge_graph_search", "args": {"query": "Q3 roadmap"}}',
+                # Grounded: cites the retrieved node id and snippet — both exist
+                # only in the fake port's canned search result, so an ungrounded
+                # (hallucinated) final message cannot satisfy the expectation.
+                '{"action": "final", "message": "Per Q3 roadmap (node-42): ship v9.8 by August."}',
+                _PASS,
+            ],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["knowledge_graph_search"],
+            expect_final_contains=["node-42", "ship v9.8 by August"],
+        ),
+        # ── automation suggestion under proposal-first governance ───────
+        Scenario(
+            name="automation-suggestion-proposal-first",
+            use_governor=True,
+            replies=[
+                '{"action": "plan", "goal": "recurring daily question detected - stage a '
+                'digest automation for review", '
+                '"steps": [{"action": "knowledge_graph_search"}, {"action": "write_file"}]}',
+                # Evidence first: confirm the repeated pattern from the Brain.
+                '{"thoughts": "confirm the pattern is real before suggesting automation", '
+                '"action": "knowledge_graph_search", '
+                '"args": {"query": "recurring question daily digest"}}',
+                # Proposal-first: changing existing automation state is a
+                # mutation, so the governor stages it as a review proposal —
+                # the model can never silently install/enable an automation.
+                '{"thoughts": "stage the automation as a reviewable proposal", '
+                '"action": "write_file", '
+                '"args": {"path": "existing/automations/daily-digest.json", '
+                '"content": "trigger interval, disabled draft, review_queue"}}',
+                '{"action": "final", "message": "Automation staged for review as '
+                'eval-proposal-1 - enable it from the review queue."}',
+                _PASS,
+            ],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1, "proposed": 1},
+            expect_tool_calls=["knowledge_graph_search"],
+            expect_final_contains=["eval-proposal-1", "review"],
+        ),
     ]
 
 
@@ -370,6 +490,9 @@ async def _run_scenario(scenario: Scenario) -> Dict[str, Any]:
     executed = [call["name"] for call in tool_log]
     if scenario.expect_tool_calls and executed != scenario.expect_tool_calls:
         failures.append(f"tool_calls={executed} != {scenario.expect_tool_calls}")
+    for needle in scenario.expect_final_contains:
+        if needle not in ctx.final_message:
+            failures.append(f"final_message missing {needle!r}")
     if governor is not None and summary["tool_outcomes"].get("proposed", 0) != len(governor.proposals):
         failures.append(
             f"governor proposals={len(governor.proposals)} != "

package/latticeai/core/legacy_compatibility.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
-LEGACY_COMPATIBILITY_VERSION = "9.7.0"
+LEGACY_COMPATIBILITY_VERSION = "9.8.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "9.7.0"
+MARKETPLACE_VERSION = "9.8.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/workspace_os.py

@@ -49,7 +49,7 @@ __all__ = [
     "remove_skill_directory",
 ]
 
-WORKSPACE_OS_VERSION = "9.7.0"
+WORKSPACE_OS_VERSION = "9.8.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/services/architecture_readiness.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
 
-ARCHITECTURE_VERSION_TARGET = "9.7.0"
+ARCHITECTURE_VERSION_TARGET = "9.8.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/automation_intelligence.py

@@ -22,6 +22,14 @@ automation suggestions:
 
 Every suggestion id is deterministic, so install calls are idempotent and the
 UI can safely re-request suggestions without duplicates.
+
+v9.8.0 quality layer (additive): every suggestion carries a deterministic
+``confidence`` score plus its ``confidence_factors`` evidence (repeat count,
+distinct phrasings, intent match, related Brain nodes / indexed files);
+suggestions below a minimum confidence are suppressed, duplicate suggestions
+targeting an already-suggested or already-installed starter recipe are
+deduplicated, and the response reports the suppression counters under
+``quality``.
 """
 
 from __future__ import annotations
@@ -40,6 +48,50 @@ _MIN_PATTERN_COUNT = 2
 _MAX_HISTORY = 4000
 _SIGNATURE_SIMILARITY = 0.6
 
+# Suggestion quality gates (v9.8.0, additive). Suggestions below the minimum
+# confidence are suppressed (insufficient evidence); suggestions between the
+# minimum and the low-confidence threshold are shown but flagged so the UI
+# can render them less prominently.
+_MIN_SUGGESTION_CONFIDENCE = 0.35
+_LOW_CONFIDENCE_THRESHOLD = 0.5
+_KG_GROUNDING_LIMIT = 5
+
+
+def _question_confidence(
+    count: int,
+    examples: List[str],
+    recipe_id: Optional[str],
+    kg_related: Optional[int],
+) -> tuple:
+    """Deterministic confidence for a recurring-question suggestion.
+
+    Evidence factors: how often the question repeats, how many distinct
+    phrasings exist, whether it maps onto a known starter-recipe intent, and
+    (when the graph is available) how many Brain nodes relate to it.
+    """
+    score = 0.3 + 0.5 * min(1.0, (int(count) - 1) / 4)
+    score += min(0.15, 0.05 * len(examples or []))
+    if recipe_id:
+        score += 0.15
+    if kg_related:
+        score += min(0.2, 0.05 * int(kg_related))
+    factors = {
+        "repeat_count": int(count),
+        "distinct_examples": len(examples or []),
+        "intent_match": bool(recipe_id),
+        "kg_related_nodes": kg_related,
+    }
+    return round(min(1.0, score), 2), factors
+
+
+def _source_confidence(indexed: int, watch_enabled: bool) -> tuple:
+    """Deterministic confidence for a knowledge-source digest suggestion."""
+    score = 0.25 + 0.6 * min(1.0, int(indexed) / 25)
+    if watch_enabled:
+        score += 0.1
+    factors = {"indexed_files": int(indexed), "watch_enabled": bool(watch_enabled)}
+    return round(min(1.0, score), 2), factors
+
 _QUESTION_HINT_RE = re.compile(
     r"(\?|어때|뭐야|뭐가|뭘까|알려줘|보여줘|정리해|요약해|정리 좀|요약 좀|해줘"
     r"|what|how|why|when|where|status|summar|remind|list|show me|tell me)",
@@ -223,38 +275,101 @@ class AutomationIntelligenceService:
             LOGGER.exception("automation intelligence source read failed")
             return []
 
+    def _kg_related_count(
+        self, text: str, *, workspace_id: Optional[str]
+    ) -> Optional[int]:
+        """Count Brain nodes related to a recurring question (grounding evidence).
+
+        Returns ``None`` when the graph is unavailable so confidence scoring can
+        distinguish "grounding impossible" from "grounded with zero hits".
+        Scoping mirrors the conversation-history read: an explicit workspace is
+        strict, no workspace falls back to the unscoped/legacy view.
+        """
+        if not self._enable_graph or not hasattr(self._kg, "search"):
+            return None
+        try:
+            report = self._kg.search(
+                str(text or "")[:200],
+                limit=_KG_GROUNDING_LIMIT,
+                allowed_workspaces={workspace_id} if workspace_id is not None else None,
+                include_legacy_global=workspace_id is None,
+            )
+        except Exception:
+            LOGGER.exception("automation intelligence KG grounding failed")
+            return None
+        if not isinstance(report, dict):
+            return None
+        return len(report.get("matches") or [])
+
     # ── suggestions ──────────────────────────────────────────────────────
 
-    def _installed_suggestion_ids(self, *, workspace_id: Optional[str]) -> Dict[str, Dict[str, Any]]:
-        installed: Dict[str, Dict[str, Any]] = {}
+    def _installed_workflows(
+        self, *, workspace_id: Optional[str]
+    ) -> tuple:
+        """Map installed automation workflows by suggestion id and recipe id.
+
+        The recipe map lets a recurring-question suggestion that targets an
+        already-installed starter recipe surface as *installed* instead of
+        re-suggesting the same automation — the install API is idempotent on
+        exactly this provenance, so the read side must agree.
+        """
+        by_suggestion: Dict[str, Dict[str, Any]] = {}
+        by_recipe: Dict[str, Dict[str, Any]] = {}
         if self._store is None:
-            return installed
+            return by_suggestion, by_recipe
         try:
             workflows = self._store.list_workflows(workspace_id=workspace_id).get("workflows") or []
         except Exception:
             LOGGER.exception("automation intelligence workflow read failed")
-            return installed
+            return by_suggestion, by_recipe
         for workflow in workflows:
             metadata = (workflow or {}).get("metadata") or {}
-            suggestion_id = metadata.get("suggestion_id")
-            if metadata.get("created_from") == "automation_suggestion" and suggestion_id:
-                installed[str(suggestion_id)] = workflow
-        return installed
+            created_from = metadata.get("created_from")
+            if created_from == "automation_suggestion" and metadata.get("suggestion_id"):
+                by_suggestion[str(metadata["suggestion_id"])] = workflow
+            elif created_from == "brain_automation_recipe" and metadata.get("recipe_id"):
+                by_recipe[str(metadata["recipe_id"])] = workflow
+        return by_suggestion, by_recipe
 
     def suggestions(
         self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
     ) -> Dict[str, Any]:
         pattern_report = self.question_patterns(user_email=user_email, workspace_id=workspace_id)
-        installed = self._installed_suggestion_ids(workspace_id=workspace_id)
+        by_suggestion, by_recipe = self._installed_workflows(workspace_id=workspace_id)
 
         items: List[Dict[str, Any]] = []
+        suppressed_low_confidence = 0
+        suppressed_duplicates = 0
+        seen_recipe_ids: set = set()
+
+        # Patterns arrive sorted by (count, last_asked) desc, so the first
+        # suggestion per recipe is the strongest — later ones targeting the
+        # same recipe would install the identical workflow and are suppressed.
         for pattern in pattern_report["patterns"]:
+            recipe_id = pattern["recipe_id"]
+            if recipe_id and recipe_id in seen_recipe_ids:
+                suppressed_duplicates += 1
+                continue
+            kg_related = self._kg_related_count(
+                pattern["representative"], workspace_id=workspace_id
+            )
+            confidence, factors = _question_confidence(
+                pattern["count"], pattern["examples"], recipe_id, kg_related
+            )
+            if confidence < _MIN_SUGGESTION_CONFIDENCE:
+                suppressed_low_confidence += 1
+                continue
+            if recipe_id:
+                seen_recipe_ids.add(recipe_id)
             suggestion_id = _stable_id("sug-q", pattern["id"])
+            workflow = by_suggestion.get(suggestion_id) or (
+                by_recipe.get(str(recipe_id)) if recipe_id else None
+            )
             items.append({
                 "id": suggestion_id,
                 "kind": "recurring_question",
                 "intent": pattern["intent"],
-                "recipe_id": pattern["recipe_id"],
+                "recipe_id": recipe_id,
                 "title": pattern["representative"],
                 "reason": {
                     "type": "repeated_question",
@@ -263,8 +378,11 @@ class AutomationIntelligenceService:
                     "examples": pattern["examples"],
                 },
                 "cadence": "daily",
-                "installed": suggestion_id in installed,
-                "workflow_id": (installed.get(suggestion_id) or {}).get("id"),
+                "confidence": confidence,
+                "confidence_factors": factors,
+                "low_confidence": confidence < _LOW_CONFIDENCE_THRESHOLD,
+                "installed": workflow is not None,
+                "workflow_id": (workflow or {}).get("id"),
             })
 
         for source in self._knowledge_sources():
@@ -272,6 +390,14 @@ class AutomationIntelligenceService:
             indexed = sum(int(v or 0) for v in file_status.values())
             if indexed <= 0:
                 continue
+            confidence, factors = _source_confidence(
+                indexed, bool(source.get("watch_enabled"))
+            )
+            if confidence < _MIN_SUGGESTION_CONFIDENCE:
+                # A barely-indexed folder is not enough evidence for a digest
+                # automation yet — do not suggest.
+                suppressed_low_confidence += 1
+                continue
             suggestion_id = _stable_id("sug-src", str(source.get("id") or source.get("root_path") or ""))
             items.append({
                 "id": suggestion_id,
@@ -286,13 +412,22 @@ class AutomationIntelligenceService:
                     "watch_enabled": bool(source.get("watch_enabled")),
                 },
                 "cadence": "when new knowledge arrives",
-                "installed": suggestion_id in installed,
-                "workflow_id": (installed.get(suggestion_id) or {}).get("id"),
+                "confidence": confidence,
+                "confidence_factors": factors,
+                "low_confidence": confidence < _LOW_CONFIDENCE_THRESHOLD,
+                "installed": suggestion_id in by_suggestion,
+                "workflow_id": (by_suggestion.get(suggestion_id) or {}).get("id"),
             })
 
         return {
             "suggestions": items,
             "questions_scanned": pattern_report["questions_scanned"],
+            "quality": {
+                "min_confidence": _MIN_SUGGESTION_CONFIDENCE,
+                "low_confidence_threshold": _LOW_CONFIDENCE_THRESHOLD,
+                "suppressed_low_confidence": suppressed_low_confidence,
+                "suppressed_duplicates": suppressed_duplicates,
+            },
             "consent": {
                 "default_state": "draft_disabled",
                 "local_only": True,
@@ -403,6 +538,7 @@ class AutomationIntelligenceService:
                 "suggestion_kind": kind,
                 "suggestion_title": title,
                 "suggestion_reason": suggestion.get("reason"),
+                "suggestion_confidence": suggestion.get("confidence"),
                 "automation_state": "enabled" if enabled else "draft_disabled",
                 "local_only": True,
                 "external_actions": False,
@@ -442,6 +578,7 @@ class AutomationIntelligenceService:
             "suggestions": suggestion_report["suggestions"],
             "questions_scanned": suggestion_report["questions_scanned"],
             "installed": installed,
+            "quality": suggestion_report["quality"],
             "consent": suggestion_report["consent"],
             "generated_at": _now(),
         }