deepparallel 0.5.5__tar.gz → 0.6.0__tar.gz

{deepparallel-0.5.5 → deepparallel-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.5
+Version: 0.6.0
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.5.5 → deepparallel-0.6.0}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.5"
+__version__ = "0.6.0"

{deepparallel-0.5.5 → deepparallel-0.6.0}/deepparallel/agent.py

@@ -255,16 +255,29 @@ def _supply_chain_note(name: str, args: dict) -> str | None:
     return None
 
 
-def _approved(name, args, interactive, auto_approve, renderer, guardian=None) -> bool:
+def _approved(name, args, interactive, auto_approve, renderer, guardian=None, mesh_fn=None) -> bool:
     forced = name in _GATED_PATH_TOOLS and _outside_cwd(args)
     sc_note = _supply_chain_note(name, args) if name in _EDIT_TOOLS else None
-    # A hallucinated dependency overrides auto-approve: always surface it.
-    if auto_approve and not forced and not sc_note:
+    # The verification mesh reviews every edit. A BUG verdict blocks the action
+    # and overrides auto-approve, exactly like a hallucinated dependency does.
+    mesh_result = None
+    if mesh_fn is not None and name in _EDIT_TOOLS:
+        try:
+            mesh_result = mesh_fn(_guardian_review_content(name, args))
+        except Exception:  # noqa: BLE001 - the gate is best-effort, never fatal
+            mesh_result = None
+    blocked = bool(mesh_result and mesh_result.get("severity") == "bug")
+    # A hallucinated dependency or a BUG verdict overrides auto-approve.
+    if auto_approve and not forced and not sc_note and not blocked:
         return True
     if not interactive:
         return False
     title, detail = _describe(name, args)
-    if guardian is not None and name in _EDIT_TOOLS:
+    if mesh_result is not None:
+        from deepparallel.mesh import format_panel
+
+        detail = f"{detail}\n\nVerification mesh:\n{format_panel(mesh_result)}"
+    elif guardian is not None and name in _EDIT_TOOLS:
         verdict = _guardian_verdict(guardian, name, args)
         if verdict:
             detail = f"{detail}\n\nGuardian: {verdict}"
@@ -307,6 +320,7 @@ def run_agent(
     max_steps: int | None = None,
     stream: bool = False,
     guardian=None,
+    mesh_fn=None,
     on_event=None,
 ) -> str:
     steps = max_steps if max_steps is not None else settings.max_steps
@@ -346,7 +360,7 @@ def run_agent(
             elif "__parse_error__" in args:
                 result = json.dumps({"error": "invalid JSON arguments"})
             elif meta.dangerous and not _approved(
-                name, args, interactive, auto_approve, renderer, guardian
+                name, args, interactive, auto_approve, renderer, guardian, mesh_fn
             ):
                 result = json.dumps({"error": "denied by user"})
             else:

{deepparallel-0.5.5 → deepparallel-0.6.0}/deepparallel/branding.py

@@ -373,12 +373,12 @@ def status_text(
     body.append(f"  {DOT} v{version}  {DOT} ", style=DIM)
     body.append("served via Crowe Logic\n", style=f"bold {CROWE_ACCENT}")
     body.append(f"{tool_count} tools", style=WHITE_HEX)
-    body.append(f" {DOT} 5,800+ MCP servers", style=DIM)
-    body.append(f"  {DOT} fusion: {fusion}\n", style=DIM)
+    body.append(f" {DOT} MCP registry (local + 5,800+)", style=DIM)
+    body.append(f"  {DOT} memory {DOT} fusion: {fusion}\n", style=DIM)
     body.append("Backend: ", style=DIM)
     body.append(f"{backend_label}\n\n", style="white")
     body.append("/help", style="bold")
-    body.append("  /tools  /fast //deep //fuse  ", style=DIM)
+    body.append("  /tools  /memory  /cockpit  /fast //deep //fuse  ", style=DIM)
     body.append("/quit", style="bold")
     return _gutter(body)
 

{deepparallel-0.5.5 → deepparallel-0.6.0}/deepparallel/cli.py

@@ -45,7 +45,7 @@ from deepparallel.config import (
     missing_required,
     resolve_settings,
 )
-from deepparallel import licensing, supply_chain
+from deepparallel import licensing, memory, supply_chain
 from deepparallel.fusion import (
     EscalationBackend,
     ReasonAnswerBackend,
@@ -177,6 +177,27 @@ def _build_guardian(settings: Settings) -> Backend | None:
     return backend_for_deployment(settings, settings.guardian_deployment)
 
 
+def _build_mesh(settings: Settings):
+    """The verification mesh: a parallel reviewer panel that gates every edit.
+
+    Supersedes the single guardian when available. Paid (Pro+) feature; returns
+    a callable ``mesh_fn(content) -> result`` or None on Free / when disabled.
+    """
+    if not settings.guardian_enabled:
+        return None
+    ok, _ = licensing.check_feature("mesh")
+    if not ok:
+        return None
+    from deepparallel import mesh
+
+    return lambda content: mesh.mesh_review(settings, content)
+
+
+def _system_prompt() -> str:
+    """System prompt with the long-term memory index injected (recall tier 1)."""
+    return load_system_prompt() + memory.index_block()
+
+
 def _make_renderer(*, force_plain: bool, assume_yes: bool = False) -> Renderer:
     plain = force_plain or _bool_env("DEEPPARALLEL_PLAIN", False) or not sys.stdout.isatty()
     if plain:
@@ -233,7 +254,7 @@ def _stream_once(backend: Backend, settings: Settings, messages: list[dict]) ->
 
 def _stream_repl(backend: Backend, settings: Settings) -> None:
     """Plain-chat interactive loop (no tools)."""
-    system = load_system_prompt()
+    system = _system_prompt()
     history: list[tuple[str, str]] = []
     while True:
         try:
@@ -288,8 +309,9 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     """Interactive agentic loop: tools enabled, conversation persists. The dial
     (/fast //fuse //escalate //deep) swaps the active fusion mode live."""
     registry = get_registry()
-    guardian = _build_guardian(settings)
-    system = load_system_prompt()
+    mesh_fn = _build_mesh(settings)
+    guardian = None if mesh_fn else _build_guardian(settings)
+    system = _system_prompt()
     messages: list[dict] = [{"role": "system", "content": system}]
     mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
     deep_next = False
@@ -315,7 +337,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
             break
         if user_msg == "/help":
             branding.info(
-                "/quit · /reset · /info · /tools · /auto · /cockpit · /fast //fuse //escalate //deep · prompt"
+                "/quit · /reset · /info · /tools · /auto · /memory · /cockpit · /fast //fuse //escalate //deep · prompt"
             )
             continue
         if user_msg in {"/auto", "/yes"}:
@@ -354,6 +376,15 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 cockpit.status("done", "cockpit complete")
                 branding.info("cockpit OFF.")
             continue
+        if user_msg == "/memory":
+            mems = memory.list_memories()
+            if mems:
+                branding.info(f"{len(mems)} memories saved. Most recent:")
+                for m in mems[-8:]:
+                    console.print(f"  [dim]-[/] {m['name']}: {m['description'][:64]}")
+            else:
+                branding.info("no memories yet; the agent saves them with the remember tool.")
+            continue
 
         messages.append({"role": "user", "content": user_msg})
         if deep_next:
@@ -371,6 +402,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 auto_approve=auto,
                 stream=True,
                 guardian=guardian,
+                mesh_fn=mesh_fn,
                 on_event=observer if cockpit_on else None,
             )
             if mode in ("reason", "escalate"):
@@ -482,7 +514,7 @@ def run(
     if fuse is not None:
         settings = replace(settings, fusion_mode=fuse)
     backend = _require_ready(settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     if deep:
         _run_deep(settings, messages)
@@ -504,6 +536,7 @@ def run(
             renderer,
             interactive=False,
             auto_approve=settings.auto_approve,
+            mesh_fn=_build_mesh(settings),
         )
     except Exception as e:  # noqa: BLE001 - surface as friendly message
         branding.error(_translate_error(e))
@@ -530,7 +563,7 @@ def cockpit(ctx: click.Context, assume_yes: bool, prompt: tuple[str, ...]) -> No
     cp.status("start", "cockpit online")
     cp.ensure_panel()
     backend = _wrap_fusion(backend, settings)
-    system = load_system_prompt()
+    system = _system_prompt()
     messages = _build_messages([], system, " ".join(prompt))
     renderer = _make_renderer(force_plain=False, assume_yes=settings.auto_approve)
     try:
@@ -600,10 +633,25 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
         branding.error("provide a PATH or --diff (with a diff on stdin)")
         sys.exit(3)
     _require_ready(settings)  # validates creds / exits if missing
+    glyphs = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}
+    mesh_ok, _ = licensing.check_feature("mesh")
+    if mesh_ok and settings.guardian_enabled:
+        # Pro: the full verification mesh, one independent reviewer per lens.
+        from deepparallel import mesh as _mesh
+
+        result = _mesh.mesh_review(settings, content)
+        for r in result["lenses"]:
+            g = glyphs.get(r["severity"], "?")
+            console.print(f"  {g} [dim]{r['label']}[/] {r['verdict'] or '(no verdict)'}")
+        verdict = result["verdict"]
+        glyph = glyphs.get(result["severity"], "?")
+        console.print(f"[bold]{glyph} {result['severity'].upper()}[/] {verdict or '(no verdict)'}")
+        sys.exit(verdict_exit_code(verdict))
+    # Free / BYOK: a single independent reviewer.
     guardian = backend_for_deployment(settings, settings.guardian_deployment)
     verdict = guardian_review(guardian, content[:8000])
     severity = verdict_severity(verdict)
-    glyph = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}.get(severity, "?")
+    glyph = glyphs.get(severity, "?")
     console.print(f"[bold]{glyph} {severity.upper()}[/] {verdict or '(no verdict)'}")
     sys.exit(verdict_exit_code(verdict))
 

{deepparallel-0.5.5 → deepparallel-0.6.0}/deepparallel/config.py

@@ -104,7 +104,54 @@ def _int_env(name: str, default: int) -> int:
         return default
 
 
+_TOML_TO_ENV = {
+    "backend.backend": "DEEPPARALLEL_BACKEND",
+    "backend.deployment": "DEEPPARALLEL_DEPLOYMENT",
+    "backend.temperature": "DEEPPARALLEL_TEMPERATURE",
+    "backend.max_tokens": "DEEPPARALLEL_MAX_TOKENS",
+    "backend.parallel_models": "DEEPPARALLEL_PARALLEL_MODELS",
+    "fusion.mode": "DEEPPARALLEL_FUSION",
+    "tools.auto_approve": "DEEPPARALLEL_AUTO_APPROVE",
+    "memory.enabled": "DEEPPARALLEL_MEMORY",
+    "memory.dir": "DEEPPARALLEL_MEMORY_DIR",
+    "mcp.config": "DEEPPARALLEL_MCP_CONFIG",
+}
+
+
+def _apply_config_file() -> None:
+    """Layer ~/.config/deepparallel/config.toml under the environment.
+
+    Sets each known DEEPPARALLEL_* env var only when unset, so precedence is
+    explicit env var > config.toml > built-in default. Missing or malformed
+    config is ignored. Path override: DEEPPARALLEL_CONFIG.
+    """
+    import tomllib
+
+    path = os.environ.get("DEEPPARALLEL_CONFIG") or os.path.expanduser(
+        "~/.config/deepparallel/config.toml"
+    )
+    try:
+        with open(path, "rb") as fh:
+            data = tomllib.load(fh)
+    except (OSError, ValueError):
+        return
+    for dotted, env_name in _TOML_TO_ENV.items():
+        if os.environ.get(env_name) is not None:
+            continue
+        section, key = dotted.split(".", 1)
+        val = (data.get(section) or {}).get(key)
+        if val is None:
+            continue
+        if isinstance(val, bool):
+            os.environ[env_name] = "true" if val else "false"
+        elif isinstance(val, list):
+            os.environ[env_name] = ",".join(str(x) for x in val)
+        else:
+            os.environ[env_name] = str(val)
+
+
 def resolve_settings() -> Settings:
+    _apply_config_file()
     backend = os.environ.get("DEEPPARALLEL_BACKEND", "azure").strip().lower()
     if backend not in {"azure", "foundry", "crowe", "openai", "ollama"}:
         backend = "azure"

deepparallel-0.6.0/deepparallel/memory.py

@@ -0,0 +1,186 @@
+# Copyright 2026, Crowe Logic Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Persistent, continuously-growing memory for DeepParallel.
+
+This is what makes CroweLM a learning model in practice: durable facts persist
+across sessions and feed back into context. Two recall tiers:
+
+- index: MEMORY.md is injected into the system prompt every session, so the
+  model remembers the user and their projects without being re-told.
+- retrieval: recall(query) ranks individual memories by relevance (TF-IDF
+  cosine over tokens, stdlib only) for an on-demand, semantic-style pull.
+
+Memories are markdown files with frontmatter under the memory directory
+(default ~/.config/deepparallel/memory; override DEEPPARALLEL_MEMORY_DIR).
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import time
+from pathlib import Path
+
+INDEX_FILE = "MEMORY.md"
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+_TOK_RE = re.compile(r"[a-z0-9]+")
+_FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.S)
+
+
+def memory_dir() -> Path:
+    raw = os.environ.get("DEEPPARALLEL_MEMORY_DIR") or os.path.expanduser(
+        "~/.config/deepparallel/memory"
+    )
+    return Path(raw)
+
+
+def enabled() -> bool:
+    return os.environ.get("DEEPPARALLEL_MEMORY", "on").strip().lower() not in {
+        "0", "off", "false", "no",
+    }
+
+
+def _slugify(name: str) -> str:
+    return _SLUG_RE.sub("-", name.strip().lower()).strip("-") or "memory"
+
+
+def _unique_slug(d: Path, slug: str) -> str:
+    cand, i = slug, 2
+    while (d / f"{cand}.md").exists():
+        cand, i = f"{slug}-{i}", i + 1
+    return cand
+
+
+def load_index() -> str:
+    try:
+        return (memory_dir() / INDEX_FILE).read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def index_block() -> str:
+    """The memory index formatted for system-prompt injection (empty if none)."""
+    idx = load_index()
+    if not idx or not enabled():
+        return ""
+    return (
+        "\n\nLong-term memory (recalled from past sessions; background context, "
+        "verify file/line specifics before relying on them):\n" + idx
+    )
+
+
+def save_memory(content: str, name: str = "", description: str = "", mtype: str = "note") -> str:
+    """Write one durable fact as a markdown file and add an index line."""
+    d = memory_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    first_line = content.strip().split("\n", 1)[0]
+    title = (name or first_line)[:60].strip() or "memory"
+    slug = _unique_slug(d, _slugify(title))
+    desc = (description or first_line).replace("\n", " ").strip()[:120]
+    body = (
+        f"---\nname: {title}\ndescription: {desc}\ntype: {mtype}\n"
+        f"created: {int(time.time())}\n---\n\n{content.strip()}\n"
+    )
+    (d / f"{slug}.md").write_text(body, encoding="utf-8")
+    _append_index(d, slug, title, desc)
+    return slug
+
+
+def _append_index(d: Path, slug: str, title: str, desc: str) -> None:
+    idx = d / INDEX_FILE
+    existing = idx.read_text(encoding="utf-8") if idx.exists() else "# DeepParallel Memory\n\n"
+    if f"]({slug}.md)" in existing:
+        return
+    if not existing.endswith("\n"):
+        existing += "\n"
+    idx.write_text(existing + f"- [{title}]({slug}.md) - {desc}\n", encoding="utf-8")
+
+
+def _parse(text: str, fallback: str) -> tuple[str, str, str]:
+    m = _FM_RE.match(text)
+    if not m:
+        return fallback, "", text.strip()
+    meta = {}
+    for line in m.group(1).splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            meta[k.strip()] = v.strip()
+    return meta.get("name", fallback), meta.get("description", ""), m.group(2).strip()
+
+
+def list_memories() -> list[dict]:
+    d = memory_dir()
+    out = []
+    if not d.exists():
+        return out
+    for p in sorted(d.glob("*.md")):
+        if p.name == INDEX_FILE:
+            continue
+        name, desc, body = _parse(p.read_text(encoding="utf-8", errors="replace"), p.stem)
+        out.append({"name": name, "description": desc, "content": body, "path": str(p)})
+    return out
+
+
+def _tokenize(text: str) -> list[str]:
+    return _TOK_RE.findall(text.lower())
+
+
+def recall(query: str, limit: int = 5) -> list[dict]:
+    """Relevance-ranked memories via TF-IDF cosine over tokens (stdlib only)."""
+    mems = list_memories()
+    if not mems or not query.strip():
+        return []
+    docs = [_tokenize(f"{m['name']} {m['description']} {m['content']}") for m in mems]
+    df: dict[str, int] = {}
+    for toks in docs:
+        for t in set(toks):
+            df[t] = df.get(t, 0) + 1
+    n = len(docs)
+
+    def vec(toks: list[str]) -> dict[str, float]:
+        if not toks:
+            return {}
+        tf: dict[str, int] = {}
+        for t in toks:
+            tf[t] = tf.get(t, 0) + 1
+        return {t: (c / len(toks)) * math.log((n + 1) / (df.get(t, 0) + 1) + 1) for t, c in tf.items()}
+
+    qv = vec(_tokenize(query))
+    qa = math.sqrt(sum(v * v for v in qv.values()))
+    scored = []
+    for m, toks in zip(mems, docs):
+        dv = vec(toks)
+        da = math.sqrt(sum(v * v for v in dv.values()))
+        num = sum(qv.get(t, 0.0) * dv.get(t, 0.0) for t in qv)
+        score = num / (da * qa) if da and qa else 0.0
+        if score > 0:
+            scored.append(
+                {"name": m["name"], "description": m["description"], "content": m["content"],
+                 "score": round(score, 4)}
+            )
+    scored.sort(key=lambda x: x["score"], reverse=True)
+    return scored[:limit]
+
+
+def _rebuild_index(d: Path) -> None:
+    lines = ["# DeepParallel Memory", ""]
+    for m in list_memories():
+        lines.append(f"- [{m['name']}]({Path(m['path']).stem}.md) - {m['description']}")
+    (d / INDEX_FILE).write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def forget(name: str) -> bool:
+    d = memory_dir()
+    target = d / f"{_slugify(name)}.md"
+    if not target.exists():
+        for p in d.glob("*.md"):
+            if p.stem == name and p.name != INDEX_FILE:
+                target = p
+                break
+    if target.exists() and target.name != INDEX_FILE:
+        target.unlink()
+        _rebuild_index(d)
+        return True
+    return False

deepparallel-0.6.0/deepparallel/mesh.py

@@ -0,0 +1,165 @@
+"""The verification mesh: N independent models review a proposed change in
+parallel, then a guardian synthesizes the final gate verdict.
+
+This generalizes the single-model ``guardian_review`` into the multi-lens panel
+the hosted /review endpoint already uses (correctness, security, edge cases,
+maintainability) and is the gate the agent loop consults before any mutating
+action. It reuses the same parallel fan-out shape as ``fusion.deep_query`` and
+emits :mod:`deepparallel.session` events so a trace view can render the panel.
+
+Pure review: it never executes anything. It returns structured verdicts and a
+decision (allow | hold | block) the caller enforces.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from deepparallel import session
+from deepparallel.backend import backend_for_deployment
+
+# Four independent lenses, mirroring the hosted reviewer panel. Each model is
+# asked for exactly one verdict line so the result is cheap to parse and gate.
+_VERDICT_SHAPE = (
+    " Reply with exactly one line: 'VERDICT: safe', 'VERDICT: risky: <reason>', "
+    "or 'VERDICT: bug: <reason>'. No preamble, no markdown."
+)
+LENSES = (
+    {"key": "correctness", "label": "Correctness",
+     "sys": "Independently review this proposed change for correctness and logic errors."},
+    {"key": "security", "label": "Security",
+     "sys": "Independently review this proposed change for security vulnerabilities "
+            "(injection, auth, secrets, unsafe input)."},
+    {"key": "edge", "label": "Edge cases",
+     "sys": "Independently review this proposed change for edge cases and failure "
+            "modes the author likely missed."},
+    {"key": "maintainability", "label": "Maintainability",
+     "sys": "Independently review this proposed change for clarity and "
+            "maintainability problems."},
+)
+
+_SEVERITY_RANK = {"safe": 0, "unknown": 1, "risky": 2, "bug": 3}
+
+
+def verdict_severity(verdict: str | None) -> str:
+    """Classify a verdict string into safe | risky | bug | unknown."""
+    if not verdict:
+        return "unknown"
+    head = verdict.strip().lower()
+    for sev in ("safe", "risky", "bug"):
+        if head.startswith(sev):
+            return sev
+    return "unknown"
+
+
+def mesh_decision(severity: str) -> str:
+    """Map a severity to a gate decision: allow | hold | block."""
+    return {"bug": "block", "risky": "hold"}.get(severity, "allow")
+
+
+def _parse_verdict(msg: dict | None) -> str | None:
+    if not msg:
+        return None
+    text = (msg.get("content") or msg.get("reasoning_content") or "").strip()
+    for line in text.splitlines():
+        s = line.strip()
+        if s.upper().startswith("VERDICT:"):
+            return s.split(":", 1)[1].strip()
+    return text.splitlines()[0][:120] if text else None
+
+
+def _review_one(backend, lens: dict, content: str) -> str | None:
+    prompt = (
+        f"You are an independent code reviewer. {lens['sys']}{_VERDICT_SHAPE}\n\n"
+        f"Proposed change:\n{content}\n\nVerdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    for _ in range(2):  # one retry: reviewers run against a sometimes-flaky API
+        try:
+            return _parse_verdict(backend.chat(messages, [], 0.0, 256))
+        except Exception:  # noqa: BLE001 - one lens failing must not sink the gate
+            continue
+    return None
+
+
+def _reviewer_chains(settings):
+    """One backend per lens, drawn from the configured council deployments so
+    the lenses are model-diverse; falls back to the guardian deployment."""
+    deps = list(settings.parallel_deployments) or [settings.guardian_deployment]
+    return [
+        (lens, backend_for_deployment(settings, deps[i % len(deps)]))
+        for i, lens in enumerate(LENSES)
+    ]
+
+
+def _guardian_synthesis(settings, content: str, lenses: list[dict]) -> str | None:
+    blocks = "\n".join(f"{r['label']}: {r['verdict'] or '(no verdict)'}" for r in lenses)
+    prompt = (
+        "Several reviewers independently checked a proposed code change; their "
+        "verdicts are below. Issue the final gate verdict, weighing the most "
+        f"severe valid concern.{_VERDICT_SHAPE}\n\n"
+        f"Reviewer verdicts:\n{blocks}\n\nThe change:\n{content}\n\nFinal verdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    for _ in range(2):
+        try:
+            v = _parse_verdict(backend_for_deployment(settings, settings.guardian_deployment)
+                               .chat(messages, [], 0.0, 256))
+            if v:
+                return v
+        except Exception:  # noqa: BLE001 - degrade to the worst lens verdict
+            break
+    return _worst_verdict(lenses)
+
+
+def _worst_verdict(lenses: list[dict]) -> str | None:
+    """Fallback final verdict: the single most severe lens verdict."""
+    ranked = sorted(lenses, key=lambda r: _SEVERITY_RANK.get(r["severity"], 1), reverse=True)
+    return ranked[0]["verdict"] if ranked else None
+
+
+def mesh_review(settings, content: str, *, on_event=None, max_chars: int = 8000) -> dict:
+    """Run the parallel verification mesh over ``content``.
+
+    Returns ``{lenses, verdict, severity, decision}`` where ``lenses`` is a list
+    of ``{key, label, verdict, severity}`` and ``decision`` is allow|hold|block.
+    ``on_event`` (optional) receives :mod:`deepparallel.session` events.
+    """
+    content = (content or "")[:max_chars]
+    chains = _reviewer_chains(settings)
+    if on_event:
+        on_event(session.verify_start(content.splitlines()[0][:80] if content else "change"))
+
+    results: list[dict | None] = [None] * len(chains)
+    with ThreadPoolExecutor(max_workers=min(8, max(1, len(chains)))) as pool:
+        futures = {
+            pool.submit(_review_one, backend, lens, content): (i, lens)
+            for i, (lens, backend) in enumerate(chains)
+        }
+        for future in as_completed(futures):
+            i, lens = futures[future]
+            v = future.result()
+            sev = verdict_severity(v)
+            results[i] = {"key": lens["key"], "label": lens["label"], "verdict": v, "severity": sev}
+            if on_event:
+                on_event(session.verdict(lens["label"], v, sev))
+
+    lenses = [r for r in results if r is not None]
+    final = _guardian_synthesis(settings, content, lenses)
+    fsev = verdict_severity(final)
+    decision = mesh_decision(fsev)
+    if on_event:
+        on_event(session.gate(decision, final, fsev))
+    return {"lenses": lenses, "verdict": final, "severity": fsev, "decision": decision}
+
+
+def format_panel(result: dict) -> str:
+    """A compact multi-line rendering of a mesh result for a confirm card / CLI."""
+    glyph = {"safe": "✓", "risky": "!", "bug": "✗", "unknown": "?"}
+    lines = [
+        f"  {glyph.get(r['severity'], '?')} {r['label']}: {r['verdict'] or '(no verdict)'}"
+        for r in result.get("lenses", [])
+    ]
+    final = result.get("verdict") or "(no verdict)"
+    lines.append(f"  = Gate [{result.get('decision', 'allow').upper()}]: {final}")
+    return "\n".join(lines)