@agentikos/omega-os 0.1.0

package/omega/Agentik_Engine/omega_engine/audit_arsenal.py

@@ -0,0 +1,314 @@
+"""The Quality Arsenal — forensic audits as the OmegaOS verification layer.
+
+The 18 forensic audits (code, security, performance, ...) become structured,
+agentic audit modules. Each is a compact definition in `Agentik_SSOT/audits/`;
+the common Gestalt-Popper shell — hinge point, adversarial framing, Popper
+falsification, scoring, the fix loop — lives here, once.
+
+A forensic audit runs in two passes:
+  1. GATHER  — deterministic tools (ruff, eslint, ...) collect machine-checkable
+               findings. No LLM, no opinion.
+  2. FALSIFY — an agentic pass: a provider call that, given the gather findings
+               and the artifacts, runs the domain phases under the Popper
+               doctrine ("prove it lies") and emits a STRUCTURED verdict +
+               fix plan.
+
+`ArsenalGate` plugs into the executor exactly where the simple `AuditGate` did —
+it IS the `CLAIMED_DONE → VERIFIED` transition, now backed by the real arsenal.
+"""
+from __future__ import annotations
+
+import fnmatch
+import json
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from omega_engine.audit import AuditFinding, AuditVerdict, audit_runtime_flow
+from omega_engine.provider import AgentProvider, AgentRequest
+
+# --------------------------------------------------------------------------
+# Structured verdict types — "structured facts + fix plan", machine-actionable.
+# --------------------------------------------------------------------------
+
+
+@dataclass
+class ArsenalFinding:
+    audit: str
+    phase: str
+    severity: str            # critical | high | medium | low
+    location: str
+    claim: str               # what the code/feature claims
+    reality: str             # what it actually does
+    category: str = "claim-vs-reality"
+
+
+@dataclass
+class FixTask:
+    id: str
+    finding: str
+    location: str
+    fix: str
+    severity: str
+
+
+@dataclass
+class ArsenalVerdict:
+    audit: str
+    score: int               # 0-100
+    verified: bool
+    confidence: str          # high | medium | low
+    findings: list[ArsenalFinding] = field(default_factory=list)
+    fix_plan: list[FixTask] = field(default_factory=list)
+    summary: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "audit": self.audit, "score": self.score, "verified": self.verified,
+            "confidence": self.confidence, "summary": self.summary,
+            "findings": [f.__dict__ for f in self.findings],
+            "fix_plan": [t.__dict__ for t in self.fix_plan],
+        }
+
+
+# --------------------------------------------------------------------------
+# Audit definition — loaded from Agentik_SSOT/audits/<id>.yaml
+# --------------------------------------------------------------------------
+
+
+@dataclass
+class AuditPhase:
+    id: str
+    checks: str
+
+
+@dataclass
+class GatherTool:
+    name: str
+    cmd: str
+    when: str = "*"          # glob the tool applies to
+
+
+@dataclass
+class Audit:
+    id: str
+    domain: str
+    question: str
+    weight: float = 1.0
+    threshold: int = 85
+    applies_roles: list[str] = field(default_factory=lambda: ["worker"])
+    applies_changed: list[str] = field(default_factory=lambda: ["*"])
+    gather: list[GatherTool] = field(default_factory=list)
+    phases: list[AuditPhase] = field(default_factory=list)
+    falsification: str = ""
+    fix_loop: bool = True
+
+    @staticmethod
+    def from_dict(d: dict) -> "Audit":
+        applies = d.get("applies_to", {}) or {}
+        return Audit(
+            id=d["id"], domain=d["domain"], question=d["question"],
+            weight=float(d.get("weight", 1.0)),
+            threshold=int(d.get("threshold", 85)),
+            applies_roles=list(applies.get("roles", ["worker"])),
+            applies_changed=list(applies.get("changed", ["*"])),
+            gather=[GatherTool(**g) for g in d.get("gather", [])],
+            phases=[AuditPhase(id=p["id"], checks=p["checks"])
+                    for p in d.get("phases", [])],
+            falsification=d.get("falsification", ""),
+            fix_loop=bool(d.get("fix_loop", True)),
+        )
+
+
+class AuditRegistry:
+    """Loads every audit definition from Agentik_SSOT/audits/."""
+
+    def __init__(self, audits: dict[str, Audit]) -> None:
+        self._audits = audits
+
+    @classmethod
+    def load(cls, audits_dir: str | Path) -> "AuditRegistry":
+        import yaml
+        audits: dict[str, Audit] = {}
+        for path in sorted(Path(audits_dir).glob("*.yaml")):
+            data = yaml.safe_load(path.read_text())
+            if data and data.get("id"):
+                audits[data["id"]] = Audit.from_dict(data)
+        return cls(audits)
+
+    def get(self, audit_id: str) -> Audit | None:
+        return self._audits.get(audit_id)
+
+    def all(self) -> list[Audit]:
+        return list(self._audits.values())
+
+    def select(self, role: str, changed: list[str]) -> list[Audit]:
+        """The audits that apply to a task — by role and by changed-file glob."""
+        chosen: list[Audit] = []
+        for audit in self._audits.values():
+            if role not in audit.applies_roles:
+                continue
+            if audit.applies_changed == ["*"] or not changed:
+                chosen.append(audit)
+                continue
+            if any(fnmatch.fnmatch(f, pat)
+                   for f in changed for pat in audit.applies_changed):
+                chosen.append(audit)
+        return chosen
+
+
+# --------------------------------------------------------------------------
+# The forensic run — gather (deterministic) + falsify (agentic)
+# --------------------------------------------------------------------------
+
+_DOCTRINE = """\
+You are a forensic investigator, not a friendly reviewer. The artifact is a
+crime scene. Apply the Gestalt-Popper doctrine:
+- GESTALT: first identify the hinge point — the one place that, if wrong, breaks
+  everything — and scrutinise it 10x.
+- POPPER: do not verify that it works; prove where it LIES. Every name is a
+  claim, every message a promise, every type a contract. Find the divergence.
+- ADVERSARIAL: assume a competitor wrote this. Bias toward FAIL. A perfect score
+  is earned by finding zero falsifiable claims, never by absence of effort.
+Banned conclusions without evidence: "looks correct", "should be fine".
+"""
+
+
+def run_gather(audit: Audit, ctx: dict[str, Any]) -> list[dict[str, Any]]:
+    """Run the audit's deterministic tools. Read-only, never raises."""
+    path = str(ctx.get("path", "."))
+    changed = ctx.get("changed", []) or []
+    results: list[dict[str, Any]] = []
+    for tool in audit.gather:
+        applies = tool.when == "*" or any(
+            fnmatch.fnmatch(f, pat)
+            for f in changed for pat in tool.when.split(","))
+        if changed and not applies:
+            results.append({"tool": tool.name, "status": "skipped",
+                            "reason": "no matching changed files"})
+            continue
+        cmd = tool.cmd.replace("{path}", path)
+        try:
+            proc = subprocess.run(cmd, shell=True, capture_output=True,
+                                  text=True, timeout=180)
+            results.append({"tool": tool.name, "status": "ran",
+                            "exit": proc.returncode,
+                            "output": (proc.stdout or proc.stderr)[:4000]})
+        except Exception as exc:  # noqa: BLE001 — gather must never break the gate
+            results.append({"tool": tool.name, "status": "error",
+                            "reason": str(exc)[:200]})
+    return results
+
+
+def build_audit_prompt(audit: Audit, ctx: dict[str, Any],
+                       gather: list[dict[str, Any]]) -> str:
+    """Compose the agentic falsification prompt — shared shell + domain phases."""
+    phases = "\n".join(f"  - {p.id}: {p.checks}" for p in audit.phases)
+    return (
+        f"{_DOCTRINE}\n"
+        f"AUDIT: {audit.id} — domain {audit.domain}\n"
+        f"THE QUESTION YOU MUST ANSWER: {audit.question}\n\n"
+        f"PHASES — investigate each:\n{phases}\n\n"
+        f"FALSIFICATION RULES: {audit.falsification}\n\n"
+        f"ARTIFACTS UNDER AUDIT:\n{json.dumps(ctx.get('artifacts', {}), indent=2)[:3000]}\n\n"
+        f"DETERMINISTIC GATHER FINDINGS:\n{json.dumps(gather, indent=2)[:3000]}\n\n"
+        f"Emit ONLY a JSON verdict: {{\"score\": 0-100, \"verified\": bool, "
+        f"\"confidence\": \"high|medium|low\", \"summary\": \"...\", "
+        f"\"findings\": [{{\"phase\",\"severity\",\"location\",\"claim\",\"reality\"}}], "
+        f"\"fix_plan\": [{{\"id\",\"finding\",\"location\",\"fix\",\"severity\"}}]}}. "
+        f"score >= {audit.threshold} means verified."
+    )
+
+
+def _parse_verdict(audit: Audit, raw: dict[str, Any]) -> ArsenalVerdict:
+    findings = [
+        ArsenalFinding(
+            audit=audit.id, phase=f.get("phase", "?"),
+            severity=f.get("severity", "medium"),
+            location=f.get("location", "?"),
+            claim=f.get("claim", ""), reality=f.get("reality", ""),
+            category=f.get("category", "claim-vs-reality"),
+        ) for f in raw.get("findings", [])
+    ]
+    fixes = [
+        FixTask(id=t.get("id", f"FIX-{i+1}"), finding=t.get("finding", ""),
+                location=t.get("location", "?"), fix=t.get("fix", ""),
+                severity=t.get("severity", "medium"))
+        for i, t in enumerate(raw.get("fix_plan", []))
+    ]
+    score = int(raw.get("score", 0))
+    return ArsenalVerdict(
+        audit=audit.id, score=score,
+        verified=bool(raw.get("verified", score >= audit.threshold)),
+        confidence=raw.get("confidence", "medium"),
+        findings=findings, fix_plan=fixes,
+        summary=raw.get("summary", ""),
+    )
+
+
+def run_forensic_audit(audit: Audit, ctx: dict[str, Any],
+                       provider: AgentProvider) -> ArsenalVerdict:
+    """One forensic audit: deterministic gather + agentic falsification."""
+    gather = run_gather(audit, ctx)
+    prompt = build_audit_prompt(audit, ctx, gather)
+    result = provider.run(AgentRequest(role="audit", prompt=prompt, context=ctx))
+    raw = result.artifacts.get("verdict")
+    if raw is None:
+        try:
+            raw = json.loads(result.text)
+        except (json.JSONDecodeError, TypeError):
+            raw = {"score": 0, "verified": False, "confidence": "low",
+                   "summary": "audit produced no parseable verdict"}
+    return _parse_verdict(audit, raw)
+
+
+class ArsenalGate:
+    """The verification gate, backed by the Quality Arsenal.
+
+    Drop-in for the executor: `verify(ctx)` returns an `AuditVerdict`, exactly
+    like the simple `AuditGate`. It always runs the mandatory runtime audit
+    (validate-live), then every forensic audit that applies to the task, and
+    aggregates. The rich per-audit verdicts are kept on `.last_verdicts` for the
+    mission report.
+    """
+
+    def __init__(self, registry: AuditRegistry, router: Any,
+                 threshold: int = 85) -> None:
+        self._registry = registry
+        self._router = router
+        self._threshold = threshold
+        self.last_verdicts: list[ArsenalVerdict] = []
+
+    def verify(self, ctx: dict[str, Any]) -> AuditVerdict:
+        findings: list[AuditFinding] = []
+        scores: list[tuple[float, int]] = []  # (weight, score)
+
+        # 1. mandatory runtime audit — validate-live, never skipped
+        runtime = audit_runtime_flow(ctx)
+        findings.append(AuditFinding(runtime.audit, runtime.score, runtime.detail))
+        if runtime.score == 0:
+            # the flow does not run — cannot be VERIFIED, full stop
+            self.last_verdicts = []
+            return AuditVerdict(score=0, verified=False, findings=findings)
+        scores.append((1.0, runtime.score))
+
+        # 2. every forensic audit that applies
+        provider = self._router.resolve("audit")
+        selected = self._registry.select(
+            role=str(ctx.get("role", "worker")),
+            changed=ctx.get("changed", []) or [],
+        )
+        self.last_verdicts = []
+        for audit in selected:
+            verdict = run_forensic_audit(audit, ctx, provider)
+            self.last_verdicts.append(verdict)
+            scores.append((audit.weight, verdict.score))
+            findings.append(AuditFinding(
+                audit.id, verdict.score,
+                f"{verdict.summary} ({len(verdict.findings)} findings)"))
+
+        total_w = sum(w for w, _ in scores)
+        agg = round(sum(w * s for w, s in scores) / total_w) if total_w else 0
+        return AuditVerdict(
+            score=agg, verified=agg >= self._threshold, findings=findings)

package/omega/Agentik_Engine/omega_engine/barrier.py

@@ -0,0 +1,45 @@
+"""The join barrier — structured concurrency for agent graphs.
+
+A dispatcher owns a scope. The scope cannot be JOINABLE until every child is in
+a terminal state. "Parent done when all children done" is therefore not
+something the engine *detects* — it is a mechanical invariant.
+
+This is the structural fix for the "parent finished before its children" bug:
+a dispatcher may only transition toward COMPLETED on receiving `scope.joinable`,
+and the barrier — not the dispatcher — decides when that event fires.
+"""
+from __future__ import annotations
+
+from enum import Enum
+from typing import Sequence
+
+from omega_engine.task import TERMINAL, TaskState
+
+
+class ScopeStatus(str, Enum):
+    RUNNING = "running"    # ≥1 child still alive — the parent CANNOT close
+    PARTIAL = "partial"    # all children terminal, but ≥1 FAILED
+    JOINABLE = "joinable"  # all children terminal and none FAILED — parent unblocked
+
+
+def scope_status(children: Sequence[TaskState]) -> ScopeStatus:
+    """Derive a scope's status from its children's states. Pure.
+
+    - empty scope            → JOINABLE (trivially)
+    - any non-terminal child → RUNNING
+    - all terminal, ≥1 FAILED→ PARTIAL
+    - all terminal, none FAILED → JOINABLE
+
+    PARTIAL is deliberately distinct from JOINABLE. When a scope is PARTIAL the
+    dispatcher must apply an explicit, per-topology policy — retry the failed
+    child, accept the partial result, or fail upward. That policy is declared in
+    Agentik_Orchestration/topologies/<name>.yaml under `on_partial:`, never
+    hard-coded in the engine.
+    """
+    if not children:
+        return ScopeStatus.JOINABLE
+    if any(s not in TERMINAL for s in children):
+        return ScopeStatus.RUNNING
+    if any(s is TaskState.FAILED for s in children):
+        return ScopeStatus.PARTIAL
+    return ScopeStatus.JOINABLE

package/omega/Agentik_Engine/omega_engine/bus.py

@@ -0,0 +1,45 @@
+"""The event bus — push, not poll (principle 5).
+
+The bus is the live path: a task emits an event, the bus appends it to the store
+(the durable source of truth) and pushes it to every subscriber synchronously.
+Subscribers are the progress tracker, the Telegram bridge, the supervisor.
+"""
+from __future__ import annotations
+
+from typing import Callable
+
+from omega_engine.events import Event
+from omega_engine.store import EventStore
+
+Subscriber = Callable[[Event], None]
+
+
+class EventBus:
+    """Appends every event to the store, then pushes it to all subscribers.
+
+    Synchronous and in-process — simple and correct. A Redis pub/sub bus can
+    replace this behind the same `publish` / `subscribe` surface for multi-process
+    deployments.
+    """
+
+    def __init__(self, store: EventStore) -> None:
+        self._store = store
+        self._subscribers: list[Subscriber] = []
+
+    def subscribe(self, fn: Subscriber) -> None:
+        """Register a callback invoked for every published event."""
+        self._subscribers.append(fn)
+
+    def publish(self, event: Event) -> Event:
+        """Persist the event, then notify subscribers. Returns the event.
+
+        A failing subscriber must never corrupt the log — its exception is
+        swallowed (the event is already durably stored).
+        """
+        self._store.append(event)
+        for fn in list(self._subscribers):
+            try:
+                fn(event)
+            except Exception:  # noqa: BLE001 — a bad subscriber must not break the bus
+                pass
+        return event

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -0,0 +1,158 @@
+"""The `omega` command-line interface.
+
+A thin entry point. The installer's doctor step calls `omega doctor`; operators
+use `omega status` to see every task's derived state.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from omega_engine import __version__
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def cmd_version(_args: argparse.Namespace) -> int:
+    print(f"omega-engine {__version__}")
+    return 0
+
+
+def cmd_doctor(_args: argparse.Namespace) -> int:
+    """Validate an Omega OS deployment: the 8-block tree + the event store."""
+    home = _omega_home()
+    blocks = [
+        "Agentik_SSOT", "Agentik_Engine", "Agentik_Orchestration",
+        "Agentik_Providers", "Agentik_Coding", "Agentik_Tools",
+        "Agentik_Runtime", "Agentik_Extra",
+    ]
+    ok = True
+    print(f"omega doctor — OMEGA_HOME={home}")
+    for b in blocks:
+        present = (home / b).is_dir()
+        print(f"  [{'ok' if present else 'MISSING'}] {b}")
+        ok = ok and present
+    store = home / "Agentik_Runtime" / "eventlog" / "omega.db"
+    print(f"  [{'ok' if store.exists() else 'pending'}] event store: {store}")
+    print("doctor: PASS" if ok else "doctor: FAIL")
+    return 0 if ok else 1
+
+
+def cmd_status(_args: argparse.Namespace) -> int:
+    """Show every task and its derived state — the event log is the truth."""
+    from omega_engine.reducer import reduce_task
+    from omega_engine.store import SQLiteStore
+
+    db = _omega_home() / "Agentik_Runtime" / "eventlog" / "omega.db"
+    if not db.exists():
+        print("no event store yet — nothing running")
+        return 0
+    store = SQLiteStore(db)
+    ids = store.task_ids()
+    if not ids:
+        print("event store is empty")
+        return 0
+    for task_id in sorted(ids):
+        state = reduce_task(store.events_for(task_id))
+        print(f"  {state.value:<13} {task_id}")
+    return 0
+
+
+def cmd_account(_args: argparse.Namespace) -> int:
+    """Show the Claude Code Max account pool and the selection strategy.
+
+    Omega OS runs one engine, not N tmux sessions — so an account is not
+    "switched" globally. The Claude provider holds a POOL and distributes agent
+    calls across accounts. Add one with `omega account login`.
+    See docs/ACCOUNT-AND-BILLING.md.
+    """
+    cfg = _omega_home() / "Agentik_Providers" / "claude" / "accounts.yaml"
+    if not cfg.exists():
+        cfg = cfg.with_name("accounts.example.yaml")
+    if not cfg.exists():
+        print("no Claude Max account pool configured — see docs/ACCOUNT-AND-BILLING.md")
+        return 0
+    try:
+        import yaml
+    except ImportError:
+        print(f"account pool config: {cfg}  (install pyyaml to render it)")
+        return 0
+    data = yaml.safe_load(cfg.read_text()) or {}
+    pool = data.get("pool", [])
+    print(f"Claude Max account pool — selection: {data.get('selection', 'least-used')}")
+    for a in pool or [{"status": "(empty)", "id": "", "label": ""}]:
+        print(f"  [{str(a.get('status', '?')):<9}] {str(a.get('id', '')):<16} {a.get('label', '')}")
+    print("  add an account:  omega account login   (docs/ACCOUNT-AND-BILLING.md)")
+    return 0
+
+
+def cmd_billing(_args: argparse.Namespace) -> int:
+    """Show usage and cost per Claude Max account.
+
+    Per-account billing reads token usage recorded on the event log against the
+    provider cost model — so you see which account is near its weekly limit.
+    """
+    print("omega billing — usage per Claude Max account")
+    print("  source: token usage on task.* events + the provider cost model")
+    print("  build-out: live per-account aggregation — see docs/ACCOUNT-AND-BILLING.md")
+    return 0
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    """Run a mission end-to-end — Oracle plans, workers execute, the audit gate
+    verifies, and a whitepaper PDF report is produced."""
+    from omega_engine.mission import run_mission
+
+    outcome = run_mission(args.intent)
+    print(f"mission {outcome.result.mission_id}: "
+          f"{outcome.result.final_state.value}  ({outcome.progress_pct}%)")
+    if outcome.report_pdf:
+        print(f"report: {outcome.report_pdf}")
+    return 0 if outcome.result.verified else 1
+
+
+def cmd_project(args: argparse.Namespace) -> int:
+    """Create a project — folder, registry entry, and (if configured) a bound
+    Telegram topic."""
+    from omega_engine.project import create_project
+
+    telegram = None
+    if not args.no_telegram:
+        try:
+            from omega_engine.telegram import TelegramBridge
+            telegram = TelegramBridge.from_vault()
+        except Exception as exc:  # noqa: BLE001
+            print(f"(no Telegram topic — {exc})")
+    project = create_project(args.name, telegram=telegram)
+    print(f"project created: {project.slug}  ->  {project.path}")
+    if project.topic_id:
+        print(f"telegram topic: {project.topic_id}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="omega", description="Omega OS control CLI")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("version", help="print the engine version").set_defaults(fn=cmd_version)
+    sub.add_parser("doctor", help="validate the deployment").set_defaults(fn=cmd_doctor)
+    sub.add_parser("status", help="show all tasks and their derived state").set_defaults(fn=cmd_status)
+    sub.add_parser("account", help="show the Claude Max account pool").set_defaults(fn=cmd_account)
+    sub.add_parser("billing", help="show usage/cost per Claude Max account").set_defaults(fn=cmd_billing)
+    p_run = sub.add_parser("run", help="run a mission end-to-end")
+    p_run.add_argument("intent", help="the mission, in natural language")
+    p_run.set_defaults(fn=cmd_run)
+    p_proj = sub.add_parser("project", help="create a project")
+    p_proj.add_argument("name", help="the project name")
+    p_proj.add_argument("--no-telegram", action="store_true",
+                        help="skip Telegram topic creation")
+    p_proj.set_defaults(fn=cmd_project)
+    args = parser.parse_args(argv)
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/omega/Agentik_Engine/omega_engine/events.py

@@ -0,0 +1,60 @@
+"""Immutable events — the single source of truth.
+
+The state of any task is a fold over its events. No agent ever writes a state;
+agents only append events. See omega_engine.reducer.
+"""
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class EventType(str, Enum):
+    # --- task lifecycle — these drive the reducer ---
+    CREATED = "task.created"
+    DISPATCHED = "task.dispatched"
+    STARTED = "task.started"
+    CLAIMED_DONE = "task.claimed_done"
+    VERIFYING = "task.verifying"
+    VERIFIED = "task.verified"
+    REJECTED = "task.rejected"
+    COMPLETED = "task.completed"
+    FAILED = "task.failed"
+    HEARTBEAT = "task.heartbeat"      # liveness ping — no state change
+    # --- scope event — consumed by the barrier, not the task reducer ---
+    SCOPE_JOINABLE = "scope.joinable"
+
+
+@dataclass(frozen=True)
+class Event:
+    """An immutable fact. Append-only. Never mutated, never deleted."""
+
+    task_id: str
+    type: EventType
+    payload: dict[str, Any] = field(default_factory=dict)
+    id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    ts: float = field(default_factory=time.time)
+
+    def to_row(self) -> dict[str, Any]:
+        """Flatten to a storable row (payload JSON-encoded)."""
+        return {
+            "id": self.id,
+            "task_id": self.task_id,
+            "type": self.type.value,
+            "ts": self.ts,
+            "payload": json.dumps(self.payload, ensure_ascii=False),
+        }
+
+    @staticmethod
+    def from_row(row: dict[str, Any]) -> "Event":
+        return Event(
+            id=row["id"],
+            task_id=row["task_id"],
+            type=EventType(row["type"]),
+            ts=row["ts"],
+            payload=json.loads(row["payload"]) if row.get("payload") else {},
+        )