alter-runtime 0.4.9__tar.gz → 0.4.10__tar.gz

{alter_runtime-0.4.9 → alter_runtime-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alter-runtime
-Version: 0.4.9
+Version: 0.4.10
 Summary: ~Alter Identity Runtime - local daemon for the continuous identity field. Subscribes to per-~handle Cloudflare Durable Objects, exposes Unix socket + D-Bus + CLI surfaces, falls back gracefully to direct MCP polling.
 Project-URL: Homepage, https://truealter.com
 Project-URL: Documentation, https://truealter.com/docs/alter-runtime

{alter_runtime-0.4.9 → alter_runtime-0.4.10}/alter_runtime/adapters/__init__.py

@@ -14,10 +14,12 @@ runtime component.
 
 from alter_runtime.adapters.claude_jsonl_watcher import ClaudeJsonlWatcher
 from alter_runtime.adapters.git_watcher import GitWatcher
+from alter_runtime.adapters.loom_verdict_exporter import LoomVerdictExporter
 from alter_runtime.adapters.worktree_watcher import WorktreeWatcher
 
 __all__ = [
     "ClaudeJsonlWatcher",
     "GitWatcher",
+    "LoomVerdictExporter",
     "WorktreeWatcher",
 ]

alter_runtime-0.4.10/alter_runtime/adapters/loom_verdict_exporter.py

@@ -0,0 +1,540 @@
+"""LoomVerdictExporter - desktop-only producer for the read-only
+cross-machine loom-verdict feed.
+
+Design doc (alter monorepo, source of truth for this component):
+``docs/scoping/loom-cross-machine-readonly-verdict-2026-07-09.md``
+sections 3 (wire schema + strict serializer), 5 (device-bound trust), and
+7 (patent boundary).
+
+Shape
+-----
+
+Only the machine that IS the loom validator (today, Blake's desktop) runs
+this component (``DaemonConfig.loom_verdict_exporter_enabled``, default
+``False``). It tails the LOCAL verdict store the validator already writes
+(``scripts/verdict_store.py`` in the alter monorepo, schema 2, one JSON
+file per concern under ``~/.local/share/alter/verdicts/``) and, for every
+new-or-changed row whose concern is a loom concern, POSTs a strict
+four-field projection to
+``POST /api/v1/identity-events/loom-verdict`` signed with the device's
+registered ``AgentSigningKey`` (the same ES256 invocation-signing path
+that already gates the daemon's MCP ``tools/call`` traffic - see
+:mod:`alter_runtime.invocation_signing`).
+
+This is the AMBIENT produce trigger only (design doc section 2): the
+validator computes a standing verdict on its own write-settle cadence and
+this component relays it. The REMOTE-REQUEST trigger (a thin client
+asking the desktop to run a fresh validation against a coordinate it has
+never seen) and the thin-client LAND-TIME ADMISSION gate that eventually
+*consumes* a mirrored verdict are both explicitly OUT OF SCOPE here - they
+belong to the Unit-4 land-kernel owner (design doc section 4's flagged
+open boundary). This module only ever reads local files and POSTs; it
+never runs a validator itself and never touches quarantined kernel code.
+
+STRICT 4-FIELD WIRE ALLOWLIST (the patent-leak guard)
+------------------------------------------------------
+
+The local verdict-store row carries a free-text ``detail`` field plus
+``basis`` / ``basis_inputs`` dicts (absolute worktree paths today; a
+future validator revision could plausibly write Patent-AR-class
+arbitration/cascade reasoning into ``detail`` to explain *why* a verdict
+landed where it did). :func:`row_to_wire_payload` is a strict allowlist
+transform with two independent enforcement layers:
+
+1. It reads ONLY ``row["verdict"]``, ``row["basis_digest"]`` (renamed to
+   the wire's ``basis_hash``), and ``row["observed_at"]``. ``detail``,
+   ``basis``, ``basis_inputs``, and any other row key are never read by
+   this function - there is no code path for them to reach the wire.
+2. Even if a future edit to this function accidentally read one of those
+   keys, constructing :class:`LoomVerdictWirePayload` (``extra="forbid"``)
+   by NAMING each field explicitly - never by splatting the row
+   (``**row``) - means an unexpected extra key raises ``ValidationError``
+   at construction time instead of silently forwarding.
+
+See ``tests/test_loom_verdict_exporter.py`` for the leak-guard assertions.
+
+Cross-platform
+--------------
+
+Pure ``pathlib`` + a portable poll loop (no ``inotify``/``watchdog``
+dependency, no ``fcntl``): the verdict store changes at most once per
+Loom-validate run, so a few seconds of poll latency is an acceptable
+trade for identical behaviour on Linux, macOS, and Windows. Cursor state
+is written via tempfile + ``os.replace`` (atomic rename on all three
+platforms).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import httpx
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+from alter_runtime.config import DaemonConfig, data_dir
+from alter_runtime.daemon import Component
+from alter_runtime.invocation_signing import build_invocation_signature
+
+if TYPE_CHECKING:
+    from alter_runtime.config import Session, SessionRef
+
+__all__ = [
+    "CURSOR_FILENAME",
+    "LOOM_CONCERN_PREFIX",
+    "LoomVerdictExporter",
+    "LoomVerdictWirePayload",
+    "default_cursor_path",
+    "row_to_wire_payload",
+    "verdict_store_dir",
+]
+
+logger = logging.getLogger("alter_runtime.adapters.loom_verdict_exporter")
+
+#: Only verdict-store rows whose ``concern`` starts with this prefix are
+#: eligible for cross-machine export. This is the scoping half of the
+#: patent-boundary guard: the local verdict store also carries unrelated
+#: concerns (e.g. ``disclosure:...``, ``lesson-rung:...`` per
+#: ``scripts/verdict_store.py``'s schema-2 docstring) that must never
+#: leave the desktop. Only concerns the loom validator itself writes
+#: belong on the wire.
+LOOM_CONCERN_PREFIX = "loom:"
+
+#: Cursor filename (within ``data_dir()``) tracking, per concern, the
+#: ``observed_at`` of the last row successfully exported - survives
+#: daemon restarts without re-emitting duplicates on every boot.
+CURSOR_FILENAME = "loom-verdict-exporter-cursor.json"
+
+#: Env var matching ``scripts/verdict_store.py``'s own ``store_dir()``
+#: resolution NAME exactly. That module lives in the sibling alter
+#: monorepo, not an installable dependency of alter-runtime, so its path
+#: resolution is intentionally replicated (not imported) here. Any change
+#: to the upstream store path/env-var must be mirrored in this constant.
+_VERDICT_STORE_DIR_ENV = "ALTER_VERDICT_STORE_DIR"
+
+#: Valid wire verdict values (matches the backend's
+#: ``LoomVerdictIngestRequest.verdict`` Literal exactly).
+_WIRE_VERDICTS = ("GREEN", "RED", "STALE", "UNKNOWN")
+
+
+def verdict_store_dir() -> Path:
+    """Resolve the local verdict-store directory the desktop validator writes.
+
+    Mirrors ``scripts/verdict_store.py:store_dir()`` (alter monorepo)
+    byte-for-byte: ``pathlib.Path.home()``-based, portable across Linux,
+    macOS, and Windows (this is the upstream producer's contract, not
+    XDG-namespaced - not ours to change; alter-runtime's own
+    :func:`alter_runtime.config.data_dir` is deliberately NOT reused here
+    because it would resolve to a different directory than the one the
+    validator actually writes to).
+    """
+    override = os.environ.get(_VERDICT_STORE_DIR_ENV)
+    return Path(override) if override else Path.home() / ".local" / "share" / "alter" / "verdicts"
+
+
+class LoomVerdictWirePayload(BaseModel):
+    """The exact four-field allowlist the backend's
+    ``LoomVerdictIngestRequest`` accepts (alter monorepo
+    ``backend/app/schemas/identity_events.py``). ``extra="forbid"`` is the
+    second, independent enforcement layer for the patent-leak guard
+    described in the module docstring - never construct this by splatting
+    an upstream row (``**row``); name every field explicitly.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    verdict: Literal["GREEN", "RED", "STALE", "UNKNOWN"]
+    basis_hash: str
+    observed_at: str
+    producer_id: str
+
+
+def _decayed_verdict(row: dict[str, Any]) -> str | None:
+    """Return the decay-honest lowercase verdict for a schema-2 row, or
+    ``None`` if the row's verdict is missing/unrecognised.
+
+    Mirrors ``scripts/verdict_store.py``'s ``_apply_decay`` /
+    ``_ttl_expired`` (replicated, not imported - see module docstring): a
+    ``green``/``red`` row whose ``decay.ttl_s`` has elapsed since
+    ``observed_at`` degrades to ``"stale"`` here too, so the exporter
+    never wires out a confidently green/red verdict that the LOCAL reader
+    itself would already treat as stale. The stored file is never
+    rewritten; this is read-time honesty only, exactly like the source
+    module.
+    """
+    verdict = row.get("verdict")
+    if verdict not in ("green", "red", "stale", "unknown"):
+        return None
+    if verdict not in ("green", "red"):
+        return verdict
+    ttl = (row.get("decay") or {}).get("ttl_s")
+    if not ttl:
+        return verdict
+    observed_at = row.get("observed_at")
+    if not isinstance(observed_at, str):
+        return "stale"
+    try:
+        observed = datetime.fromisoformat(observed_at)
+    except ValueError:
+        return "stale"  # An unparseable timestamp can never prove freshness.
+    if observed.tzinfo is None:
+        observed = observed.replace(tzinfo=timezone.utc)
+    if (datetime.now(timezone.utc) - observed).total_seconds() > ttl:
+        return "stale"
+    return verdict
+
+
+def row_to_wire_payload(row: dict[str, Any], *, producer_id: str) -> LoomVerdictWirePayload | None:
+    """Strict allowlist transform: a verdict-store row -> the four-field
+    wire payload, or ``None`` when the row is malformed or ineligible.
+
+    ``producer_id`` is supplied by the CALLER (derived from the local
+    device's own signing-key identity - see
+    :meth:`LoomVerdictExporter._producer_id`); it is NEVER read from
+    ``row``. See the module docstring for the two-layer patent-leak guard
+    this function implements.
+    """
+    if not isinstance(row, dict):
+        return None
+    if row.get("schema") != 2:
+        return None
+    concern = row.get("concern")
+    if not isinstance(concern, str) or not concern.startswith(LOOM_CONCERN_PREFIX):
+        return None
+
+    decayed = _decayed_verdict(row)
+    if decayed is None:
+        return None
+    wire_verdict = decayed.upper()
+    if wire_verdict not in _WIRE_VERDICTS:
+        return None
+
+    basis_hash = row.get("basis_digest")
+    observed_at = row.get("observed_at")
+    if not isinstance(basis_hash, str) or not basis_hash:
+        return None
+    if not isinstance(observed_at, str) or not observed_at:
+        return None
+
+    try:
+        return LoomVerdictWirePayload(
+            verdict=wire_verdict,  # type: ignore[arg-type]
+            basis_hash=basis_hash,
+            observed_at=observed_at,
+            producer_id=producer_id,
+        )
+    except ValidationError:
+        # Fail-closed: an unexpected shape is dropped, never forwarded
+        # partially. Should be unreachable given the checks above; kept as
+        # the second enforcement layer described in the module docstring.
+        logger.warning(
+            "loom_verdict_exporter: row for concern=%r failed the wire-payload "
+            "allowlist validation - dropping (never forwarding a partial row)",
+            concern,
+        )
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Cursor persistence (survives daemon restarts without re-emitting)
+# ---------------------------------------------------------------------------
+
+
+def default_cursor_path() -> Path:
+    return data_dir() / CURSOR_FILENAME
+
+
+def _load_cursor(path: Path) -> dict[str, str]:
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return {str(k): str(v) for k, v in data.items() if isinstance(v, str)}
+    except (OSError, json.JSONDecodeError):
+        pass
+    return {}
+
+
+def _save_cursor(path: Path, cursor: dict[str, str]) -> None:
+    """Atomically write the cursor file (tempfile + fsync + os.replace).
+
+    No ``fcntl`` - single-writer-at-a-time by construction (one exporter
+    instance polls at a time) and this pattern is portable to Windows,
+    unlike the ``flock``-based idiom used by the append-only JSONL writers
+    elsewhere in this package.
+    """
+    tmp = path.with_suffix(".tmp")
+    try:
+        tmp.write_text(json.dumps(cursor, indent=2, sort_keys=True), encoding="utf-8")
+        with tmp.open("rb") as f:
+            os.fsync(f.fileno())
+        os.replace(tmp, path)
+    except OSError as exc:
+        logger.warning("loom_verdict_exporter: cursor write failed: %s", exc)
+        with contextlib.suppress(OSError):
+            tmp.unlink()
+
+
+# ---------------------------------------------------------------------------
+# LoomVerdictExporter
+# ---------------------------------------------------------------------------
+
+
+class LoomVerdictExporter(Component):
+    """Tails the local loom-concern verdict-store rows and re-emits each
+    as a signed ``loom_verdict`` POST to the backend.
+
+    Parameters
+    ----------
+    config:
+        Loaded :class:`DaemonConfig`. Uses ``loom_verdict_exporter_enabled``
+        (checked by the daemon wiring, not this class),
+        ``loom_verdict_exporter_poll_interval_seconds``, and
+        ``loom_verdict_endpoint``.
+    session:
+        Authenticated CLI :class:`Session` or a live :class:`SessionRef`.
+        Supplies the bearer JWT and the ES256 signing-key identity
+        (``signing_kid`` / ``signing_key_fingerprint``) used to build the
+        ``Mcp-Invocation-Signature`` header.
+    http_client:
+        Optional ``httpx.AsyncClient`` override for tests.
+    store_dir:
+        Override the verdict-store directory for tests (defaults to
+        :func:`verdict_store_dir`).
+    poll_interval_seconds:
+        Override the poll cadence for tests.
+    cursor_path:
+        Override the cursor file path for tests (defaults to
+        :func:`default_cursor_path`, i.e. ``data_dir()``). Tests MUST pass
+        this (or redirect ``XDG_DATA_HOME``) - otherwise the exporter
+        reads/writes the real ``~/.local/share/alter-runtime/`` cursor
+        file, leaking cross-test-run state onto the developer's machine.
+    """
+
+    name = "loom_verdict_exporter"
+
+    def __init__(
+        self,
+        config: DaemonConfig,
+        session: "Session | SessionRef",
+        *,
+        http_client: httpx.AsyncClient | None = None,
+        store_dir: Path | None = None,
+        poll_interval_seconds: float | None = None,
+        cursor_path: Path | None = None,
+    ) -> None:
+        self._config = config
+        from alter_runtime.config import SessionRef as _SessionRef
+
+        if isinstance(session, _SessionRef):
+            self._session_ref: "_SessionRef | None" = session
+            self._session: "Session" = session.current
+        else:
+            self._session_ref = None
+            self._session = session  # type: ignore[assignment]
+
+        self._http_client = http_client
+        self._owns_client = http_client is None
+        self._store_dir = store_dir if store_dir is not None else verdict_store_dir()
+        self._poll_interval = (
+            poll_interval_seconds
+            if poll_interval_seconds is not None
+            else config.loom_verdict_exporter_poll_interval_seconds
+        )
+        self._cursor_path = cursor_path if cursor_path is not None else default_cursor_path()
+        self._stop_event = asyncio.Event()
+        self._cursor: dict[str, str] = _load_cursor(self._cursor_path)
+
+        # Test/observability introspection counters.
+        self.export_count = 0
+        self.skip_count = 0
+
+    def _live_session(self) -> "Session":
+        if self._session_ref is not None:
+            return self._session_ref.current
+        return self._session
+
+    @staticmethod
+    def _producer_id(session: "Session") -> str | None:
+        """Derive a device-identity string from the local ES256 signing
+        key. NEVER reads a value from the verdict row or any
+        caller-suppliable input - this is the daemon's own credential.
+
+        The backend derives ``producer_id`` server-side from the verified
+        signing key and IGNORES any caller-supplied value
+        (``backend/app/api/v1/endpoints/identity_events.py::
+        _derive_loom_producer_id`` + ``post_loom_verdict``, foundation
+        ``skein/feat-loom-verdict-feed-foundation`` @ 8be402150). We still
+        send the device's own key identity here for schema compatibility
+        and forward-honesty; the backend overwrites it, so the served value
+        is authoritative regardless of what this exporter sends.
+        """
+        fingerprint = getattr(session, "signing_key_fingerprint", None)
+        if fingerprint:
+            return f"es256-fp:{fingerprint}"
+        kid = getattr(session, "signing_kid", None)
+        if kid:
+            return f"es256-kid:{kid}"
+        return None
+
+    # ------------------------------------------------------------------
+    # Component lifecycle
+    # ------------------------------------------------------------------
+
+    async def run(self) -> None:
+        client = self._http_client or httpx.AsyncClient(timeout=httpx.Timeout(10.0))
+        logger.info(
+            "loom_verdict_exporter starting store_dir=%s endpoint=%s poll_interval=%.1fs",
+            self._store_dir,
+            self._config.loom_verdict_endpoint,
+            self._poll_interval,
+        )
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    await self._poll_once(client)
+                except Exception as exc:  # noqa: BLE001 - one bad poll must not kill the loop
+                    logger.warning("loom_verdict_exporter: poll iteration failed: %s", exc)
+                try:
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=self._poll_interval)
+                except (TimeoutError, asyncio.TimeoutError):
+                    pass
+        finally:
+            if self._owns_client:
+                with contextlib.suppress(Exception):
+                    await client.aclose()
+            logger.info("loom_verdict_exporter stopped")
+
+    async def stop(self) -> None:
+        """Cooperative shutdown - releases the poll loop."""
+        self._stop_event.set()
+
+    # ------------------------------------------------------------------
+    # Poll + emit
+    # ------------------------------------------------------------------
+
+    async def _poll_once(self, client: httpx.AsyncClient) -> None:
+        """Scan the verdict-store directory once and emit any new rows."""
+        if not self._store_dir.is_dir():
+            return
+
+        session = self._live_session()
+        producer_id = self._producer_id(session)
+        if producer_id is None:
+            logger.warning(
+                "loom_verdict_exporter: no signing key available "
+                "(session.signing_kid unset) - cannot emit a device-bound "
+                "loom_verdict; skipping this poll"
+            )
+            return
+
+        for path in sorted(self._store_dir.glob("*.json")):
+            try:
+                row = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+
+            payload = row_to_wire_payload(row, producer_id=producer_id)
+            if payload is None:
+                continue
+
+            concern = row["concern"]
+            last_observed_at = self._cursor.get(concern)
+            if last_observed_at is not None and payload.observed_at <= last_observed_at:
+                continue  # Already exported this (or a newer) observation.
+
+            ok = await self._emit(client, session, payload)
+            if ok:
+                self._cursor[concern] = payload.observed_at
+                _save_cursor(self._cursor_path, self._cursor)
+                self.export_count += 1
+            else:
+                self.skip_count += 1
+
+    async def _emit(
+        self,
+        client: httpx.AsyncClient,
+        session: "Session",
+        payload: LoomVerdictWirePayload,
+    ) -> bool:
+        """POST one wire payload, signed. Returns True on confirmed success."""
+        # tool_args MUST equal exactly what the server recomputes as
+        # ``body.model_dump(exclude={"thread_id"})`` - since this payload
+        # carries no thread_id field at all, model_dump() already matches
+        # byte-for-byte (the canonicalisation itself is delegated entirely
+        # to build_invocation_signature / the server's canonical_args_sha256,
+        # both sort_keys=True + compact separators + ensure_ascii=False).
+        tool_args = payload.model_dump()
+        jws = build_invocation_signature(session, "loom_verdict.emit", tool_args)
+        if jws is None:
+            logger.warning(
+                "loom_verdict_exporter: could not build Mcp-Invocation-Signature "
+                "(missing/unreadable signing key) - skipping this export"
+            )
+            return False
+
+        headers = {
+            "Authorization": f"Bearer {session.jwt}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Mcp-Invocation-Signature": jws,
+        }
+
+        try:
+            response = await client.post(
+                self._config.loom_verdict_endpoint,
+                json=tool_args,
+                headers=headers,
+            )
+        except httpx.HTTPError as exc:
+            logger.warning("loom_verdict_exporter: POST transport error: %s", exc)
+            return False
+
+        if response.status_code >= 400:
+            logger.warning(
+                "loom_verdict_exporter: backend rejected loom_verdict status=%d body=%s",
+                response.status_code,
+                response.text[:256],
+            )
+            return False
+
+        # The endpoint returns HTTP 200 with {"ok": false, ...} when the DO
+        # itself rejects the envelope - a plain status check misses that.
+        try:
+            body = response.json()
+        except ValueError:
+            body = None
+        if isinstance(body, dict) and body.get("ok") is False:
+            logger.warning(
+                "loom_verdict_exporter: backend ok=false do_status=%s error=%s",
+                body.get("do_status"),
+                body.get("error"),
+            )
+            return False
+
+        logger.info(
+            "loom_verdict_exporter: emitted verdict=%s basis_hash=%s status=%d",
+            payload.verdict,
+            payload.basis_hash[:12],
+            response.status_code,
+        )
+        return True
+
+    # ------------------------------------------------------------------
+    # Test introspection
+    # ------------------------------------------------------------------
+
+    @property
+    def store_dir(self) -> Path:
+        return self._store_dir
+
+    @property
+    def cursor(self) -> dict[str, str]:
+        return self._cursor

{alter_runtime-0.4.9 → alter_runtime-0.4.10}/alter_runtime/adapters/worktree_watcher.py

@@ -17,9 +17,8 @@ Signals
           "ts":        "2026-05-21T12:34:56.789012+00:00",
       }
 
-Published on the ``local.signal`` topic. ``WeaveIntentWriter`` subscribes and
-projects the event into ``weave-intent.jsonl`` as a coarse ``worktree_edit``
-record (coarse "dangling edge" degradation path).
+Published on the ``local.signal`` topic for any downstream subscriber that
+consumes working-tree save events.
 
 Design notes
 ------------

{alter_runtime-0.4.9 → alter_runtime-0.4.10}/alter_runtime/config.py

@@ -899,6 +899,43 @@ class DaemonConfig:
     #: Override via ``ALTER_RUNTIME_DOCTRINE_PROJECTION_INTERVAL_SECONDS``.
     doctrine_projection_interval_seconds: float = 60.0
 
+    # --- Loom verdict cross-machine feed (read-only foundation) ----------
+    # Design doc: docs/scoping/loom-cross-machine-readonly-verdict-2026-07-09.md
+    # (alter monorepo). Two independent components share this config block:
+    # the desktop LoomVerdictExporter (producer side) and the thin-client
+    # LoomVerdictSubscriber (read-only mirror side). A single host may run
+    # either, both, or neither depending on whether it IS the loom
+    # validator or merely reads a served verdict.
+    #: Master toggle for :class:`LoomVerdictExporter`. Default ``False``:
+    #: only the machine that IS the loom validator (today, Blake's desktop)
+    #: should ever tail its local verdict store and re-emit rows
+    #: cross-machine. A thin client has no validator verdicts to export;
+    #: enabling this there is a harmless no-op (the poll finds nothing
+    #: matching the ``loom:`` concern prefix) but the default stays off so
+    #: the capability is opt-in per the design's single-producer-of-record
+    #: posture (section 2). Enable via
+    #: ``ALTER_RUNTIME_LOOM_VERDICT_EXPORTER=1`` on the validator host only.
+    loom_verdict_exporter_enabled: bool = False
+    #: Poll interval for the exporter's verdict-store tail. A portable
+    #: poll-based tail (no inotify/watchdog dependency) so Windows, macOS,
+    #: and Linux behave identically - the verdict store is written
+    #: relatively infrequently (once per Loom-validate run), so a few
+    #: seconds of latency is an acceptable trade for portability. Override
+    #: via ``ALTER_RUNTIME_LOOM_VERDICT_EXPORTER_POLL_INTERVAL_SECONDS``.
+    loom_verdict_exporter_poll_interval_seconds: float = 5.0
+    #: Backend REST endpoint the exporter POSTs the strict 4-field
+    #: allowlist payload to (``POST .../identity-events/loom-verdict``).
+    #: Override via ``ALTER_RUNTIME_LOOM_VERDICT_ENDPOINT``.
+    loom_verdict_endpoint: str = "https://api.truealter.com/api/v1/identity-events/loom-verdict"
+
+    #: Master toggle for :class:`LoomVerdictSubscriber` (thin-client
+    #: read-only mirror). Default ``True``, mirroring
+    #: :class:`~alter_runtime.subscribers.agent_frames.AgentFrameSubscriber`'s
+    #: always-on posture: it is read-only, cheap (filters the existing
+    #: DO-SSE bus stream), and safe on every host including the validator's
+    #: own desktop. Disable via ``ALTER_RUNTIME_LOOM_VERDICT_SUBSCRIBER=0``.
+    loom_verdict_subscriber_enabled: bool = True
+
     @classmethod
     def load(cls) -> DaemonConfig:
         """Load config from environment + YAML file + defaults.
@@ -1053,6 +1090,28 @@ class DaemonConfig:
             except ValueError:
                 pass  # Ignore malformed override; default stands.
 
+        # --- Loom verdict cross-machine feed -----------------------------
+        _lve_flag = os.environ.get("ALTER_RUNTIME_LOOM_VERDICT_EXPORTER", "").lower()
+        if _lve_flag in ("0", "false", "no", "off"):
+            config.loom_verdict_exporter_enabled = False
+        elif _lve_flag in ("1", "true", "yes", "on"):
+            config.loom_verdict_exporter_enabled = True
+        if lve_interval := os.environ.get(
+            "ALTER_RUNTIME_LOOM_VERDICT_EXPORTER_POLL_INTERVAL_SECONDS"
+        ):
+            try:
+                config.loom_verdict_exporter_poll_interval_seconds = float(lve_interval)
+            except ValueError:
+                pass  # Ignore malformed override; default stands.
+        if lv_endpoint := os.environ.get("ALTER_RUNTIME_LOOM_VERDICT_ENDPOINT"):
+            config.loom_verdict_endpoint = lv_endpoint
+            env_pinned_endpoints.add("loom_verdict_endpoint")
+        _lvs_flag = os.environ.get("ALTER_RUNTIME_LOOM_VERDICT_SUBSCRIBER", "").lower()
+        if _lvs_flag in ("0", "false", "no", "off"):
+            config.loom_verdict_subscriber_enabled = False
+        elif _lvs_flag in ("1", "true", "yes", "on"):
+            config.loom_verdict_subscriber_enabled = True
+
         if level := os.environ.get("ALTER_RUNTIME_LOG_LEVEL"):
             config.log_level = level
         if socket := os.environ.get("ALTER_RUNTIME_SOCKET"):
@@ -1173,6 +1232,7 @@ class DaemonConfig:
         _require_https("org_alter_caps_endpoint", config.org_alter_caps_endpoint)
         _require_https("org_alter_presence_endpoint", config.org_alter_presence_endpoint)
         _require_https("do_publish_url", config.do_publish_url)
+        _require_https("loom_verdict_endpoint", config.loom_verdict_endpoint)
 
         return config