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

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2026 ALTER Meridian Pty Ltd
+   Copyright 2026 Alter Meridian Pty Ltd
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: alter-runtime
-Version: 0.4.8
+Version: 0.4.9
 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
 Project-URL: Repository, https://github.com/true-alter/alter-runtime
 Project-URL: Bug Tracker, https://github.com/true-alter/alter-runtime/issues
 Author: ~Alter
-Author-email: ALTER Meridian Pty Ltd <hello@truealter.com>
+Author-email: Alter Meridian Pty Ltd <hello@truealter.com>
 License: Apache-2.0
 License-File: LICENSE
 Keywords: agent,ai-agents,alter,cloudflare,durable-object,identity,llm,mcp,model-context-protocol,psychometric,sovereign-identity,verifiable-credentials,x402
@@ -75,10 +75,10 @@ Description-Content-Type: text/markdown
 
 ## Alpha release - filesystem key storage
 
-**`0.1.0` is an alpha release.** The public API surface (CLI flags,
+**This is an alpha release.** The public API surface (CLI flags,
 Unix-socket JSON schema, D-Bus interface, Python SDK signatures) may change in
-backwards-incompatible ways before the `0.2.0` stable cut. Pin exact versions in
-downstream tooling and read the CHANGELOG before upgrading.
+backwards-incompatible ways before the stable release. Pin exact versions in
+downstream tooling before upgrading.
 
 **Private keys are stored on the filesystem, not in an OS keychain.** On first
 `alter-runtime init`, the device Ed25519 keypair is written to
@@ -88,7 +88,7 @@ owning user and never leaves the device. This behaviour is deliberate for the
 alpha: it keeps the daemon self-contained on any POSIX host and avoids a hard
 dependency on distro-specific secret stores during early testing.
 
-**OS-native secret storage is deferred to `0.2.0`:** Linux `libsecret` /
+**OS-native secret storage is deferred to a future release:** Linux `libsecret` /
 `kwallet`, macOS Keychain, and Windows Credential Manager integration will ship
 behind a `keystore = "native"` config knob. Filesystem storage will remain the
 documented fallback.
@@ -100,10 +100,9 @@ attestation). The filesystem-stored device key then scopes only to ambient
 signal ingestion, not to high-assurance authorisations, which require a fresh
 hardware passkey ceremony per session.
 
-**Reporting issues.** Security-relevant reports: please follow
-[SECURITY.md](./SECURITY.md) and email `security@truealter.com` rather than
-filing a public issue. Non-security bugs and feature requests: email
-`support@truealter.com`.
+**Reporting issues.** Security-relevant reports: please email
+`security@truealter.com` rather than filing a public issue. Non-security bugs
+and feature requests: email `support@truealter.com`.
 
 ## Status
 
@@ -161,7 +160,7 @@ alter-runtime stop
    `https://api.truealter.com/api/v1/mcp` when the DO is unreachable for more than 3
    seconds. Your surfaces never know which path served them.
 
-3. **Exposes three local transports:**
+3. **Exposes** three local transports:
    - **Unix socket** at `/run/user/$UID/alter.sock` (Linux) or
      `~/Library/Application Support/alter/runtime.sock` (macOS) - line-delimited JSON
    - **D-Bus** interface `org.alter.Identity1` on the session bus (Linux) - used by
@@ -245,8 +244,7 @@ asyncio.run(main())
 - **Arch Linux (AUR)** - `alter-runtime`
 - **Homebrew** - `brew install alter-runtime`
 
-Pin an exact version in downstream tooling during the alpha and read the
-CHANGELOG before upgrading.
+Pin an exact version in downstream tooling during the alpha before upgrading.
 
 ## Related projects
 

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/README.md

@@ -7,10 +7,10 @@
 
 ## Alpha release - filesystem key storage
 
-**`0.1.0` is an alpha release.** The public API surface (CLI flags,
+**This is an alpha release.** The public API surface (CLI flags,
 Unix-socket JSON schema, D-Bus interface, Python SDK signatures) may change in
-backwards-incompatible ways before the `0.2.0` stable cut. Pin exact versions in
-downstream tooling and read the CHANGELOG before upgrading.
+backwards-incompatible ways before the stable release. Pin exact versions in
+downstream tooling before upgrading.
 
 **Private keys are stored on the filesystem, not in an OS keychain.** On first
 `alter-runtime init`, the device Ed25519 keypair is written to
@@ -20,7 +20,7 @@ owning user and never leaves the device. This behaviour is deliberate for the
 alpha: it keeps the daemon self-contained on any POSIX host and avoids a hard
 dependency on distro-specific secret stores during early testing.
 
-**OS-native secret storage is deferred to `0.2.0`:** Linux `libsecret` /
+**OS-native secret storage is deferred to a future release:** Linux `libsecret` /
 `kwallet`, macOS Keychain, and Windows Credential Manager integration will ship
 behind a `keystore = "native"` config knob. Filesystem storage will remain the
 documented fallback.
@@ -32,10 +32,9 @@ attestation). The filesystem-stored device key then scopes only to ambient
 signal ingestion, not to high-assurance authorisations, which require a fresh
 hardware passkey ceremony per session.
 
-**Reporting issues.** Security-relevant reports: please follow
-[SECURITY.md](./SECURITY.md) and email `security@truealter.com` rather than
-filing a public issue. Non-security bugs and feature requests: email
-`support@truealter.com`.
+**Reporting issues.** Security-relevant reports: please email
+`security@truealter.com` rather than filing a public issue. Non-security bugs
+and feature requests: email `support@truealter.com`.
 
 ## Status
 
@@ -93,7 +92,7 @@ alter-runtime stop
    `https://api.truealter.com/api/v1/mcp` when the DO is unreachable for more than 3
    seconds. Your surfaces never know which path served them.
 
-3. **Exposes three local transports:**
+3. **Exposes** three local transports:
    - **Unix socket** at `/run/user/$UID/alter.sock` (Linux) or
      `~/Library/Application Support/alter/runtime.sock` (macOS) - line-delimited JSON
    - **D-Bus** interface `org.alter.Identity1` on the session bus (Linux) - used by
@@ -177,8 +176,7 @@ asyncio.run(main())
 - **Arch Linux (AUR)** - `alter-runtime`
 - **Homebrew** - `brew install alter-runtime`
 
-Pin an exact version in downstream tooling during the alpha and read the
-CHANGELOG before upgrading.
+Pin an exact version in downstream tooling during the alpha before upgrading.
 
 ## Related projects
 

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/__init__.py

@@ -6,5 +6,5 @@ device touches. See the package README for an overview.
 
 from alter_runtime.sdk.client import AlterClient
 
-__version__ = "0.4.8"
+__version__ = "0.4.9"
 __all__ = ["AlterClient", "__version__"]

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

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

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/adapters/claude_jsonl_watcher.py

@@ -4,7 +4,7 @@ Watches the per-project ``*.jsonl`` transcript files under Claude Code's
 home projects directory with ``watchdog``.
 On modification, reads new lines from the persisted byte offset, parses each
 via the privacy-hard-stop ``parse_assistant_line`` function, and POSTs
-batches to the ALTER backend token-usage audit endpoint.
+batches to the ~alter backend token-usage audit endpoint.
 
 Privacy guarantee
 -----------------
@@ -123,7 +123,7 @@ def parse_assistant_line(record: dict) -> Optional[dict]:
     """Parse one JSONL record and return a token-usage dict, or None.
 
     This is the privacy hard-stop between Claude Code's local transcripts
-    and ALTER's audit database. It is a strict whitelist: the output dict is
+    and ~alter's audit database. It is a strict whitelist: the output dict is
     constructed key-by-key from explicitly named fields. ``record``,
     ``message``, and ``usage`` are NEVER spread. No key beyond the whitelist
     can reach the output.

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/cli.py

@@ -9,6 +9,7 @@ Subcommands:
   daemon    Run the supervisor in the foreground (for systemd Type=exec or debugging).
   query     Query the current materialised view (attunement, warmth, trust tier).
   ingest    Manually ingest a signal (for testing).
+  send      Send a member-to-member message via the running daemon.
 
 Matches the shape of the companion CLI's command handler - a simple switch-on-verb,
 no external CLI framework dependency (argparse is stdlib).
@@ -139,6 +140,20 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_ingest.add_argument("--producer", default="cli:manual", help="Producer identifier.")
 
+    # send
+    p_send = sub.add_parser(
+        "send",
+        help="Send a member-to-member message via the running daemon.",
+    )
+    p_send.add_argument("to", help="Recipient ~handle (e.g. ~peer).")
+    p_send.add_argument("body", help="Message body, markdown, <= 8 KiB.")
+    p_send.add_argument(
+        "--content-type",
+        dest="content_type",
+        default=None,
+        help="Message content_type (default: text/markdown).",
+    )
+
     return parser
 
 
@@ -232,7 +247,7 @@ def cmd_start(args: argparse.Namespace) -> int:
     except UserDeletedArtefact as exc:
         print(
             f"  {exc.args[0]} was previously deleted by the user.\n"
-            "  ALTER will not recreate it automatically.\n"
+            "  ~alter will not recreate it automatically.\n"
             "  To reinstall, run: alter-runtime start --reinstall",
             file=sys.stderr,
         )
@@ -448,6 +463,81 @@ def cmd_ingest(args: argparse.Namespace) -> int:
     return 0
 
 
+def _daemon_token() -> str | None:
+    """Read the daemon auth token written beside the socket, or None."""
+    token_file = unix_socket_path().parent / "alter-daemon-token"
+    try:
+        return token_file.read_text(encoding="utf-8").strip() or None
+    except OSError:
+        return None
+
+
+async def _socket_request(request: dict[str, object]) -> dict[str, object]:
+    """Connect to the daemon socket, authenticate, send one request, return the reply.
+
+    Mirrors the same auth handshake the local MCP bridge performs: read the
+    daemon token file, present it via ``{"method":"auth",...}``, then send the
+    request line and read one JSON reply line.
+    """
+    socket = unix_socket_path()
+    reader, writer = await asyncio.open_unix_connection(str(socket))
+    try:
+        token = _daemon_token()
+        if token:
+            writer.write((json.dumps({"method": "auth", "token": token}) + "\n").encode("utf-8"))
+            await writer.drain()
+            auth_line = await asyncio.wait_for(reader.readline(), timeout=5.0)
+            auth_resp = json.loads(auth_line or b"{}")
+            if not auth_resp.get("ok"):
+                return {"ok": False, "error": f"auth failed: {auth_resp.get('error', 'unknown')}"}
+        writer.write((json.dumps(request) + "\n").encode("utf-8"))
+        await writer.drain()
+        # A send does a backend Durable-Object round-trip that can exceed a
+        # minute; wait above the daemon's own send timeout so the CLI does not
+        # give up before the daemon answers.
+        line = await asyncio.wait_for(reader.readline(), timeout=90.0)
+        if not line:
+            return {"ok": False, "error": "no response from daemon"}
+        reply = json.loads(line)
+        if not isinstance(reply, dict):
+            return {"ok": False, "error": "malformed reply from daemon"}
+        return reply
+    finally:
+        writer.close()
+        with contextlib.suppress(Exception):
+            await writer.wait_closed()
+
+
+def cmd_send(args: argparse.Namespace) -> int:
+    """Send a member-to-member message via the running daemon.
+
+    The daemon performs the authenticated send (it holds the session bearer
+    and signing key); this verb is a thin socket client. Default-closed: the
+    recipient must have granted you messaging permission first.
+    """
+    socket = unix_socket_path()
+    if not socket.exists():
+        print(
+            "daemon socket absent - is alter-runtime running? (`alter-runtime status`)",
+            file=sys.stderr,
+        )
+        return 1
+    request: dict[str, object] = {"method": "send", "to": args.to, "body": args.body}
+    if args.content_type:
+        request["content_type"] = args.content_type
+    try:
+        reply = asyncio.run(_socket_request(request))
+    except (OSError, ConnectionError) as exc:
+        print(f"failed to reach daemon socket: {exc}", file=sys.stderr)
+        return 1
+    if reply.get("ok"):
+        mid = reply.get("message_id") or reply.get("id") or ""
+        print(f"sent to {args.to}" + (f" (message {mid})" if mid else ""))
+        return 0
+    print(f"send failed: {reply.get('error', 'unknown error')}", file=sys.stderr)
+    return 1
+
+
 # ---------------------------------------------------------------------------
 # Main dispatcher
 # ---------------------------------------------------------------------------
@@ -461,6 +551,7 @@ COMMANDS: dict[str, object] = {
     "daemon": cmd_daemon,
     "query": cmd_query,
     "ingest": cmd_ingest,
+    "send": cmd_send,
 }
 
 

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/clients/token_usage_client.py

@@ -1,6 +1,6 @@
 """TokenUsageClient - authenticated HTTP client for the token-usage audit endpoint.
 
-Posts batches of parsed token-usage events to the ALTER backend.
+Posts batches of parsed token-usage events to the ~alter backend.
 
 Authentication
 --------------
@@ -101,12 +101,12 @@ def _derive_host_id() -> str:
 
 
 class TokenUsageClient:
-    """Async client for the ALTER backend token-usage audit endpoint.
+    """Async client for the ~alter backend token-usage audit endpoint.
 
     Parameters
     ----------
     base_url:
-        Base URL of the ALTER backend API. Reads ``ALTER_RUNTIME_API_BASE``
+        Base URL of the ~alter backend API. Reads ``ALTER_RUNTIME_API_BASE``
         env var at construction if not explicitly provided; defaults to
         ``https://api.truealter.com``.
     jwt_provider:

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

@@ -43,6 +43,7 @@ __all__ = [
     "cache_dir",
     "config_dir",
     "data_dir",
+    "doctrine_projection_dir",
     "enc_keyfile_path",
     "enc_session_path",
     "keypair_path",
@@ -111,6 +112,24 @@ def runtime_state_dir() -> Path:
     return path
 
 
+def doctrine_projection_dir() -> Path:
+    """Return $XDG_DATA_HOME/alter/doctrine (default ~/.local/share/alter/doctrine).
+
+    The canonical home of the local read-only doctrine projection:
+    ``personal.jsonl`` / ``collective.jsonl`` plus their per-scope checkpoint
+    files live here. Note the ``alter/`` namespace (NOT ``alter-runtime/``):
+    the projection is pinned under the broad ``alter`` data tree alongside the
+    CLI's other ``alter``-namespaced data, not the daemon's private
+    ``alter-runtime`` subtree.
+
+    Created on first access with mode ``0o700`` so the projected doctrine (which
+    may carry personal-scope notes) cannot be world-read.
+    """
+    path = _xdg_path("XDG_DATA_HOME", ".local/share") / "alter" / "doctrine"
+    path.mkdir(parents=True, exist_ok=True, mode=0o700)
+    return path
+
+
 def keypair_path() -> Path:
     """Path to the device Ed25519 keypair (generated by `alter-runtime init`)."""
     return config_dir() / "keypair.json"
@@ -173,6 +192,18 @@ class Session:
     #: ``handle_mismatch``.  ``None`` on legacy sessions (legacy fallback:
     #: attempt to sign and let the server surface any mismatch).
     signing_key_fingerprint: str | None = None
+    #: Long-lived member API key written by ``alter login``. This is the
+    #: credential the bridge sends as ``X-ALTER-API-Key`` for member-self tools
+    #: (doctrine, messaging, alignment, consent, attunement) - those tools
+    #: require ``member_self`` scope, which the 24h bearer JWT does NOT carry.
+    #: The doctrine-projection poller authenticates with this key; ``None`` when
+    #: the session predates the member-key cutover (the poller then soft-fails
+    #: the doctrine read and logs, never crashes).
+    member_api_key: str | None = None
+    #: The member's UUID (assessment-DB ``members.id``). Carried for parity with
+    #: the bridge; the backend resolves ownership from the validated credential,
+    #: not from this value. ``None`` on legacy sessions.
+    member_id: str | None = None
 
 
 class SessionRef:
@@ -423,7 +454,7 @@ def _read_enc_store() -> str | None:
 
 
 def _parse_consent_tier(value: Any) -> int:
-    """Normalise ``consent_tier`` to the integer ALTER uses internally.
+    """Normalise ``consent_tier`` to the integer ~alter uses internally.
 
     The CLI writes the consent tier as a string label
     (``"L1"``, ``"L2"``, ``"L3"``, ``"L4"``) - see the SDK type
@@ -488,6 +519,8 @@ def _parse_session_text(raw_text: str) -> Session | None:
             logged_in_at=raw.get("logged_in_at"),
             signing_kid=raw.get("signing_kid") or None,
             signing_key_fingerprint=raw.get("signing_key_fingerprint") or None,
+            member_api_key=raw.get("member_api_key") or None,
+            member_id=raw.get("member_id") or None,
         )
     except (KeyError, TypeError):
         return None
@@ -788,16 +821,6 @@ class DaemonConfig:
     #: ``ALTER_RUNTIME_CLAUDE_JSONL_WATCHER=1`` or direct config mutation.
     enable_claude_jsonl_watcher: bool = False
 
-    # --- Working-tree write-event watcher --------------------------------
-    #: When ``True``, register :class:`WeaveWatcher` as a supervised
-    #: Component. It appends every observed working-tree file write to the
-    #: durable, append-only WriteEvent log (``alter_runtime.weave_log``).
-    #: Consent-gated: opt-in (default ``False``) because a durable per-handle
-    #: write log is more sensitive than the short-lived, expiring intent
-    #: coordination stream. Enable via ``ALTER_RUNTIME_WEAVE_WATCHER=1`` or
-    #: direct config mutation.
-    enable_weave_watcher: bool = False
-
     # --- Hardening (frame-signature enforcement) --------------
     #: When ``True``, every SSE frame received by :class:`DoSseSubscriber`
     #: MUST carry a valid Ed25519 signature over the canonical (JCS-style
@@ -858,6 +881,24 @@ class DaemonConfig:
     #: ``ALTER_RUNTIME_AUTOUPDATE_POLL_INTERVAL_SECONDS``.
     autoupdate_poll_interval_seconds: int = 24 * 60 * 60
 
+    # --- Doctrine projection poller --------------------------------------
+    #: Master toggle for :class:`DoctrineProjectionPoller`. When enabled (the
+    #: default) the daemon maintains a local read-only JSONL projection of the
+    #: member's doctrine substrate per scope (``personal`` / ``collective``)
+    #: under :func:`doctrine_projection_dir`. Pull-mode (the backend emits no
+    #: event on a doctrine write): the poller calls ``alter_doctrine``'s cheap
+    #: ``summary`` verb each tick and only pulls the ``list`` delta when the
+    #: etag changes. It shares the read-side MCP wire contract (envelope +
+    #: ``mcp_fallback_endpoint`` + Bearer JWT) with the other pollers. Disable
+    #: via ``ALTER_RUNTIME_DOCTRINE_PROJECTION=0`` (e.g. air-gapped fleets that
+    #: don't want the periodic authenticated round-trip).
+    doctrine_projection_enabled: bool = True
+    #: Cadence in seconds for the doctrine summary poll. 60s is deliberately
+    #: slow: doctrine is a low-velocity living-state surface and the summary
+    #: call is cheap, so a steadily-fresh cache (not a tight loop) is the goal.
+    #: Override via ``ALTER_RUNTIME_DOCTRINE_PROJECTION_INTERVAL_SECONDS``.
+    doctrine_projection_interval_seconds: float = 60.0
+
     @classmethod
     def load(cls) -> DaemonConfig:
         """Load config from environment + YAML file + defaults.
@@ -1000,6 +1041,18 @@ class DaemonConfig:
             except ValueError:
                 pass
 
+        # --- Doctrine projection poller ----------------------------------
+        _dp_flag = os.environ.get("ALTER_RUNTIME_DOCTRINE_PROJECTION", "").lower()
+        if _dp_flag in ("0", "false", "no", "off"):
+            config.doctrine_projection_enabled = False
+        elif _dp_flag in ("1", "true", "yes", "on"):
+            config.doctrine_projection_enabled = True
+        if dp_interval := os.environ.get("ALTER_RUNTIME_DOCTRINE_PROJECTION_INTERVAL_SECONDS"):
+            try:
+                config.doctrine_projection_interval_seconds = float(dp_interval)
+            except ValueError:
+                pass  # Ignore malformed override; default stands.
+
         if level := os.environ.get("ALTER_RUNTIME_LOG_LEVEL"):
             config.log_level = level
         if socket := os.environ.get("ALTER_RUNTIME_SOCKET"):
@@ -1009,14 +1062,6 @@ class DaemonConfig:
             config.enable_claude_jsonl_watcher = True
         elif _cjw_flag in ("0", "false", "no", "off"):
             config.enable_claude_jsonl_watcher = False
-        # Working-tree write-event watcher. Consent-gated opt-in: the watcher
-        # only writes a local append-only log and never touches frame-signature
-        # enforcement, so a plain env toggle is safe.
-        _weave_flag = os.environ.get("ALTER_RUNTIME_WEAVE_WATCHER", "").lower()
-        if _weave_flag in ("1", "true", "yes", "on"):
-            config.enable_weave_watcher = True
-        elif _weave_flag in ("0", "false", "no", "off"):
-            config.enable_weave_watcher = False
         # Post-pentest-2026-04-26: default is True. Env var still toggles -
         # explicit "0"/"false"/"no"/"off" disables (migration-window opt-out),
         # everything else (including unset) keeps the default True.

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/consent.py

@@ -18,7 +18,7 @@ Implements the following install-transparency countermeasures:
   tombstoned, the install is refused with an actionable message. The user
   can explicitly clear the tombstone with ``--reinstall``.
 
-ALTER does not use a silent-install pattern.
+~Alter does not use a silent-install pattern.
 """
 
 from __future__ import annotations
@@ -88,7 +88,11 @@ def _sha256_file(path: Path) -> str:
 # ---------------------------------------------------------------------------
 
 
-def enumerate_artefacts(binary_path: Path | None = None) -> list[dict[str, Any]]:
+def enumerate_artefacts(
+    binary_path: Path | None = None,
+    *,
+    binary_sigstore_bundle_url: str | None = None,
+) -> list[dict[str, Any]]:
     """Return a list of artefacts that ``alter-runtime start`` will write.
 
     Each entry is a dict::
@@ -102,13 +106,21 @@ def enumerate_artefacts(binary_path: Path | None = None) -> list[dict[str, Any]]
 
     For v1 the set is:
 
-    * The systemd user unit *or* launchd plist (platform-appropriate).
+    * The systemd user unit *or* launchd plist (platform-appropriate). This is
+      a locally-rendered template, not a signed release artefact, so its
+      ``sigstore_bundle_url`` is always ``None``.
     * The ``alter-runtime`` binary itself (resolved via
       :func:`~alter_runtime.service_install.resolve_runtime_binary`, with
       a graceful fallback to ``None`` if the binary is not yet installed).
 
-    ``sigstore_bundle_url`` is ``None`` in v1; the bundle-URL lookup lands
-    in a future release once the static binary build is in place.
+    Parameters
+    ----------
+    binary_sigstore_bundle_url:
+        The sigstore bundle URL for the runtime binary, read from the release
+        manifest entry for the running platform. When supplied it is stamped
+        onto the binary artefact so the consent screen and the post-install
+        manifest record the signature provenance. ``None`` (the default) means
+        no bundle is known for this install path, e.g. a local source build.
     """
     from alter_runtime.service_install import (
         current_platform,
@@ -154,7 +166,7 @@ def enumerate_artefacts(binary_path: Path | None = None) -> list[dict[str, Any]]
                 "path": resolved_binary,
                 "size_bytes": bin_size,
                 "sha256": _sha256_file(resolved_binary),
-                "sigstore_bundle_url": None,
+                "sigstore_bundle_url": binary_sigstore_bundle_url,
             }
         )
 
@@ -177,7 +189,12 @@ def _human_size(size_bytes: int | None) -> str:
     return f"{size_bytes / (1024 * 1024):.1f} MiB"
 
 
-def print_consent_screen(artefacts: list[dict[str, Any]], uninstall_cmd: str) -> None:
+def print_consent_screen(
+    artefacts: list[dict[str, Any]],
+    uninstall_cmd: str,
+    *,
+    verified: bool = False,
+) -> None:
     """Render the pre-install consent screen to stdout.
 
     Format::
@@ -189,24 +206,38 @@ def print_consent_screen(artefacts: list[dict[str, Any]], uninstall_cmd: str) ->
         ...
         Sigstore-keyless verification: UNVERIFIED
         To remove everything:  alter-runtime stop
+
+    Parameters
+    ----------
+    verified:
+        Whether an actual sigstore-verified verdict has been obtained for the
+        release artefacts (e.g. from ``alter runtime verify`` / the
+        verified-apply path). The headline status reads ``VERIFIED`` ONLY when
+        this is ``True``; it is ``UNVERIFIED`` otherwise. A bundle URL being
+        merely *present* on an artefact is no longer treated as proof of
+        verification: an unverified install must never claim it passed.
     """
     print("ALTER Runtime - install consent")
     print("================================")
     print("The following artefacts will be written to your system:")
 
-    any_sigstore = False
     for artefact in artefacts:
         path = artefact["path"]
         size_str = _human_size(artefact.get("size_bytes"))
         sha = artefact.get("sha256") or ""
         short_sha = sha[:12] if sha else "(not yet on disk)"
         bundle_url = artefact.get("sigstore_bundle_url")
-        sig_label = "verified" if bundle_url else "unverified"
-        if bundle_url:
-            any_sigstore = True
+        # Per-artefact label is driven by the verdict, not URL presence: a
+        # bundle URL with no verified verdict is "pending", never "verified".
+        if verified and bundle_url:
+            sig_label = "verified"
+        elif bundle_url:
+            sig_label = "pending"
+        else:
+            sig_label = "unverified"
         print(f"  {path}  ({size_str})  sha256:{short_sha}  sigstore: {sig_label}")
 
-    sig_status = "PASSED" if any_sigstore else "UNVERIFIED"
+    sig_status = "VERIFIED" if verified else "UNVERIFIED"
     print(f"Sigstore-keyless verification: {sig_status}")
     print(f"To remove everything:  {uninstall_cmd}")
     print()

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/daemon.py

@@ -309,6 +309,7 @@ async def run_daemon(config: DaemonConfig | None = None) -> None:
         AttunementRefresher,
         CacheWriter,
         CeremonyEchoWriter,
+        DoctrineProjectionPoller,
         DoSseSubscriber,
         EventBus,
         InboxWriter,
@@ -352,6 +353,20 @@ async def run_daemon(config: DaemonConfig | None = None) -> None:
         if config.attunement_refresh_enabled:
             supervisor.register(AttunementRefresher(config, session, event_bus))
 
+        # DoctrineProjectionPoller maintains a local read-only JSONL projection
+        # of the member's doctrine substrate per scope (personal/collective)
+        # under ~/.local/share/alter/doctrine. Pull-mode: the backend emits no
+        # event on a doctrine write, so it polls the cheap ``alter_doctrine``
+        # ``summary`` verb each tick and only pulls the ``list`` delta when the
+        # etag changes. Shares the read-side MCP wire contract (envelope +
+        # endpoint + JWT) with the fallback / attunement pollers; it does NOT
+        # touch do_sse's connect/auth/mint path. The projection file is a
+        # rolling, rebuildable-from-substrate cache. Pass the session_ref holder
+        # when available so the poller reads the live JWT after a proactive
+        # rotation. Disable via ALTER_RUNTIME_DOCTRINE_PROJECTION=0.
+        if config.doctrine_projection_enabled:
+            supervisor.register(DoctrineProjectionPoller(config, session_ref or session))
+
         # SessionRefresher proactively shells ``alter creds refresh --force``
         # a configurable lead time before the access JWT expires.  After a
         # successful rotation it updates the shared ``session_ref`` holder so
@@ -485,8 +500,7 @@ async def run_daemon(config: DaemonConfig | None = None) -> None:
 
         # WorktreeWatcher: working-tree filesystem watcher. Observes the
         # repo working tree and publishes local.signal kind=worktree_edit
-        # on every file save, covering editors that lack a hook as a coarse
-        # second producer for the write log.
+        # on every file save, covering editors that lack a hook.
         supervisor.register(WorktreeWatcher(config, event_bus))
 
         # WeaveIntentWriter: subscribes to local.signal worktree_edit events
@@ -499,26 +513,13 @@ async def run_daemon(config: DaemonConfig | None = None) -> None:
 
         # Claude Code JSONL token-usage watcher - opt-in via config flag.
         # Tails the Claude Code projects transcripts and posts token-usage events to
-        # the ALTER backend audit endpoint. Disabled by default; enable via
+        # the ~alter backend audit endpoint. Disabled by default; enable via
         # ALTER_RUNTIME_CLAUDE_JSONL_WATCHER=1 or direct config mutation.
         if config.enable_claude_jsonl_watcher:
             from alter_runtime.adapters.claude_jsonl_watcher import ClaudeJsonlWatcher
 
             supervisor.register(ClaudeJsonlWatcher(config, event_bus))
 
-        # Working-tree write-log watcher: opt-in via config flag or
-        # ALTER_RUNTIME_WEAVE_WATCHER=1. Observes working-tree
-        # IN_CLOSE_WRITE events into the durable, append-only write log
-        # (~/.local/share/alter-runtime/weave-log.jsonl) that the
-        # read-back MCP surface reads back. No TTL, no rotation-to-deletion.
-        # The TTL-bounded weave-intent.jsonl above is the separate
-        # write-log plane. The write log is an append-only overlay on git,
-        # never a replacement.
-        if config.enable_weave_watcher:
-            from alter_runtime.adapters import WeaveWatcher
-
-            supervisor.register(WeaveWatcher(config, event_bus))
-
         # --- External adapter plugins (entry-point discovery) -------------
         # Out-of-tree adapters register under the ``alter_runtime.adapters``
         # entry-point group and are discovered here rather than imported by

{alter_runtime-0.4.8 → alter_runtime-0.4.9}/alter_runtime/http_auth.py

@@ -1,4 +1,4 @@
-"""HTTP header helpers for upstream calls into the ALTER backend.
+"""HTTP header helpers for upstream calls into the ~alter backend.
 
 Every authenticated request carries an ``Authorization: Bearer <jwt>``
 header set explicitly by the calling subscriber; that member bearer is