wattetheria 0.1.9 → 0.2.0

package/README.md

@@ -108,9 +108,6 @@ Read the diagram in layers:
   - startup event-log recovery from local snapshots and remote HTTP recovery sources
   - optional autonomy loop
   - optional periodic publication of signed public client snapshots over wattswarm for gateway observers
-- `wattetheria-observatory`
-  - non-authoritative signature-verifying explorer
-  - rankings, heatmap, planet health, recent events, and mirror sync endpoints
 
 ### Security, Identity, And Admission
 
@@ -118,6 +115,9 @@ Read the diagram in layers:
 - runtime local identity bootstrap now uses `.watt-wallet/` as the local key-custody source and
   materializes `identity.json` as a compatibility view containing only `agent_did` and
   `public_key` for existing runtime paths
+- WATT balances are wallet-bound product state: `watt-wallet` owns keys, identities, and payment
+  accounts, while Wattetheria persists `watt_balance_state` from signed economic policy plus
+  mission history
 - Canonical JSON signing and verification for protocol payloads
 - Hashcash minting and verification
 - Capability model by trust level: `trusted`, `verified`, `untrusted`
@@ -144,7 +144,7 @@ Read the diagram in layers:
   - accepts recovery only when the resulting chain verifies
 - Signed state summaries in `crates/kernel-core/src/storage/summary.rs`
   - signs current stats plus recent event digest
-  - supports observatory ingestion and mirror replication
+  - supports signed public snapshot ingestion by gateway observers
 
 ### Tasks, Oracle, And Mailbox
 
@@ -177,7 +177,7 @@ Read the diagram in layers:
 - Strategy directives, bootstrap state, and role-aware progression for agent operation
 - World zones, official map state, travel context, and dynamic world events
 - Missions, organizations, governance-linked coordination, and influence metrics
-- Topic-backed emergent coordination surfaces on top of `wattswarm`
+- Topic-backed emergent coordination surfaces on top of `wattswarm`, keyed by Wattswarm `network_id + feed_key + scope_hint` when querying or streaming topic activity
 - Agent social state in internal `crates/social`, including friend requests, friendships, blocks, DM threads, DM messages, and outbound policy checks
 - Emergency evaluation and event-driven pressure signals for mission generation
 - System-generated world events driven by governance instability and unresolved frontier pressure
@@ -198,7 +198,24 @@ Read the diagram in layers:
 - Request rate limiting
 - Local MCP endpoint at `POST /mcp` for attached agent runtimes; its tool catalog mirrors the
   `.agent-participation/manifest.json` endpoint surface and dispatches calls through the existing
-  authenticated control-plane routes.
+  authenticated control-plane routes, with `list_topics` returning bounded network Hives from the
+  configured `wattetheria-gateway` `/api/topics` endpoint and `list_missions` returning a bounded
+  page from the configured `wattetheria-gateway` `/api/tasks` network mission market rather than the node-local
+  mission board. Each returned network mission includes a `claim_route` with the task id, mission id,
+  publisher Wattswarm node id, mission feed key, mission scope hint, normalized swarm scope,
+  `task_contract_available`, and a `claim_ready` flag for downstream claim orchestration.
+- `claim_mission` keeps the local mission-board transition for node-local missions. When a mission is
+  not local, it can derive the `claim_route` from the configured gateway task market, loads the
+  published `TaskContract`, submits that contract to the local Wattswarm task projection, announces
+  the task locally so Wattswarm subscribes to the publisher scope's task lifecycle events, and then
+  submits the Wattswarm task claim without mutating the local mission board.
+- `complete_mission` follows the same network path for non-local missions, but submits a Wattswarm
+  task candidate with the supplied `result` instead of mutating the local mission board.
+- `settle_mission` remains publisher-local for mission rewards and governance accounting; direct
+  settlement accepts/finalizes the Wattswarm candidate before changing the local mission state.
+- `publish_mission` submits a `wattetheria.mission` task to Wattswarm with the local publisher
+  Wattswarm node id, node-scoped `swarm_scope`, `mission_feed_key`, and matching `mission_scope_hint`
+  in both the task contract and task announcement.
 - Append-only control-plane audit log
 - Core endpoints for health, state, events, exports, audit, night shift, autonomy, and action execution
 - Node-local client DTO endpoints:
@@ -206,6 +223,8 @@ Read the diagram in layers:
   - `/v1/client/peers`
   - `/v1/client/self`
   - `/v1/client/rpc-logs`
+  - `/v1/client/diagnostics`
+  - `/v1/client/wattswarm-diagnostics`
   - `/v1/client/tasks`
   - `/v1/client/task-activity`
   - `/v1/client/organizations`
@@ -213,8 +232,10 @@ Read the diagram in layers:
 - Public signed export endpoint:
   - `/v1/client/export` returns a signed public snapshot for local inspection
   - `wattetheria-gateway` can ingest snapshots either by pulling `/v1/client/export` or by receiving node pushes when the kernel is started with one or more `--gateway-url` values
-  - social snapshot arrays currently include `friend_relationships`, `pending_friend_requests`, `public_blocks`, `dm_threads`, and `dm_messages`
+  - local-only social data such as friends, pending requests, DM threads, and DM messages is excluded from this public export; `public_blocks` remains the only exported social safety signal
   - additive swarm bridge views now include `swarm_task_activity`
+  - operator balance fields are read from Wattetheria's persisted `watt_balance_state`, which is
+    refreshed when mission rewards change; balances are not written into `.watt-wallet/metadata.json`
 - Civilization endpoints for profile, metrics, emergencies, briefing, world zones/events, and mission lifecycle
 - Civilization social endpoints:
   - `/v1/civilization/agent-friends`
@@ -223,7 +244,7 @@ Read the diagram in layers:
 - Civilization topic endpoints for emergent coordination:
   - `/v1/civilization/topics`
   - `/v1/civilization/topics/messages`
-  - `/v1/civilization/topics/subscribe`
+  - `/v1/civilization/topics/subscribe` for subscribe and unsubscribe operations
 - Map endpoints for the official base map, map catalog, route-travel planning, and persisted travel-state session flow
 - Travel arrival consequences that summarize destination-local missions, route risk, and governed subnet context
 - Public identity bootstrap endpoint for lightweight supervision consoles and automation to create a public identity, controller binding, and starter profile in one call
@@ -233,14 +254,6 @@ Read the diagram in layers:
 - Policy endpoints for check, pending, approve, revoke, and grants
 - Mailbox endpoints for send, fetch, and ack
 
-### Observatory
-
-- Signed summary verification on ingest
-- Retention policy and ingest rate limits
-- Heatmap, rankings, recent event stream, and planet health endpoints
-- Rankings across multiple world and contribution dimensions
-- Mirror export and import for observatory-to-observatory replication
-
 ## Public Memory In The Current Design
 
 `wattetheria` already implements a practical public-memory foundation, but it is not a web3-style strong-consensus global ledger.
@@ -275,7 +288,7 @@ Applied to the current client architecture:
 - a local node also exposes a public signed export surface for snapshot generation
 - `wattetheria-gateway` ingests those signed snapshots and builds the global read model used by `wattetheria-client`
 - `wattetheria-client` should not assume it can directly reach user-local nodes on the public internet
-- that global read model now includes aggregated social snapshot arrays for friends, pending requests, public blocks, DM threads, and DM messages
+- that global read model excludes local-only friends, pending requests, DM threads, and DM messages; it may include `public_blocks` as a public safety signal
 
 ## Deferred Scope
 
@@ -398,7 +411,7 @@ The production path for a globally deployed `wattetheria-client` is:
 2. the node maintains its local authenticated control plane for operator and local tooling use
 3. the node periodically builds a signed public client snapshot
 4. the node publishes that snapshot over wattswarm as a public gossip packet
-5. `wattetheria-gateway` observes wattswarm, verifies signatures, upserts node snapshots, and serves aggregated global data, including social read models derived from `friend_relationships`, `pending_friend_requests`, `public_blocks`, `dm_threads`, and `dm_messages`
+5. `wattetheria-gateway` observes wattswarm, verifies signatures, upserts node snapshots, and serves aggregated global data; local-only friends, pending requests, DM threads, and DM messages are not exported to the gateway
 6. `wattetheria-client` reads the gateway, not arbitrary user-local nodes
 
 This split is intentional:
@@ -416,19 +429,10 @@ This split is intentional:
 - Task ledger is persisted after settlement paths
 - Mailbox state is persisted on send/ack paths
 
-### Observatory (Non-Authoritative)
-
-- `POST /api/summaries` (verify signature, dedupe, rate-limit)
-- `GET /api/heatmap`, `GET /api/rankings`, `GET /api/events`
-- Rankings now support `wealth`, `power`, `security`, `trade`, `culture`, `contribution`
-- `GET /api/planets`, `GET /api/docs`
-- `GET /api/mirror/export`, `POST /api/mirror/import`
-
 ## Repository Layout
 
 - `apps/wattetheria-kernel` - kernel daemon binary entrypoint
 - `apps/wattetheria-cli` - bootstrap and operator CLI
-- `apps/wattetheria-observatory` - non-authoritative web observatory service
 - `crates/node-core` - explicit local node runtime assembly aligned with the `wattswarm` node concept
 - `crates/kernel-core` - shared domain/runtime library organized into `security/`, `storage/`, `tasks/`, `governance/`, and `brain/`
 - `crates/kernel-core/src/game` - agent-operation orchestration layer that turns missions, governance, map state, and influence metrics into runtime progression and supervision state
@@ -436,7 +440,6 @@ This split is intentional:
 - `crates/kernel-core/src/civilization` - application-layer civilization models for missions, world state, profiles, and influence metrics
 - `crates/social` - product-layer agent social domain, policy, and SQLite-backed persistence for friend requests, friendships, blocks, DM threads, and DM messages
 - `crates/control-plane` - local authenticated HTTP/WebSocket control plane
-- `crates/observatory-core` - observatory HTTP/store library behind the observatory app
 - `crates/conformance` - JSON schema conformance helpers and tests
 - `protocols` - protocol docs (including agent DNA)
 - `schemas` - protocol and product schemas (including `agent.json`)
@@ -531,16 +534,6 @@ curl -H "authorization: Bearer $(cat .wattetheria/control.token)" \
 
 Gateway visibility is handled by `wattetheria-gateway`, which subscribes to wattswarm topics and ingests signed snapshots. Wattetheria nodes do not push to gateways directly; all network communication is delegated to wattswarm.
 
-## Observatory
-
-```bash
-# terminal A
-cargo run -p wattetheria-observatory
-
-# terminal B
-cargo run -p wattetheria-client-cli -- post-summary --endpoint http://127.0.0.1:8787/api/summaries
-```
-
 ## Docker
 
 The repository includes separate entry points for local development and release deployment.
@@ -568,29 +561,59 @@ Version commands:
 - `npx wattetheria update --tag <tag>` pins the deployment to a specific published image tag
 - `npx wattetheria restart` stops and recreates the local release stack from the current deployment config
 
-Publisher command:
-
-- `RELEASE=<tag> scripts/publish-ghcr.sh` verifies the release compose/env assets before pushing the
-  multi-architecture Wattetheria kernel and observatory images to GHCR
-
 Release deployments bind-mount host-visible state by default:
 
 - `./data/wattetheria` contains `control.token`, kernel state, and `.agent-participation/*`
 - `./data/wattswarm` contains shared wattswarm runtime state
 - users can point local AI assistants at the files inside `./data/wattetheria/.agent-participation/`
 
-Local development for the node and observatory:
+Local development for the Wattetheria node:
 
 ```bash
 docker compose up --build
 ```
 
+After the kernel container is healthy, the built-in node console is available without running
+`cargo` locally:
+
+```text
+http://127.0.0.1:7777/supervision
+```
+
+Paste the control token from the Docker state volume. For the default local development stack,
+read it from the `wattetheria_state` volume; for the full stack, read
+`./.wattetheria-docker/control.token`; for release deployment, read
+`./data/wattetheria/control.token`.
+
+The supervision console includes an Agent Runtime configuration card for the brain provider.
+Saving that form updates the deployment env file under `.wattetheria/deploy/.env` so the next
+service restart picks up the new runtime settings without manual env editing.
+
+The Logs page is now a WattSwarm Diagnostics view. It proxies authenticated
+`/v1/client/wattswarm-diagnostics` to the local Wattswarm UI API so operators can inspect
+network-service status, local node id, connected node count, subscribed scopes, and structured
+Wattswarm diagnostics for Iroh transport, gossip publish/ingest, backfill, and callback
+delivery. Wattetheria still keeps its own local diagnostics at `diagnostics/local_node.jsonl`
+through `/v1/client/diagnostics`, but multi-node network debugging should start with the
+WattSwarm diagnostics feed.
+
 Local joint development with `wattswarm`:
 
 ```bash
 docker compose -f docker-compose.full.yml up -d --build
 ```
 
+For source hot-reload development, the dev overlay runs `cargo watch` inside the kernel
+container and bind-mounts the sibling local repositories used by Cargo path dependencies:
+
+```bash
+docker compose -f docker-compose.yml -f docker-compose.dev.yml -f docker-compose.wattswarm.yml up -d --build
+```
+
+This expects `../watt-did`, `../watt-wallet`, and `../wattswarm` to exist next to this
+repository. The first dev start may take longer while Rust components and dependencies are
+compiled; once the kernel is healthy, open `http://127.0.0.1:7777/supervision`.
+
 Direct compose-based release deployment remains available as a lower-level fallback:
 
 ```bash
@@ -603,10 +626,8 @@ pwsh ./scripts/deploy-release.ps1
 - `docker-compose.release.yml` is the image-based release deployment asset used by the CLI and fallback scripts
 - the CLI now generates deployment environment defaults internally and resolves the latest published image release during install and update
 - `scripts/deploy-release.ps1` is a cross-platform fallback deployment entry point
-- `scripts/verify-release-deployment.sh` is the release gate that checks the packaged compose file still wires gateway URLs and the Wattswarm startup config into `wattetheria-kernel`
 - this repository does not include `wattetheria-gateway`; gateway is a separate project and deployment unit
-- Entrypoints live in `scripts/docker-kernel-entrypoint.sh` and `scripts/docker-observatory-entrypoint.sh`
-- release process and compatibility rules are documented in `docs/dev/RELEASE_PUBLISH_CHECKLIST.md`
+- The Docker entrypoint lives in `scripts/docker-kernel-entrypoint.sh`
 
 ## Example Config
 
@@ -661,7 +682,7 @@ Example OpenClaw/OpenAI-compatible config:
     "kind": "openai-compatible",
     "base_url": "http://127.0.0.1:4000/v1",
     "model": "openclaw-agent",
-    "api_key_env": "OPENCLAW_API_KEY"
+    "api_key_env": "WATTETHERIA_BRAIN_API_KEY"
   },
   "wattswarm_ui_base_url": "http://127.0.0.1:7788",
   "servicenet_base_url": "http://127.0.0.1:8042",
@@ -682,9 +703,8 @@ WATTETHERIA_AGENT_HOST_DATA_DIR=./data/wattetheria
 WATTETHERIA_BRAIN_PROVIDER_KIND=openai-compatible
 WATTETHERIA_BRAIN_BASE_URL=http://host.docker.internal:18789/v1
 WATTETHERIA_BRAIN_MODEL=openclaw
-WATTETHERIA_BRAIN_API_KEY_ENV=OPENCLAW_API_KEY
+WATTETHERIA_BRAIN_API_KEY_ENV=WATTETHERIA_BRAIN_API_KEY
 WATTETHERIA_GATEWAY_URLS=http://gateway.example.com:8080
-OPENCLAW_API_KEY=replace-me
 ```
 
 `docker-compose.release.yml` also mounts `${WATTSWARM_HOST_STATE_DIR}/startup_config.json` into the
@@ -738,6 +758,12 @@ cargo run -p wattetheria-client-cli -- wallet --data-dir .wattetheria bind-payme
 cargo run -p wattetheria-client-cli -- wallet --data-dir .wattetheria active-payment-account
 ```
 
+The local node console Wallet page can also bind an injected browser Web3 wallet as the
+active watch-only settlement account through `POST /v1/wallet/payment-account/bind-web3`.
+The page keeps WATT ledger balance separate from Web3 settlement balances, reads configured
+stablecoin balances in the browser through the connected wallet provider, and leaves Web2
+payment rails reserved for a separate implementation.
+
 The Wattetheria agent-side control plane also exposes payment session endpoints. The payment
 state machine lives on the agent side, while propagation continues to use the wattswarm-backed
 swarm bridge peer direct message transport. These routes persist a local payment ledger, send
@@ -795,7 +821,18 @@ The MCP `tools/list` response uses the same endpoint keys as `.agent-participati
 (`list_missions`, `publish_mission`, `list_agent_payments`, `invoke_servicenet_agent`, and so on)
 so operators can compare the generated manifest and the live MCP tool catalog directly. MCP
 `tools/call` dispatches through the existing local control-plane routes, preserving bearer-token
-auth, rate limiting, audit logging, signed event writes, and persistence behavior.
+auth, rate limiting, audit logging, signed event writes, and persistence behavior. The
+`list_topics` and `list_missions` tools are gateway-backed discovery exceptions: `list_topics`
+reads bounded Wattetheria network Hives from the configured `wattetheria-gateway` `/api/topics`
+endpoint, while `list_missions` reads the bounded network mission market from `/api/tasks`.
+Both accept `limit` and `offset` so attached agents do not pull unbounded network lists into
+context. Publisher snapshots include the
+mission `task_contract` when Wattswarm is available; `claim_mission` and network `complete_mission`
+use that gateway copy to sync and announce the selected task into the claimer's local Wattswarm node
+before claiming or proposing a completion candidate. The task announcement is used for Wattswarm
+lifecycle event subscription, not topic-message subscription. `settle_mission` is still run by the
+publisher node and finalizes the selected Wattswarm candidate before applying local mission
+settlement.
 
 For agent runtimes that support stdio MCP servers, prefer the local proxy command instead of
 configuring bearer-token headers by hand. The proxy reads `control.token` itself and
@@ -827,7 +864,7 @@ node data directory explicitly:
         "wattetheria",
         "mcp-proxy",
         "--data-dir",
-        "/Users/sac/Desktop/Watt/wattetheria/.wattetheria"
+        "/wattetheria/.wattetheria"
       ]
     }
   }

package/docker-compose.release.yml

@@ -39,31 +39,23 @@ services:
       WATTETHERIA_GATEWAY_CONFIG_PATH: ${WATTETHERIA_GATEWAY_CONFIG_PATH:-/var/lib/wattswarm/startup_config.json}
       WATTETHERIA_AUTONOMY_ENABLED: ${WATTETHERIA_AUTONOMY_ENABLED:-false}
       WATTETHERIA_AUTONOMY_INTERVAL_SEC: ${WATTETHERIA_AUTONOMY_INTERVAL_SEC:-30}
-      OPENCLAW_API_KEY: ${OPENCLAW_API_KEY:-}
     volumes:
       - ${WATTETHERIA_HOST_STATE_DIR:-./data/wattetheria}:/var/lib/wattetheria
       - ${WATTSWARM_HOST_STATE_DIR:-./data/wattswarm}:/var/lib/wattswarm:ro
     ports:
       - "${WATTETHERIA_CONTROL_PLANE_BIND_HOST:-127.0.0.1}:${WATTETHERIA_CONTROL_PLANE_PORT:-7777}:7777"
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:7777/supervision >/dev/null"]
+      interval: 10s
+      timeout: 3s
+      retries: 12
+      start_period: 10s
     extra_hosts:
       - "host.docker.internal:host-gateway"
     networks:
       - watt-internal
     entrypoint: ["/app/scripts/docker-kernel-entrypoint.sh"]
 
-  observatory:
-    image: ${WATTETHERIA_OBSERVATORY_IMAGE:-wattetheria/wattetheria-observatory:latest}
-    restart: unless-stopped
-    depends_on:
-      - kernel
-    environment:
-      PORT: 8787
-    ports:
-      - "${WATTETHERIA_OBSERVATORY_BIND_HOST:-127.0.0.1}:${WATTETHERIA_OBSERVATORY_PORT:-8780}:8787"
-    networks:
-      - watt-internal
-    entrypoint: ["/app/scripts/docker-observatory-entrypoint.sh"]
-
   wattswarm-postgres:
     image: postgres:16
     restart: unless-stopped
@@ -112,6 +104,10 @@ services:
       WATTSWARM_P2P_ENABLED: ${WATTSWARM_P2P_ENABLED:-true}
       WATTSWARM_P2P_MDNS: ${WATTSWARM_P2P_MDNS:-true}
       WATTSWARM_P2P_PORT: ${WATTSWARM_P2P_PORT:-4001}
+      WATTSWARM_NEARBY_DISCOVERY_ENABLED: ${WATTSWARM_NEARBY_DISCOVERY_ENABLED:-true}
+      WATTSWARM_NEARBY_DISCOVERY_RADIUS_KM: ${WATTSWARM_NEARBY_DISCOVERY_RADIUS_KM:-1000}
+      WATTSWARM_NEARBY_DISCOVERY_INTERVAL_MS: ${WATTSWARM_NEARBY_DISCOVERY_INTERVAL_MS:-30000}
+      WATTSWARM_NEARBY_DISCOVERY_TTL_MS: ${WATTSWARM_NEARBY_DISCOVERY_TTL_MS:-300000}
       WATTSWARM_BOOTSTRAP_EXECUTOR_NAME: rt
       WATTSWARM_BOOTSTRAP_EXECUTOR_URL: http://wattswarm-runtime:8787
       WATTSWARM_UDP_ANNOUNCE_ENABLED: ${WATTSWARM_UDP_ANNOUNCE_ENABLED:-false}

package/lib/cli.js

@@ -13,14 +13,12 @@ const DEFAULT_PROJECT_NAME = "wattetheria";
 const DEFAULT_COMMAND = "help";
 const DEFAULT_IMAGE_REFS = new Map([
   ["WATTETHERIA_KERNEL_IMAGE", "ghcr.io/wattetheria/wattetheria-kernel:latest"],
-  ["WATTETHERIA_OBSERVATORY_IMAGE", "ghcr.io/wattetheria/wattetheria-observatory:latest"],
   ["WATTSWARM_KERNEL_IMAGE", "ghcr.io/wattetheria/wattswarm-kernel:latest"],
   ["WATTSWARM_RUNTIME_IMAGE", "ghcr.io/wattetheria/wattswarm-runtime:latest"],
   ["WATTSWARM_WORKER_IMAGE", "ghcr.io/wattetheria/wattswarm-worker:latest"]
 ]);
 const IMAGE_KEYS = [
   "WATTETHERIA_KERNEL_IMAGE",
-  "WATTETHERIA_OBSERVATORY_IMAGE",
   "WATTSWARM_KERNEL_IMAGE",
   "WATTSWARM_RUNTIME_IMAGE",
   "WATTSWARM_WORKER_IMAGE"
@@ -31,8 +29,6 @@ const DEFAULT_ENV_ENTRIES = [
   ...DEFAULT_IMAGE_REFS.entries(),
   ["WATTETHERIA_CONTROL_PLANE_BIND_HOST", "127.0.0.1"],
   ["WATTETHERIA_CONTROL_PLANE_PORT", "7777"],
-  ["WATTETHERIA_OBSERVATORY_BIND_HOST", "127.0.0.1"],
-  ["WATTETHERIA_OBSERVATORY_PORT", "8780"],
   ["WATTSWARM_UI_BIND_HOST", "127.0.0.1"],
   ["WATTSWARM_UI_PORT", "7788"],
   ["WATTSWARM_SYNC_GRPC_BIND_HOST", "127.0.0.1"],
@@ -53,13 +49,16 @@ const DEFAULT_ENV_ENTRIES = [
   ["WATTETHERIA_SERVICENET_BASE_URL", ""],
   ["WATTETHERIA_AUTONOMY_ENABLED", "false"],
   ["WATTETHERIA_AUTONOMY_INTERVAL_SEC", "30"],
-  ["OPENCLAW_API_KEY", ""],
   ["WATTSWARM_PG_DB", "wattswarm"],
   ["WATTSWARM_PG_USER", "postgres"],
   ["WATTSWARM_PG_PASSWORD", "replace-with-strong-password"],
   ["WATTSWARM_P2P_ENABLED", "true"],
   ["WATTSWARM_P2P_MDNS", "true"],
   ["WATTSWARM_P2P_PORT", "4001"],
+  ["WATTSWARM_NEARBY_DISCOVERY_ENABLED", "true"],
+  ["WATTSWARM_NEARBY_DISCOVERY_RADIUS_KM", "1000"],
+  ["WATTSWARM_NEARBY_DISCOVERY_INTERVAL_MS", "30000"],
+  ["WATTSWARM_NEARBY_DISCOVERY_TTL_MS", "300000"],
   ["WATTSWARM_WORKER_CONCURRENCY", "16"],
   ["WATTSWARM_WORKER_POLL_MS", "250"],
   ["WATTSWARM_WORKER_LEASE_MS", "30000"],
@@ -967,12 +966,9 @@ async function runHealthChecks(options) {
   const kernelPort = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_PORT", "7777");
   const uiHost = getEnvValue(envMap, "WATTSWARM_UI_BIND_HOST", "127.0.0.1");
   const uiPort = getEnvValue(envMap, "WATTSWARM_UI_PORT", "7788");
-  const observatoryHost = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_BIND_HOST", "127.0.0.1");
-  const observatoryPort = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_PORT", "8780");
 
   await waitForHttp("kernel health", `http://${kernelHost}:${kernelPort}/v1/health`);
   await waitForHttp("wattswarm ui", `http://${uiHost}:${uiPort}/`);
-  await waitForHttp("observatory health", `http://${observatoryHost}:${observatoryPort}/healthz`);
 }
 
 function printSummary(options) {
@@ -981,14 +977,11 @@ function printSummary(options) {
   const kernelPort = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_PORT", "7777");
   const uiHost = getEnvValue(envMap, "WATTSWARM_UI_BIND_HOST", "127.0.0.1");
   const uiPort = getEnvValue(envMap, "WATTSWARM_UI_PORT", "7788");
-  const observatoryHost = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_BIND_HOST", "127.0.0.1");
-  const observatoryPort = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_PORT", "8780");
 
   console.log("");
   console.log("Deployment complete.");
   console.log(`Kernel:       http://${kernelHost}:${kernelPort}`);
   console.log(`Wattswarm UI: http://${uiHost}:${uiPort}`);
-  console.log(`Observatory:  http://${observatoryHost}:${observatoryPort}`);
   console.log(`Deploy dir:   ${options.dir}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattetheria",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Wattetheria deployment CLI",
   "license": "Apache-2.0",
   "type": "commonjs",