ltcai 8.9.0 → 9.1.0

package/lattice_brain/portability.py

@@ -13,14 +13,12 @@ any cloud service. Two complementary mechanisms, both fully local:
 
 from __future__ import annotations
 
-import hashlib
 import json
 import os
 import shutil
 import sqlite3
 import tempfile
 import zipfile
-from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Any, Dict, Optional
 
@@ -30,26 +28,16 @@ from .storage import (
     PostgresEngine,
     SQLiteToPostgresMigrator,
 )
+from .utils import sha256_file as _sha256_file
+from .utils import utc_now_iso
 
 FORMAT = "latticeai.kg.export"
 FORMAT_VERSION = 1
 BACKUP_FORMAT = "latticeai.kg.backup"
 
 
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
 def _stamp() -> str:
-    return _now_iso().replace(":", "").replace("-", "").replace(".", "")[:15]
-
-
-def _sha256_file(path: Path) -> str:
-    h = hashlib.sha256()
-    with open(path, "rb") as fh:
-        for block in iter(lambda: fh.read(65536), b""):
-            h.update(block)
-    return h.hexdigest()
+    return utc_now_iso().replace(":", "").replace("-", "").replace(".", "")[:15]
 
 
 def _safe_zip_names(names) -> None:
@@ -168,15 +156,24 @@ class KGPortabilityService:
             raise RuntimeError("Knowledge Graph is disabled (LATTICEAI_ENABLE_GRAPH).")
 
     # ── logical export / import ──────────────────────────────────────────────
-    def export(self, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+    def export(
+        self,
+        *,
+        workspace_id: Optional[str] = None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         self._require()
-        data = self._kg.export_graph_data(workspace_id=workspace_id)
+        data = self._kg.export_graph_data(
+            workspace_id=workspace_id,
+            include_legacy_global=include_legacy_global,
+        )
         header = {
             "format": FORMAT,
             "format_version": FORMAT_VERSION,
             **self._kg.schema_versions(),
-            "exported_at": _now_iso(),
+            "exported_at": utc_now_iso(),
             "workspace_id": workspace_id,
+            "include_legacy_global": bool(include_legacy_global),
             "counts": data.get("counts"),
         }
         artifact = {"header": header, **data}
@@ -184,8 +181,17 @@ class KGPortabilityService:
             artifact["signature"] = self._identity.sign_manifest(header)
         return artifact
 
-    def export_to_file(self, path=None, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        artifact = self.export(workspace_id=workspace_id)
+    def export_to_file(
+        self,
+        path=None,
+        *,
+        workspace_id: Optional[str] = None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
+        artifact = self.export(
+            workspace_id=workspace_id,
+            include_legacy_global=include_legacy_global,
+        )
         self._exports_dir.mkdir(parents=True, exist_ok=True)
         path = Path(path) if path else self._exports_dir / f"kg-export-{_stamp()}.json"
         path.write_text(json.dumps(artifact, ensure_ascii=False, indent=2), encoding="utf-8")
@@ -212,7 +218,7 @@ class KGPortabilityService:
         if not dry_run:
             try:
                 self._kg.record_provenance(
-                    node_id="import:" + str((artifact.get("header") or {}).get("exported_at") or _now_iso()),
+                    node_id="import:" + str((artifact.get("header") or {}).get("exported_at") or utc_now_iso()),
                     source_type="bundle_import",
                     pipeline="kg-portability",
                     owner=None,
@@ -240,7 +246,7 @@ class KGPortabilityService:
                 "format": BACKUP_FORMAT,
                 "format_version": FORMAT_VERSION,
                 **self._kg.schema_versions(),
-                "created_at": _now_iso(),
+                "created_at": utc_now_iso(),
                 "db_sha256": _sha256_file(db_copy),
                 "has_blobs": Path(self._kg.blob_dir).exists(),
             }
@@ -341,7 +347,7 @@ class KGPortabilityService:
             "storage": self.storage_status().get("active", {}),
             "snapshot": self.snapshot_metadata(),
             "device_identity": self._identity.describe() if self._identity is not None else {},
-            "provenance": {"exported_at": _now_iso(), "source": "kg-portability"},
+            "provenance": {"exported_at": utc_now_iso(), "source": "kg-portability"},
         }
         archive = EncryptedBrainArchive(
             BrainArchivePaths(

package/lattice_brain/quality.py

@@ -152,6 +152,28 @@ class MemoryCandidate:
     conflicts: List[str] = field(default_factory=list)
 
 class MemoryQualityManager:
+    _NEGATION_PATTERNS = (
+        "not",
+        "does not",
+        "don't",
+        "do not",
+        "싫어",
+        "원하지 않",
+        "하지 않",
+        "반대",
+    )
+    _POSITIVE_PATTERNS = (
+        "prefers",
+        "prefer",
+        "likes",
+        "like",
+        "wants",
+        "want",
+        "좋아",
+        "선호",
+        "원해",
+    )
+
     def extract_candidates(self, memories: List[Dict]) -> List[MemoryCandidate]:
         return [MemoryCandidate(m["id"], m["content"], m.get("score", 0.6), m.get("source", "mem")) for m in memories]
 
@@ -163,10 +185,16 @@ class MemoryQualityManager:
         return sorted(cands, key=lambda x: x.score, reverse=True)
 
     def dedupe(self, cands: List[MemoryCandidate], threshold: float = 0.85) -> List[MemoryCandidate]:
+        """Advanced content dedup (KG scale slice).
+
+        Uses sha256 prefix + normalized length bucket for better collision resistance
+        than plain md5. Future: plug embedding cosine or simhash here.
+        """
         kept = []
         seen = set()
         for c in cands:
-            h = hashlib.md5(c.content.encode()).hexdigest()[:16]
+            norm = " ".join(c.content.lower().split())[:200]
+            h = hashlib.sha256((norm + f"|{len(c.content)//50}").encode()).hexdigest()[:16]
             if h not in seen:
                 seen.add(h)
                 kept.append(c)
@@ -182,12 +210,78 @@ class MemoryQualityManager:
         return list(merged.values())
 
     def detect_conflicts(self, cands: List[MemoryCandidate]) -> List[MemoryCandidate]:
-        # Lightweight local heuristic; LLM conflict classifiers can replace it.
-        for i, c in enumerate(cands):
-            if "not" in c.content.lower() or "반대" in c.content:
+        """Flag local contradiction signals before proactive synthesis.
+
+        The heuristic stays deterministic/offline: direct negation marks a row
+        as risky, and pairwise token overlap catches common preference conflicts
+        such as "prefers light mode" vs "does not like light mode".
+        """
+        for c in cands:
+            lowered = c.content.lower()
+            if any(pattern in lowered for pattern in self._NEGATION_PATTERNS):
                 c.conflicts.append("conflict:possible_negation")
+
+        signatures = [(c, self._content_signature(c.content)) for c in cands]
+        for left_index, (left, left_sig) in enumerate(signatures):
+            for right, right_sig in signatures[left_index + 1:]:
+                if not left_sig or len(left_sig & right_sig) < 2:
+                    continue
+                left_negative = self._is_negative(left.content)
+                right_negative = self._is_negative(right.content)
+                left_positive = self._is_positive(left.content)
+                right_positive = self._is_positive(right.content)
+                if left_negative == right_negative:
+                    continue
+                if not (left_positive or right_positive):
+                    continue
+                left.conflicts.append(f"conflict:contradicts:{right.id}")
+                right.conflicts.append(f"conflict:contradicts:{left.id}")
         return cands
 
+    def _is_negative(self, content: str) -> bool:
+        lowered = content.lower()
+        return any(pattern in lowered for pattern in self._NEGATION_PATTERNS)
+
+    def _is_positive(self, content: str) -> bool:
+        lowered = content.lower()
+        return any(pattern in lowered for pattern in self._POSITIVE_PATTERNS)
+
+    def _content_signature(self, content: str) -> set[str]:
+        stopwords = {
+            "a", "an", "and", "for", "i", "is", "it", "mode", "the", "to",
+            "user", "users", "does", "do", "not", "like", "likes", "prefer",
+            "prefers", "want", "wants",
+        }
+        tokens = set(re.findall(r"\w+", content.lower()))
+        return {token for token in tokens if len(token) > 2 and token not in stopwords}
+
+    # --- Large candidate #4 slice: proactive / temporal contradiction detection ---
+    def detect_temporal_contradictions(self, memories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Simple temporal + contradiction detector over memory list (proactive synthesis extension).
+
+        Looks at negation keywords across similar contents + differing timestamps.
+        Real version would walk graph historical projections + LLM judge.
+        Returns flagged items with 'contradiction' tag.
+        """
+        flagged = []
+        neg_tokens = ("not ", "반대", "거짓", "no longer", "never", "중단", "사용하지")
+        pos_group = []
+        neg_group = []
+        for m in memories:
+            c = (m.get("content") or "").lower()
+            if any(t in c for t in neg_tokens):
+                neg_group.append(m)
+            else:
+                pos_group.append(m)
+        # cross check: if both pos and neg exist with time spread
+        all_t = [m.get("timestamp") or m.get("created_at") or 0 for m in memories]
+        if neg_group and pos_group and len(set(all_t)) > 1:
+            for g in (pos_group + neg_group):
+                gg = dict(g)
+                gg["proactive_flag"] = "contradiction:temporal_negation"
+                flagged.append(gg)
+        return flagged
+
     def apply_retention(self, cands: List[MemoryCandidate], max_age_days: int = 90) -> List[MemoryCandidate]:
         now = time.time()
         return [c for c in cands if (now - c.timestamp) < max_age_days * 86400]

package/lattice_brain/runtime/agent_runtime.py

@@ -28,7 +28,6 @@ it, the frontend) now depends on this boundary instead of internal paths.
 
 from __future__ import annotations
 
-from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 from .multi_agent import (
@@ -45,6 +44,11 @@ from .contracts import (
     run_record_contract,
     runtime_boundary_contract,
 )
+from .statuses import (
+    RUN_ACTIVE_STATUSES as _ACTIVE_STATUSES,
+    RUN_TERMINAL_STATUSES as _TERMINAL_STATUSES,
+)
+from ..utils import now_iso as _now
 
 ROLE_DESCRIPTIONS = {
     "researcher": "Gathers workspace context and memory for the goal.",
@@ -57,12 +61,8 @@ ROLE_DESCRIPTIONS = {
 # Run statuses the orchestrator can emit that mean "still working". The default
 # orchestrator runs synchronously, so persisted runs are always terminal; this
 # set lets the runtime report live work if a future async runner lands.
-_ACTIVE_STATUSES = {"running", "in_progress", "queued", "retrying", "cancelling"}
-_TERMINAL_STATUSES = {"ok", "retried_ok", "failed", "rejected", "cancelled", "interrupted", "partial"}
-
-
-def _now() -> str:
-    return datetime.now().isoformat(timespec="seconds")
+def _compact_text(value: Any, *, limit: int) -> str:
+    return " ".join(str(value or "").split())[:limit]
 
 
 class AgentRuntimeUnavailable(RuntimeError):
@@ -80,6 +80,8 @@ class AgentRuntime:
         max_retries_cap: int = 5,
         hooks: Any = None,
         allow_simulation_runs: bool = False,
+        memory_ingest: Optional[Callable[..., Dict[str, Any]]] = None,
+        review_sink: Any = None,
     ):
         self._store = store
         self._orchestrator_factory = orchestrator_factory
@@ -91,6 +93,11 @@ class AgentRuntime:
         self._hooks = hooks
         self._allow_simulation_runs = bool(allow_simulation_runs)
         self._run_executor: Any = None
+        # Optional memory synthesis: successful agent runs produce durable
+        # Brain memories (long_term / workspace tier) so users *feel* the results
+        # in BrainBrief, MemoryRings, search and graph immediately.
+        self._memory_ingest = memory_ingest
+        self._review_sink = review_sink
 
     def attach_executor(self, executor: Any) -> None:
         self._run_executor = executor
@@ -415,6 +422,155 @@ class AgentRuntime:
             "current_role": None,
         }
 
+    def _synthesize_brain_memory(self, *, goal: str, result: Any, user_email: Optional[str], scope: Optional[str]) -> None:
+        """Turn a successful agent run into durable Brain memory + graph nodes.
+
+        This is the key to users *strongly feeling* the scale of agent work:
+        delegated goals don't disappear into Act tab; they become part of the
+        Living Brain (searchable, visible in rings/brief, connected in graph).
+        """
+        if not self._memory_ingest:
+            return
+        if getattr(result, "status", None) not in ("ok", "retried_ok"):
+            return
+        try:
+            output = _compact_text(getattr(result, "output", ""), limit=2200)
+            plan_steps = getattr(result, "plan", None) or []
+            sections = self._agent_synthesis_sections(goal=goal, output=output, plan_steps=plan_steps, result=result)
+            plan_summary = "; ".join(sections["plan_steps"][:4])
+            content = "\n\n".join([
+                f"[Agent synthesis] Goal: {_compact_text(goal, limit=240)}",
+                f"Outcome: {output}",
+                self._format_synthesis_section("Key facts", sections["facts"]),
+                self._format_synthesis_section("Decisions", sections["decisions"]),
+                self._format_synthesis_section("Follow-ups", sections["followups"]),
+                f"Plan: {plan_summary}" if plan_summary else "",
+            ]).strip()
+            if not content or len(content) < 20:
+                return
+            tags = ["agent-synthesis", "delegated", "auto"]
+            self._memory_ingest(
+                kind="long_term",
+                content=content,
+                user_email=user_email,
+                tags=tags,
+                metadata={
+                    "source": "agent_runtime",
+                    "synthesis_version": 2,
+                    "goal": _compact_text(goal, limit=200),
+                    "roles": getattr(result, "roles_run", None),
+                    "facts": sections["facts"],
+                    "decisions": sections["decisions"],
+                    "followups": sections["followups"],
+                },
+                graph=self._workspace_graph() if hasattr(self, "_workspace_graph") else None,
+                workspace_id=scope,
+            )
+            if sections["decisions"]:
+                self._memory_ingest(
+                    kind="decisions",
+                    content=f"Agent decision for {_compact_text(goal, limit=120)}: {'; '.join(sections['decisions'][:3])}",
+                    user_email=user_email,
+                    tags=["agent", "outcome", "decision"],
+                    metadata={"source": "agent_runtime_synthesis", "synthesis_version": 2, "goal": _compact_text(goal, limit=200)},
+                    workspace_id=scope,
+                )
+            if sections["followups"]:
+                self._memory_ingest(
+                    kind="workspace",
+                    content=f"Agent follow-ups for {_compact_text(goal, limit=120)}: {'; '.join(sections['followups'][:5])}",
+                    user_email=user_email,
+                    tags=["agent", "follow-up", "next-action"],
+                    metadata={"source": "agent_runtime_followups", "synthesis_version": 2, "goal": _compact_text(goal, limit=200)},
+                    workspace_id=scope,
+                )
+                self._enqueue_agent_followups(
+                    goal=goal,
+                    followups=sections["followups"],
+                    result=result,
+                    user_email=user_email,
+                    scope=scope,
+                    output=output,
+                )
+        except Exception:
+            # Synthesis must never break the run record.
+            pass
+
+    @staticmethod
+    def _format_synthesis_section(title: str, items: List[str]) -> str:
+        if not items:
+            return ""
+        return f"{title}:\n" + "\n".join(f"- {item}" for item in items[:5])
+
+    @staticmethod
+    def _agent_synthesis_sections(*, goal: str, output: str, plan_steps: List[Dict[str, Any]], result: Any) -> Dict[str, List[str]]:
+        plan_descriptions = [
+            _compact_text(step.get("description") or step.get("name") or step.get("id"), limit=120)
+            for step in plan_steps
+            if isinstance(step, dict) and (step.get("description") or step.get("name") or step.get("id"))
+        ]
+        sentences = [
+            sentence.strip(" -•\t")
+            for sentence in output.replace("\n", ". ").split(".")
+            if sentence.strip(" -•\t")
+        ]
+        facts = [_compact_text(sentence, limit=180) for sentence in sentences[:4]]
+        review = getattr(result, "review", None) if isinstance(getattr(result, "review", None), dict) else {}
+        plan_review = getattr(result, "plan_review", None) if isinstance(getattr(result, "plan_review", None), dict) else {}
+        decision_seed = review.get("decision") or review.get("status") or plan_review.get("decision") or getattr(result, "status", "")
+        decisions = [
+            _compact_text(f"Run finished with {decision_seed}", limit=160),
+            _compact_text(f"Goal accepted: {goal}", limit=180),
+        ]
+        followups = [
+            item for item in plan_descriptions
+            if any(token in item.lower() for token in ("next", "follow", "review", "verify", "test", "ship", "publish", "document", "implement"))
+        ][:5]
+        if not followups:
+            followups = plan_descriptions[:3]
+        return {
+            "facts": [item for item in facts if item],
+            "decisions": [item for item in decisions if item],
+            "followups": [item for item in followups if item],
+            "plan_steps": plan_descriptions,
+        }
+
+    def _enqueue_agent_followups(
+        self,
+        *,
+        goal: str,
+        followups: List[str],
+        result: Any,
+        user_email: Optional[str],
+        scope: Optional[str],
+        output: str,
+    ) -> None:
+        if self._review_sink is None:
+            return
+        for index, followup in enumerate(followups[:5], start=1):
+            try:
+                self._review_sink.create(
+                    title=_compact_text(followup, limit=96) or f"Agent follow-up {index}",
+                    summary=_compact_text(f"From goal: {goal}", limit=420),
+                    source="agent_followup",
+                    kind="task_draft",
+                    payload={
+                        "goal": _compact_text(goal, limit=300),
+                        "followup": _compact_text(followup, limit=300),
+                        "output_preview": _compact_text(output, limit=800),
+                        "roles": getattr(result, "roles_run", None),
+                    },
+                    provenance={
+                        "agent_id": getattr(result, "agent_id", ""),
+                        "source_detail": "agent_runtime_followup",
+                        "status": getattr(result, "status", ""),
+                    },
+                    user_email=user_email,
+                    workspace_id=scope,
+                )
+            except Exception:
+                continue
+
     def _post_run_hooks(
         self,
         *,
@@ -572,6 +728,9 @@ class AgentRuntime:
             status=updated.get("status") or result.status,
             retries=result.retries,
         )
+        # Large-scale user-visible impact: successful runs enrich the Brain permanently.
+        if (updated.get("status") or result.status) in ("ok", "retried_ok"):
+            self._synthesize_brain_memory(goal=goal, result=result, user_email=user_email, scope=scope)
         post_dispatch = self._post_run_hooks(
             run_id=run_id,
             result=result,
@@ -651,6 +810,9 @@ class AgentRuntime:
             status=result.status,
             retries=result.retries,
         )
+        # Large-scale user-visible impact: successful runs enrich the Brain permanently.
+        if result.status in ("ok", "retried_ok"):
+            self._synthesize_brain_memory(goal=goal, result=result, user_email=user_email, scope=scope)
 
         run_id = run.get("id") or run.get("run_id") if isinstance(run, dict) else None
         post_dispatch = self._post_run_hooks(

package/lattice_brain/runtime/hooks.py

@@ -25,6 +25,7 @@ order.
 from __future__ import annotations
 
 import json
+import logging
 import os
 import shlex
 import subprocess
@@ -32,10 +33,14 @@ import tempfile
 import threading
 import time
 from collections import deque
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+from ..utils import now_iso as _now
+
+
+LOGGER = logging.getLogger(__name__)
+
 
 HOOK_KINDS = (
     "pre_run",
@@ -63,10 +68,6 @@ LEGACY_KIND_ALIASES = {
 HOOK_STATUSES = ("ok", "blocked", "error", "skipped", "advisory")
 
 
-def _now() -> str:
-    return datetime.now().isoformat(timespec="seconds")
-
-
 class HookContext:
     """Mutable execution context handed to every hook in a dispatch.
 
@@ -213,7 +214,8 @@ def dispatch_tool(
         return run_fn()
     try:
         arg_keys = list(args.keys()) if isinstance(args, dict) else []
-    except Exception:
+    except Exception as exc:
+        LOGGER.debug("tool argument metadata could not be inspected: %s", exc)
         arg_keys = []
     pre = hooks.fire_hook(
         "pre_tool", f"tool.{tool_name}",
@@ -341,8 +343,8 @@ class HooksRegistry:
                     data.setdefault("custom", [])
                     data.setdefault("overrides", {})
                     return data
-            except Exception:
-                pass
+            except (OSError, json.JSONDecodeError, TypeError, ValueError) as exc:
+                LOGGER.warning("hook registry state is unreadable at %s: %s", self._path, exc)
         return {"custom": [], "overrides": {}}
 
     def _save(self) -> None:
@@ -626,6 +628,7 @@ class HooksRegistry:
                 user_email=user_email, workspace_id=workspace_id, metadata=metadata,
             )
         except Exception as exc:  # pragma: no cover - defensive
+            LOGGER.exception("hook dispatch failed before execution: %s", kind)
             return {"kind": kind, "event": event or kind, "ran": 0, "blocked": False,
                     "block_reason": "", "error": str(exc), "results": [], "generated_at": _now()}
 
@@ -694,7 +697,21 @@ class HooksRegistry:
         if not argv:
             return "skipped", "empty command", "", False
         ctx_json = json.dumps(context.as_dict(), ensure_ascii=False)
-        env = dict(os.environ)
+        # Command hooks run with an intentionally small environment. In
+        # particular, provider keys, database credentials, session secrets,
+        # and arbitrary PYTHON*/NODE* injection variables from the server
+        # process must never be inherited by a child process. The retained
+        # entries are the minimum needed for executable lookup, home-relative
+        # tools, locale handling, temporary files, and Windows process startup.
+        allowed_env_keys = {
+            "PATH", "HOME", "LANG", "LC_ALL", "LC_CTYPE",
+            "TMPDIR", "TMP", "TEMP", "SYSTEMROOT", "WINDIR", "PATHEXT",
+        }
+        env = {
+            key: value
+            for key, value in os.environ.items()
+            if key.upper() in allowed_env_keys
+        }
         env.update({
             "LATTICE_HOOK_KIND": context.kind,
             "LATTICE_HOOK_EVENT": context.event,
@@ -726,8 +743,8 @@ class HooksRegistry:
                     data = json.load(fh)
                 if isinstance(data, list):
                     return data
-        except Exception:
-            pass
+        except (OSError, json.JSONDecodeError, TypeError, ValueError) as exc:
+            LOGGER.warning("hook run history is unreadable at %s: %s", self._runs_path, exc)
         return []
 
     def _save_runs(self) -> None:
@@ -737,8 +754,8 @@ class HooksRegistry:
             with os.fdopen(fd, "w", encoding="utf-8") as fh:
                 json.dump(list(self._runs), fh, ensure_ascii=False, indent=2)
             os.replace(tmp, self._runs_path)
-        except Exception:  # pragma: no cover - the run log is best-effort
-            pass
+        except OSError as exc:  # pragma: no cover - the run log is best-effort
+            LOGGER.warning("hook run history write failed at %s: %s", self._runs_path, exc)
 
     def _record_run(self, result: HookResult, context: HookContext) -> None:
         entry = result.as_dict()

package/lattice_brain/runtime/multi_agent.py

@@ -15,13 +15,13 @@ installations can exercise the full Planner -> Executor -> Reviewer loop.
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 from .contracts import multi_agent_contract
+from ..utils import now_iso as _now
 
 
-MULTI_AGENT_VERSION = "8.9.0"
+MULTI_AGENT_VERSION = "9.1.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")
@@ -50,10 +50,6 @@ REVIEW_OUTCOMES = ("approve", "reject", "retry")
 _SECRET_KEYS = ("secret", "token", "password", "api_key", "apikey", "credential")
 
 
-def _now() -> str:
-    return datetime.now().isoformat(timespec="seconds")
-
-
 def _redact(value: Any) -> Any:
     """Return a JSON-safe value with obvious secret fields redacted."""
     if isinstance(value, dict):
@@ -668,7 +664,7 @@ class MultiAgentOrchestrator:
             result = self.role_runner(role, ctx) or {}
             status = result.get("status", "ok")
         except Exception as exc:
-            result = {"error": str(exc)}
+            result = {"status": "error", "error": str(exc)}
             status = "error"
         if role == "reviewer":
             review = dict(ctx.review or result)
@@ -739,9 +735,32 @@ class MultiAgentOrchestrator:
             role = pipeline[index]
             if previous is not None:
                 ctx.handoff(previous, role)
-            self._run_role(role, ctx)
+            role_result = self._run_role(role, ctx)
             roles_run.append(role)
 
+            # A role exception is terminal for this attempt. Continuing would
+            # let downstream roles review stale or missing output and could
+            # incorrectly convert a failed run into an approved one.
+            if str(role_result.get("status") or "").lower() == "error":
+                reason = str(role_result.get("error") or f"{role} role failed")
+                existing_review = dict(ctx.review or {})
+                ctx.review = existing_review or {
+                    "outcome": "reject",
+                    "verdict": "fail",
+                    "reason": reason,
+                    "notes": [f"{role} did not complete"],
+                    "reviewed_at": _now(),
+                }
+                ctx.timeline.append(
+                    {
+                        "event": "execution_failed",
+                        "role": role,
+                        "reason": reason,
+                        "timestamp": _now(),
+                    }
+                )
+                break
+
             if role == "reviewer":
                 review = dict(ctx.review or {})
                 outcome = _review_outcome(review)

package/lattice_brain/runtime/statuses.py

@@ -0,0 +1,10 @@
+"""Canonical lifecycle states shared by persisted agent and workflow runs."""
+
+RUN_ACTIVE_STATUSES = frozenset(
+    {"queued", "running", "in_progress", "retrying", "cancelling"}
+)
+RUN_TERMINAL_STATUSES = frozenset(
+    {"ok", "retried_ok", "failed", "rejected", "cancelled", "interrupted", "partial"}
+)
+
+__all__ = ["RUN_ACTIVE_STATUSES", "RUN_TERMINAL_STATUSES"]