ltcai 9.9.1 → 9.9.3

package/latticeai/services/app_context.py

@@ -34,11 +34,17 @@ class AppContext:
     chat_service: Any = None
     context_assembler: Any = None
     brain_memory: Any = None
+    # Unified ingestion gateway (lattice_brain.ingestion.IngestionPipeline);
+    # None when the knowledge graph is disabled.
+    ingestion_pipeline: Any = None
     chat_agent_runtime: Any = None
     gardener: Any = None
     hooks: Any = None
     realtime_bus: Any = None
     capability_registry: Any = None
+    # UX funnel metrics (latticeai.services.funnel_metrics); None in tests
+    # that don't observe the funnel — every increment site is nil-safe.
+    funnel_metrics: Any = None
 
     # ── auth / session callables ──────────────────────────────────────────
     require_user: Optional[Callable[..., str]] = None

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.9.1"
+ARCHITECTURE_VERSION_TARGET = "9.9.3"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/automation_execution.py

@@ -0,0 +1,266 @@
+"""Automation "run now" support: dry-run reports + execution log surfacing.
+
+Backlog #6 (review §7.2 F, Wave 2): after installing an automation the user
+should be able to run it once immediately — first as a **dry run** that
+reports exactly what WOULD happen without side effects, then for real — and
+every automation card should show its last execution result.
+
+This module owns the deterministic policy pieces:
+
+* :func:`dry_run_report` — walks the workflow's node graph (same normalizer
+  as the engine) and describes each step without invoking any runner. No
+  model call, no store write, no side effects.
+* :func:`build_last_execution` / :func:`summarize_workflow_run` — the compact
+  ``last_execution`` record persisted on the workflow's metadata and surfaced
+  by the automation overview + daily briefing.
+* :func:`last_execution_view` — read-side merge: the stamped metadata record
+  vs. the newest persisted workflow run (so trigger-driven runs surface too).
+* :func:`enqueue_failed_execution` — failed live executions become a review
+  queue item (source ``workflow_run``, kind ``automation_failure``) so
+  failures land in the same inbox as every other automation outcome.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from latticeai.core.timeutil import now_iso as _now
+
+LOGGER = logging.getLogger(__name__)
+
+AUTOMATION_CREATED_FROM = frozenset({
+    "automation_suggestion",
+    "brain_automation_recipe",
+})
+
+_TRIGGER_LABEL = {
+    "interval": "wait for the user-enabled schedule",
+    "brain_event": "wait for new Brain knowledge",
+    "manual": "start when the user asks",
+}
+
+
+def is_automation_workflow(workflow: Dict[str, Any]) -> bool:
+    metadata = (workflow or {}).get("metadata") or {}
+    return metadata.get("created_from") in AUTOMATION_CREATED_FROM
+
+
+def dry_run_report(workflow: Dict[str, Any]) -> Dict[str, Any]:
+    """Describe what a run WOULD do — deterministically, with no side effects.
+
+    Walks the normalized node chain (``trigger`` first, then ``next``
+    pointers) and emits one human-readable step per node. Nothing is
+    executed: no runner, no model, no store write.
+    """
+    from lattice_brain.workflow import normalize_definition, validate_definition
+
+    definition = normalize_definition(workflow or {})
+    errors = validate_definition(definition)
+    metadata = definition.get("metadata") or {}
+    steps: List[Dict[str, Any]] = []
+
+    nodes = {node.get("id"): node for node in definition.get("nodes") or []}
+    current = next(
+        (node for node in definition.get("nodes") or [] if node.get("type") == "trigger"),
+        None,
+    )
+    visited: set = set()
+    while current is not None and current.get("id") not in visited:
+        visited.add(current.get("id"))
+        ntype = str(current.get("type") or "")
+        config = current.get("config") or {}
+        if ntype == "trigger":
+            would = _TRIGGER_LABEL.get(
+                str(config.get("trigger") or "manual"),
+                "start when triggered",
+            )
+            would = f"skipped in a manual run ({would})"
+        elif ntype == "agent":
+            prompt = str(config.get("prompt") or config.get("goal") or "")[:160]
+            would = f"ask the local agent to draft: {prompt}" if prompt else (
+                "ask the local agent to draft a review item"
+            )
+        elif ntype == "tool":
+            would = f"run tool '{config.get('tool') or current.get('name') or 'tool'}'"
+        elif ntype == "skill":
+            would = f"run skill '{config.get('skill') or current.get('name') or 'skill'}'"
+        elif ntype == "plugin":
+            would = f"run plugin '{config.get('plugin') or current.get('name') or 'plugin'}'"
+        elif ntype == "condition":
+            would = "evaluate a branch condition"
+        elif ntype == "output":
+            would = "deliver the draft to the review inbox"
+        else:
+            would = f"run node '{current.get('id')}'"
+        steps.append({
+            "node": current.get("id"),
+            "type": ntype,
+            "name": current.get("name") or current.get("id"),
+            "would": would,
+        })
+        next_id = current.get("next")
+        current = nodes.get(next_id) if next_id else None
+
+    executable = [s for s in steps if s["type"] not in {"trigger", "output", "condition"}]
+    creates = list(metadata.get("creates") or [])
+    if errors:
+        summary = "invalid workflow: " + "; ".join(errors[:3])
+        status = "invalid"
+    else:
+        summary = (
+            f"{len(executable)} step(s) would run locally and produce a reviewable draft"
+        )
+        if creates:
+            summary += " (" + ", ".join(str(c) for c in creates[:3]) + ")"
+        summary += "; no external actions, nothing is written until you approve."
+        status = "ok"
+    return {
+        "mode": "dry_run",
+        "status": status,
+        "steps": steps,
+        "summary": summary,
+        "side_effects": False,
+        "validation_errors": errors,
+    }
+
+
+def build_last_execution(
+    *,
+    mode: str,
+    status: str,
+    summary: str,
+    run_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """The compact per-automation execution record (persisted on metadata)."""
+    return {
+        "mode": mode,                     # dry_run | live
+        "status": status,                 # ok | failed | running | partial | ...
+        "summary": str(summary or "")[:300],
+        "run_id": run_id,
+        "finished_at": _now(),
+    }
+
+
+def summarize_workflow_run(run: Dict[str, Any]) -> str:
+    """One honest line for a persisted workflow run."""
+    status = str(run.get("status") or "unknown")
+    timeline = run.get("timeline") or []
+    if status == "failed":
+        detail = ""
+        for entry in reversed(timeline):
+            if entry.get("status") in {"failed", "error"}:
+                detail = str(
+                    entry.get("reason") or entry.get("detail") or entry.get("errors") or ""
+                )[:160]
+                break
+        if not detail:
+            detail = str((run.get("outputs") or {}).get("error") or "")[:160]
+        return f"failed after {len(timeline)} step(s)" + (f": {detail}" if detail else "")
+    if status == "awaiting_approval":
+        return "paused — a step needs your approval before it can run"
+    if status in {"queued", "running", "cancelling"}:
+        return "still running"
+    return f"{status} — {len(timeline)} step(s) recorded"
+
+
+def last_execution_view(
+    workflow: Dict[str, Any],
+    *,
+    store: Any = None,
+    workspace_id: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Read-side ``last_execution``: stamped metadata vs. newest persisted run.
+
+    Run-now stamps ``metadata.last_execution`` directly; trigger/background
+    runs only leave workflow-run rows. Whichever is newer wins so the card is
+    honest about the latest execution regardless of how it was started.
+    """
+    metadata = (workflow or {}).get("metadata") or {}
+    stamped = metadata.get("last_execution")
+    stamped = dict(stamped) if isinstance(stamped, dict) else None
+
+    latest_run: Optional[Dict[str, Any]] = None
+    if store is not None and hasattr(store, "list_workflow_runs"):
+        try:
+            runs = (
+                store.list_workflow_runs(
+                    workflow_id=workflow.get("id"), limit=1, workspace_id=workspace_id
+                )
+                or {}
+            ).get("runs") or []
+            latest_run = runs[0] if runs else None
+        except Exception:  # noqa: BLE001 — surfacing must never break the overview
+            LOGGER.exception("automation last-execution run read failed")
+            latest_run = None
+
+    derived: Optional[Dict[str, Any]] = None
+    if latest_run is not None:
+        derived = {
+            "mode": "live",
+            "status": str(latest_run.get("status") or "unknown"),
+            "summary": summarize_workflow_run(latest_run),
+            "run_id": latest_run.get("id"),
+            "finished_at": str(
+                latest_run.get("completed_at")
+                or latest_run.get("updated_at")
+                or latest_run.get("created_at")
+                or ""
+            ),
+        }
+
+    if stamped is None:
+        return derived
+    if derived is None:
+        return stamped
+    return derived if str(derived.get("finished_at") or "") > str(
+        stamped.get("finished_at") or ""
+    ) else stamped
+
+
+def enqueue_failed_execution(
+    review_queue: Any,
+    *,
+    workflow: Dict[str, Any],
+    run_id: Optional[str],
+    error: str,
+    user_email: Optional[str] = None,
+    workspace_id: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Failed live execution → review queue item (never raises)."""
+    if review_queue is None:
+        return None
+    name = str(workflow.get("name") or "Automation")
+    try:
+        return review_queue.create(
+            title=f"Automation failed: {name}"[:160],
+            summary=str(error or "")[:500],
+            source="workflow_run",
+            kind="automation_failure",
+            payload={
+                "workflow_id": workflow.get("id"),
+                "run_id": run_id,
+                "error": str(error or "")[:500],
+            },
+            provenance={
+                "workflow_id": workflow.get("id"),
+                "run_id": run_id,
+                "origin": "automation_run_now",
+            },
+            user_email=user_email,
+            workspace_id=workspace_id,
+        )
+    except Exception:  # noqa: BLE001 — review enqueue is best-effort surfacing
+        LOGGER.exception("automation failure review enqueue failed")
+        return None
+
+
+__all__ = [
+    "AUTOMATION_CREATED_FROM",
+    "is_automation_workflow",
+    "dry_run_report",
+    "build_last_execution",
+    "summarize_workflow_run",
+    "last_execution_view",
+    "enqueue_failed_execution",
+]

package/latticeai/services/automation_intelligence.py

@@ -560,6 +560,8 @@ class AutomationIntelligenceService:
             except Exception:
                 LOGGER.exception("automation intelligence workflow read failed")
                 workflows = []
+            from latticeai.services.automation_execution import last_execution_view
+
             for workflow in workflows:
                 metadata = (workflow or {}).get("metadata") or {}
                 if metadata.get("created_from") not in {"automation_suggestion", "brain_automation_recipe"}:
@@ -573,6 +575,11 @@ class AutomationIntelligenceService:
                     "enabled": metadata.get("automation_state") == "enabled",
                     "requires_user_enable": bool(metadata.get("requires_user_enable", True)),
                     "creates": metadata.get("creates") or [],
+                    # Execution log surfacing (backlog #6): the newest of the
+                    # run-now stamp vs. the latest persisted workflow run.
+                    "last_execution": last_execution_view(
+                        workflow, store=self._store, workspace_id=workspace_id
+                    ),
                 })
         return {
             "suggestions": suggestion_report["suggestions"],

package/latticeai/services/command_center.py

@@ -147,18 +147,37 @@ class CommandCenterService:
         workflows = self._workflows(workspace_id=workspace_id)
         enabled = 0
         drafts = 0
+        last_execution: Optional[Dict[str, Any]] = None
         for workflow in workflows:
             metadata = (workflow or {}).get("metadata") or {}
             if metadata.get("automation_state") == "enabled":
                 enabled += 1
             elif metadata.get("automation_state") == "draft_disabled":
                 drafts += 1
-        return {
+            # Execution log surfacing (backlog #6): the briefing carries the
+            # most recent stamped automation execution so "did my automation
+            # run, and how did it go?" is answered on the home surface.
+            stamped = metadata.get("last_execution")
+            if isinstance(stamped, dict) and str(stamped.get("finished_at") or "") > str(
+                (last_execution or {}).get("finished_at") or ""
+            ):
+                last_execution = {
+                    "workflow_id": workflow.get("id"),
+                    "name": _clip(workflow.get("name"), 120),
+                    "mode": stamped.get("mode"),
+                    "status": stamped.get("status"),
+                    "summary": _clip(stamped.get("summary"), 200),
+                    "finished_at": stamped.get("finished_at"),
+                }
+        section = {
             "available": True,
             "total": len(workflows),
             "enabled": enabled,
             "drafts": drafts,
         }
+        if last_execution is not None:
+            section["last_execution"] = last_execution
+        return section
 
     def _review_section(
         self, *, user_email: Optional[str], workspace_id: Optional[str]