super-dsh 0.1.4 → 0.1.5

package/superd-hub/dist/web-trust.d.ts

@@ -29,11 +29,11 @@
  *   - config level: `trustedPageAuthorities: []` keeps the row mounted but
  *     injects nothing (fully inert).
  *
- * Composed on BOTH trees: ctx0 through the `super-dsh/web-trust` row (the
- * composite bundle's insert list) and every world through the
- * `@pgmi-builds/superd-hub/web-trust` row (world mount patches) — world pages
- * emit `webserver/index-inject` on their own root, so a ctx0-only listener
- * would never reach them.
+ * Composed on ctx0 only (since path-separation T-D): the `super-dsh/web-trust`
+ * row in the composite bundle's insert list. The per-world row retired with
+ * the world pages themselves (T-D disabled the world webui rows — no world
+ * page renders, so no world-local injection exists); `/hub` is the sole
+ * foreign entry and it serves ctx0's index, which this ctx0 row covers.
  *
  * @module @pgmi-builds/superd-hub/web-trust
  */

package/superd-hub/dist/web-trust.js

@@ -29,11 +29,11 @@
  *   - config level: `trustedPageAuthorities: []` keeps the row mounted but
  *     injects nothing (fully inert).
  *
- * Composed on BOTH trees: ctx0 through the `super-dsh/web-trust` row (the
- * composite bundle's insert list) and every world through the
- * `@pgmi-builds/superd-hub/web-trust` row (world mount patches) — world pages
- * emit `webserver/index-inject` on their own root, so a ctx0-only listener
- * would never reach them.
+ * Composed on ctx0 only (since path-separation T-D): the `super-dsh/web-trust`
+ * row in the composite bundle's insert list. The per-world row retired with
+ * the world pages themselves (T-D disabled the world webui rows — no world
+ * page renders, so no world-local injection exists); `/hub` is the sole
+ * foreign entry and it serves ctx0's index, which this ctx0 row covers.
  *
  * @module @pgmi-builds/superd-hub/web-trust
  */

package/superd-hub/dist/world-entry.d.ts

@@ -2,20 +2,27 @@
  * World-side mount plugin (AW-B DL1/DL3) — `@pgmi-builds/superd-hub/world`.
  *
  * Inserted into the WORLD root's composition (its own process-side root, no
- * listener). It provides the virtual `webServer` for that root: every route the
- * world's plugins register is translated to `/<label>+path` on ctx0's real
- * webServer, so the world's whole web surface lands under its mount with no
- * namespace list and no second socket.
+ * listener). Since path-separation T-D (2026-09-26, "disable their webui
+ * build, just like disable their webserver") it provides the world's whole
+ * remaining web-adjacent surface, shrunk to data-plane facts:
  *
- * The RPC channel is NOT the world's: `WorldWebServer` swallows `/api*`, and the
- * hub's carrier answers `/<label>/api` + `/<label>/api/remote.mux` in ctx0's
- * auth domain, dispatching to this world's gateway instance. Non-envelope
- * GET/HEAD traffic on `/<label>/api` is forwarded into the world's registered
- * exact Fetch routes (session-log export and friends) through the shared
- * `/api` fetch handler this plugin publishes into the cross-root registry
- * (`world-host.ts`) — still behind ctx0's fence, never the world's own.
-
- * auth domain, dispatching to this world's gateway instance.
+ *   - the VIRTUAL `webServer` — a silent, registration-only shell
+ *     (`world-web-server.ts`): every route a world plugin declares is
+ *     accepted and swallowed, so the tree boots exactly as before while
+ *     nothing is ever served (`/hub` is the sole entry, T-C);
+ *   - the neutral `webRuntime` values — the ONE leg the disabled `web-runtime`
+ *     row used to provide that the DATA plane still reads (the `connection`
+ *     row injects it): loopback bind ⇒ no LAN literals, plus the deploy-level
+ *     `--trusted-host` extras spawnWorld seeds the tree with (carried here by
+ *     `worldMountPatches` in the row config).
+ *
+ * The RPC channel is NOT the world's: the hub's `/hub` family
+ * (`hub-route.ts`) answers `?agent=<key>` traffic in ctx0's auth domain,
+ * dispatching to this world's gateway instance. Non-envelope GET/HEAD traffic
+ * is forwarded into the world's registered exact Fetch routes (session-log
+ * export and friends) through the shared `/api` fetch handler this plugin
+ * publishes into the cross-root registry (`world-host.ts`) — still behind
+ * ctx0's fence, never the world's own.
  */
 import type { Context } from '@deepseek-ai/cordis';
 /** Stable Cordis plugin name. */

package/superd-hub/dist/world-entry.js

@@ -1,5 +1,6 @@
 import { noteWorldServer, publishWorldFetch, takeHostMount } from './world-host.js';
 import { WorldWebServer } from './world-web-server.js';
+import { superdTrustedHosts } from './world-mount.js';
 /** Stable Cordis plugin name. */
 export const name = 'superd-world-mount';
 /** Apply the world mount. @param ctx - the WORLD root context. @param config - `{ key }`. */
@@ -14,37 +15,32 @@ export function apply(ctx, config) {
         ctx.logger?.warn?.(`superd-world-mount: no host mount registered for key ${JSON.stringify(key)}`);
         return;
     }
-    const worldWebServer = new WorldWebServer(mount.labelPath, mount.real, {
-        onIndexInject: (table) => { ctx.emit('webserver/index-inject', table); },
-        // One auth domain: the mount, not this world, decides who may read a page.
-        authorize: (req, res) => mount.authorize?.(req, res) ?? true,
-    });
+    const worldWebServer = new WorldWebServer(mount.labelPath);
     noteWorldServer(key, worldWebServer);
     ctx.reflect.provide('webServer', worldWebServer);
-    // The world's frontend-static still asks ITS OWN connection to authorize an
-    // index request. That gate is answered by the mount above: the browser came
-    // in through ctx0, the world is reached in-ctx, and the world's cookie secret
-    // belongs to its own nested home — so a second check here could only 401 an
-    // already-authorized read. Neutralize it instead of sharing credentials.
-    // The same connection also composes the world's `/api` fetch handler (exact
-    // Fetch routes + the gateway's RPC interceptor). It is published here so the
-    // hub's carrier can forward non-envelope GET/HEAD traffic on
-    // `/<label>/api` into the world's registered routes; auth stays in ctx0's
-    // domain because the carrier fences the request BEFORE this handler runs.
+    // The data-plane leg of the disabled `web-runtime` row: the `connection`
+    // row injects `webRuntime` (and reads `ctx.webRuntime.trustedHosts` in its
+    // config). Same neutral shape as before T-D: a loopback-only bind resolves
+    // no LAN literals; the trusted-host extras are the same deploy-level env
+    // list `spawnWorld` feeds this tree as `--trusted-host` arguments (one
+    // derivation: `superdTrustedHosts`).
+    ctx.reflect.provide('webRuntime', { lanAddresses: [], trustedHosts: superdTrustedHosts(process.env.SUPERD_TRUSTED_HOSTS) });
+    // The world's `/api` fetch handler (exact Fetch routes + the gateway's RPC
+    // interceptor) is published here so the hub's `/hub` family can forward
+    // non-envelope GET/HEAD traffic into the world's registered routes; auth
+    // stays in ctx0's domain because the family fences the request BEFORE this
+    // handler runs. (The world's own index-authorization neutralization is
+    // gone with T-D: no world page exists to authorize.)
     let dropWorldFetch;
     ctx.inject(['connection'], (webCtx) => {
         const connection = webCtx.get('connection');
         if (connection === undefined)
             return;
-        if (typeof connection.authorizeIndex === 'function') {
-            connection.authorizeIndex = () => true;
-        }
         if (typeof connection.createSharedFetchHandler === 'function') {
             dropWorldFetch = publishWorldFetch(key, connection.createSharedFetchHandler('/api'));
         }
     });
     ctx.effect(() => () => {
-        worldWebServer.dispose();
         dropWorldFetch?.();
     }, 'superd-world-mount: virtual webServer');
 }

package/superd-hub/dist/world-host.d.ts

@@ -4,32 +4,26 @@
  * A world runs as its OWN cordis ROOT (events are root-scoped — probe
  * 2026-09-16), so ctx0 and the world cannot share service instances through
  * the context tree. They DO share this module (the profile links
- * `@pgmi-builds/superd-hub` at the same path), which is where the host hands the
- * world everything it needs to mount itself:
+ * `@pgmi-builds/superd-hub` at the same path), which is where the host hands
+ * the world what it needs to mount itself:
  *
- *   ctx0 hub  → registerHostMount({ key, labelPath, real })   (before spawn)
+ *   ctx0 hub  → registerHostMount({ key, labelPath })         (before spawn)
  *   world     → takeHostMount(key) → provides the virtual `webServer`
  *
+ * T-C (2026-09-26): the `real`/`authorize` legs were RETIRED with the
+ * per-label URL family. T-D (2026-09-26) swept the vestiges: the mount record
+ * is the world's ADDRESSABILITY entry only (`{ key, labelPath }`) — no ctx0
+ * webServer instance, no index gate; the adapter world-plugins' call sites
+ * were updated in the same round.
+ *
  * No selection state: the key is the world's own identity, fixed at spawn.
  */
-import type { RealWebServerFace } from './world-web-server.js';
-/** What a world needs to mount its surface onto ctx0's real webServer. */
+/** What the host publishes for one world mount (the world's identity record). */
 export interface HostMount {
     /** Runtime key (`omp`, `codex`, …) — equals the mount label. */
     key: string;
     /** Mount root (`/omp`). */
     labelPath: string;
-    /** ctx0's webServer instance (live object, passed across roots). */
-    real: RealWebServerFace;
-    /**
-     * ctx0's index authorization (the SAME gate the native index goes through).
-     * The mount is the only ingress and answers the world's pages/assets itself,
-     * so auth is decided in ctx0's domain — by the cookie that authenticated
-     * `<label>` — and never by the world's own browser-auth gate (a different
-     * tree, a different secret). Returning false means the authorizer already
-     * answered (401, or the token→cookie 303).
-     */
-    authorize?(req: unknown, res: unknown): boolean;
 }
 /** Publish the host side of one world mount (idempotent replace). */
 export declare function registerHostMount(mount: HostMount): () => void;
@@ -59,10 +53,11 @@ export interface WorldFetchHandler {
     fetch(request: Request): Promise<Response>;
 }
 /**
- * Publish one world's shared `/api` fetch handler so the carrier can forward
- * non-envelope traffic on `/<label>/api` into the world's registered routes
- * (session-log export and friends). Called from inside the world root
- * (`world-entry`); read from the host root (`carrier`). Idempotent replace.
+ * Publish one world's shared `/api` fetch handler so the hub's `/hub` family
+ * can forward non-envelope traffic (`?agent=<label>` GET/HEAD) into the
+ * world's registered routes (session-log export and friends). Called from
+ * inside the world root (`world-entry`); read from the host root
+ * (`carrier`). Idempotent replace.
  */
 export declare function publishWorldFetch(key: string, handler: WorldFetchHandler): () => void;
 /** The world's published shared `/api` fetch handler, if its root published one yet. */

package/superd-hub/dist/world-host.js

@@ -1,3 +1,23 @@
+/**
+ * Cross-root mount registry (AW-B DL1/DL3).
+ *
+ * A world runs as its OWN cordis ROOT (events are root-scoped — probe
+ * 2026-09-16), so ctx0 and the world cannot share service instances through
+ * the context tree. They DO share this module (the profile links
+ * `@pgmi-builds/superd-hub` at the same path), which is where the host hands
+ * the world what it needs to mount itself:
+ *
+ *   ctx0 hub  → registerHostMount({ key, labelPath })         (before spawn)
+ *   world     → takeHostMount(key) → provides the virtual `webServer`
+ *
+ * T-C (2026-09-26): the `real`/`authorize` legs were RETIRED with the
+ * per-label URL family. T-D (2026-09-26) swept the vestiges: the mount record
+ * is the world's ADDRESSABILITY entry only (`{ key, labelPath }`) — no ctx0
+ * webServer instance, no index gate; the adapter world-plugins' call sites
+ * were updated in the same round.
+ *
+ * No selection state: the key is the world's own identity, fixed at spawn.
+ */
 const mounts = new Map();
 /** Publish the host side of one world mount (idempotent replace). */
 export function registerHostMount(mount) {
@@ -26,10 +46,11 @@ export function listHostMounts() {
 }
 const worldFetchHandlers = new Map();
 /**
- * Publish one world's shared `/api` fetch handler so the carrier can forward
- * non-envelope traffic on `/<label>/api` into the world's registered routes
- * (session-log export and friends). Called from inside the world root
- * (`world-entry`); read from the host root (`carrier`). Idempotent replace.
+ * Publish one world's shared `/api` fetch handler so the hub's `/hub` family
+ * can forward non-envelope traffic (`?agent=<label>` GET/HEAD) into the
+ * world's registered routes (session-log export and friends). Called from
+ * inside the world root (`world-entry`); read from the host root
+ * (`carrier`). Idempotent replace.
  */
 export function publishWorldFetch(key, handler) {
     worldFetchHandlers.set(key, handler);

package/superd-hub/dist/world-join.js

@@ -9,14 +9,18 @@
  * adapter's `/world` entry is deliberately inert and is joined HERE).
  *
  *   1. roster membership (activation IS membership, spec S2);
- *   2. ctx0 publishes the host mount (real webServer instance) before spawn;
+ *   2. ctx0 publishes the host mount record — the world's addressability
+ *      entry only since T-D (no webServer instance, no fence: those legs
+ *      retired with the world pages);
  *   3. `spawnWorld` boots the sibling ROOT from the world's own nested home
  *      (`<home>/agents/<key>/profiles/web` — provisioned here via
  *      `provisionWorldProfile`, or by the line bootstrap when the adapter
  *      package is not resolvable from this module), with the world mount
- *      patches (no listener, virtual webServer);
- *   4. the world's gateway becomes a foreign target; the carrier answers
- *      `/<key>/api` + `/<key>/api/remote.mux` in ctx0's auth domain.
+ *      patches (no listener, no webui rows — T-D);
+ *   4. the world's gateway becomes a foreign target; the hub's `/hub` family
+ *      answers `?agent=<key>` traffic in ctx0's auth domain (T-C: the
+ *      per-label `/<key>/api` + `/<key>/api/remote.mux` mounts are retired —
+ *      `/hub` is the sole entry).
  *
  * Cordis identifies a plugin by its module, so ONE joiner row per tree — a
  * second joined world needs either its own adapter-side plugin (omp/codex
@@ -33,7 +37,6 @@ import { registerForeignTarget } from './targets.js';
 import { spawnWorld } from './spawn-world.js';
 import { provisionWorldProfile, resolveInstallAnchor } from './world-provision.js';
 import { registerHostMount } from './world-host.js';
-import { mountWorld } from './carrier.js';
 import { worldMountPatches } from './world-mount.js';
 /** Stable Cordis plugin name. */
 export const name = 'superd-join';
@@ -63,22 +66,10 @@ export function apply(ctx, config) {
         worldHome,
     });
     const world = (async () => {
-        // Wait for ctx0's listening stack: the mount needs the real webServer and
-        // the browser-trust fence from the live connection service.
-        const host = await new Promise((resolve) => {
-            ctx.inject(['webServer', 'connection'], (hostCtx) => { resolve(hostCtx); });
-        });
-        const real = host['webServer'];
-        const connection = host['connection'];
-        const dropHostMount = registerHostMount({
-            key,
-            labelPath: `/${key}`,
-            real,
-            // ctx0's index gate, applied by the mount to this world's pages and
-            // assets: the world is reached in-ctx and owns no listener, so ctx0
-            // decides auth (one auth domain).
-            authorize: (req, res) => connection.authorizeIndex(req, res),
-        });
+        // T-D: the mount record is addressability only — no ctx0 listening-stack
+        // wait, no webServer instance, no authorize leg (the /hub family wires
+        // its own gate in ctx0, see gateway.ts).
+        const dropHostMount = registerHostMount({ key, labelPath: `/${key}` });
         const ctxW = await spawnWorld({
             appName: `superd-${key}`,
             profileName: 'web',
@@ -93,16 +84,10 @@ export function apply(ctx, config) {
         });
         const gateway = ctxW.get('typertGateway');
         registerForeignTarget({ key, gateway });
-        const mounted = mountWorld({
-            real,
-            label: key,
-            gateway,
-            requestRejection: (request) => connection
-                .requestRejection(request),
-        });
+        // T-C: no per-label mount anymore — the gateway above is the world's
+        // whole ingress, reached through the /hub family's `?agent=<key>` demux.
         setReady(key, true);
         ctx.effect?.(() => () => {
-            mounted.dispose();
             dropHostMount();
         }, `superd-join: ${key} mount`);
         return ctxW;

package/superd-hub/dist/world-mount.d.ts

@@ -1,19 +1,37 @@
 /**
- * World composition patches for the mount (AW-B DL1/DL3).
+ * World composition patches for the mount (AW-B DL1/DL3 → path-separation T-D).
  *
- * A mounted world runs with NO listener and provides the virtual webServer
- * from `<pkg>/world`. Three patches make that composition work:
- *
- *   1. `webserver` disabled      — the world owns no socket; ctx0's listener is
- *                                  the only ingress.
- *   2. `modules` inject webServer — client-modules probes
- *      `ctx.get('webServer')` WITHOUT declaring the dependency
- *      (`client/modules/src/index.ts:576`), so without this patch its row
- *      activates before the provider exists and boot fails. Patching the row's
- *      `inject` makes cordis WAIT for the provider, order-independent.
- *   3. insert the world mount row — provides the virtual webServer inside the
- *      world root and translates every route its plugins declare.
+ * A mounted world is a PURE DATA PLANE: no listener (it never had a socket)
+ * and since T-D no webui composition either ("disable their webui build, just
+ * like disable their webserver" — 2026-09-26 user ruling). The rows that gave
+ * the world tree its own web surface are DISABLED here:
  *
+ *   1. `webserver` disabled    — the world owns no socket; ctx0's listener is
+ *                                the only ingress (pre-T-D posture, kept).
+ *   2. `hmr` disabled          — a world's composition is a spawn-time fact;
+ *                                the profile-hmr reload chain must never arm.
+ *   3. `web-runtime` disabled  — the web-app glue row: it mounted the
+ *                                frontend-static fallback owner over the
+ *                                virtual server, printed the URL line, opened
+ *                                the browser, and registered the web-surface
+ *                                prompt section. Its ONE data-plane leg — the
+ *                                `webRuntime` values the `connection` row
+ *                                injects — moved into the world mount row
+ *                                (neutral facts, see `world-entry.ts`).
+ *   4. `client-hmr` disabled   — the client-plugin reload chain; nothing ever
+ *                                loads a world page to reload.
+ *   5. `modules` still waits   — the client-modules row (and any other row
+ *                                that injects `webServer`) binds against the
+ *                                VIRTUAL per-world server the mount row
+ *                                provides; the virtual server swallows every
+ *                                registration (T-C), so the tree boots
+ *                                unchanged while nothing is ever served.
+ *   6. insert the world rows   — the mount row (virtual `webServer` + neutral
+ *                                `webRuntime` provider) and the HUB row (the
+ *                                `/api/agent-runtime` face /hub can reach
+ *                                through the world's own data plane). The
+ *                                world page-trust row is GONE (T-D): its only
+ *                                consumer was the world page.
  * Patch layers are plain data: the patch engine applies arbitrary entry
  * overrides (`vendor/include/src/index.ts:77-121`).
  */
@@ -25,10 +43,13 @@ export declare const WORLD_MOUNT_PLUGIN = "@pgmi-builds/superd-hub/world";
 export declare const WORLD_HUB_ROW_ID = "superd-hub";
 /** Plugin name of the hub itself — one UI, one roster, every runtime. */
 export declare const WORLD_HUB_PLUGIN = "@pgmi-builds/superd-hub";
-/** Id of the inserted page-trust row (world trees; ctx0 composes its own). */
-export declare const WORLD_WEB_TRUST_ROW_ID = "superd-web-trust";
-/** Page-trust component subpath — world pages emit index-inject on their own root. */
-export declare const WORLD_WEB_TRUST_PLUGIN = "@pgmi-builds/superd-hub/web-trust";
+/**
+ * Parse the deploy-level trusted-authority list the world's connection fence
+ * was seeded with (`SUPERD_TRUSTED_HOSTS`, whitespace/comma separated) — the
+ * same values `spawnWorld` feeds the world tree as `--trusted-host` extras.
+ * Shared so the fence facts keep a single derivation.
+ */
+export declare function superdTrustedHosts(value: string | undefined): string[];
 /** One patch layer understood by the loader (structural; no app-boot import). */
 export type WorldPatchLayer = {
     id: string;
@@ -43,17 +64,18 @@ export type WorldPatchLayer = {
     }>;
 };
 /**
- * The layers that turn a listener-owning world into a mounted one:
+ * The layers that turn a listener-owning world into a mounted, webui-less
+ * data plane:
  *
  *   1. `webserver` off — the world owns no socket (the hub serves its face);
- *   2. `modules` waits for the virtual `webServer` the entry row provides;
- *   3. the entry row itself (the world's mount identity);
- *   4. the HUB ROW — the same `@pgmi-builds/superd-hub` native ctx0 composes, so
- *      the foreign agent gets the *identical* selector UI, and the roster it
- *      renders is read from the hub over the world's own `/api` channel;
- *   5. the PAGE-TRUST row — the same component ctx0 composes through the
- *      composite bundle, so a trusted non-loopback page (Caddy domain / LAN
- *      IP) keeps its loopback-equivalent verdict in the WORLD's UI too.
+ *   2. `hmr` off — the composition is a spawn-time fact;
+ *   3. `web-runtime` off — no frontend-static mount, no URL line, no browser
+ *      handoff, no web-surface prompt (T-D; its `webRuntime` provider moved
+ *      into the mount row);
+ *   4. `client-hmr` off — no client reload chain (T-D);
+ *   5. `modules` waits for the virtual `webServer` the mount row provides;
+ *   6. the world rows: the mount (virtual `webServer` + neutral `webRuntime`)
+ *      and the hub (`/api/agent-runtime` face on the world's data plane).
  * @param key - runtime key (`omp`, `codex`, …) — the mount label.
  * @returns patch layers to append to the world's composition.
  */

package/superd-hub/dist/world-mount.js

@@ -1,19 +1,37 @@
 /**
- * World composition patches for the mount (AW-B DL1/DL3).
+ * World composition patches for the mount (AW-B DL1/DL3 → path-separation T-D).
  *
- * A mounted world runs with NO listener and provides the virtual webServer
- * from `<pkg>/world`. Three patches make that composition work:
- *
- *   1. `webserver` disabled      — the world owns no socket; ctx0's listener is
- *                                  the only ingress.
- *   2. `modules` inject webServer — client-modules probes
- *      `ctx.get('webServer')` WITHOUT declaring the dependency
- *      (`client/modules/src/index.ts:576`), so without this patch its row
- *      activates before the provider exists and boot fails. Patching the row's
- *      `inject` makes cordis WAIT for the provider, order-independent.
- *   3. insert the world mount row — provides the virtual webServer inside the
- *      world root and translates every route its plugins declare.
+ * A mounted world is a PURE DATA PLANE: no listener (it never had a socket)
+ * and since T-D no webui composition either ("disable their webui build, just
+ * like disable their webserver" — 2026-09-26 user ruling). The rows that gave
+ * the world tree its own web surface are DISABLED here:
  *
+ *   1. `webserver` disabled    — the world owns no socket; ctx0's listener is
+ *                                the only ingress (pre-T-D posture, kept).
+ *   2. `hmr` disabled          — a world's composition is a spawn-time fact;
+ *                                the profile-hmr reload chain must never arm.
+ *   3. `web-runtime` disabled  — the web-app glue row: it mounted the
+ *                                frontend-static fallback owner over the
+ *                                virtual server, printed the URL line, opened
+ *                                the browser, and registered the web-surface
+ *                                prompt section. Its ONE data-plane leg — the
+ *                                `webRuntime` values the `connection` row
+ *                                injects — moved into the world mount row
+ *                                (neutral facts, see `world-entry.ts`).
+ *   4. `client-hmr` disabled   — the client-plugin reload chain; nothing ever
+ *                                loads a world page to reload.
+ *   5. `modules` still waits   — the client-modules row (and any other row
+ *                                that injects `webServer`) binds against the
+ *                                VIRTUAL per-world server the mount row
+ *                                provides; the virtual server swallows every
+ *                                registration (T-C), so the tree boots
+ *                                unchanged while nothing is ever served.
+ *   6. insert the world rows   — the mount row (virtual `webServer` + neutral
+ *                                `webRuntime` provider) and the HUB row (the
+ *                                `/api/agent-runtime` face /hub can reach
+ *                                through the world's own data plane). The
+ *                                world page-trust row is GONE (T-D): its only
+ *                                consumer was the world page.
  * Patch layers are plain data: the patch engine applies arbitrary entry
  * overrides (`vendor/include/src/index.ts:77-121`).
  */
@@ -25,22 +43,28 @@ export const WORLD_MOUNT_PLUGIN = '@pgmi-builds/superd-hub/world';
 export const WORLD_HUB_ROW_ID = 'superd-hub';
 /** Plugin name of the hub itself — one UI, one roster, every runtime. */
 export const WORLD_HUB_PLUGIN = '@pgmi-builds/superd-hub';
-/** Id of the inserted page-trust row (world trees; ctx0 composes its own). */
-export const WORLD_WEB_TRUST_ROW_ID = 'superd-web-trust';
-/** Page-trust component subpath — world pages emit index-inject on their own root. */
-export const WORLD_WEB_TRUST_PLUGIN = '@pgmi-builds/superd-hub/web-trust';
 /**
- * The layers that turn a listener-owning world into a mounted one:
+ * Parse the deploy-level trusted-authority list the world's connection fence
+ * was seeded with (`SUPERD_TRUSTED_HOSTS`, whitespace/comma separated) — the
+ * same values `spawnWorld` feeds the world tree as `--trusted-host` extras.
+ * Shared so the fence facts keep a single derivation.
+ */
+export function superdTrustedHosts(value) {
+    return (value ?? '').split(/[\s,]+/).filter(Boolean);
+}
+/**
+ * The layers that turn a listener-owning world into a mounted, webui-less
+ * data plane:
  *
  *   1. `webserver` off — the world owns no socket (the hub serves its face);
- *   2. `modules` waits for the virtual `webServer` the entry row provides;
- *   3. the entry row itself (the world's mount identity);
- *   4. the HUB ROW — the same `@pgmi-builds/superd-hub` native ctx0 composes, so
- *      the foreign agent gets the *identical* selector UI, and the roster it
- *      renders is read from the hub over the world's own `/api` channel;
- *   5. the PAGE-TRUST row — the same component ctx0 composes through the
- *      composite bundle, so a trusted non-loopback page (Caddy domain / LAN
- *      IP) keeps its loopback-equivalent verdict in the WORLD's UI too.
+ *   2. `hmr` off — the composition is a spawn-time fact;
+ *   3. `web-runtime` off — no frontend-static mount, no URL line, no browser
+ *      handoff, no web-surface prompt (T-D; its `webRuntime` provider moved
+ *      into the mount row);
+ *   4. `client-hmr` off — no client reload chain (T-D);
+ *   5. `modules` waits for the virtual `webServer` the mount row provides;
+ *   6. the world rows: the mount (virtual `webServer` + neutral `webRuntime`)
+ *      and the hub (`/api/agent-runtime` face on the world's data plane).
  * @param key - runtime key (`omp`, `codex`, …) — the mount label.
  * @returns patch layers to append to the world's composition.
  */
@@ -63,11 +87,19 @@ export function worldMountPatches(key) {
         // worldMountPatches (webserver re-enabled on 3080, world rows gone).
         // Worlds must stay hmr-less: their composition is a spawn-time fact.
         { id: 'hmr', disabled: true },
+        // T-D (2026-09-26): the world webui rows off. The `web-runtime` row is the
+        // web-app glue that mounted frontend-static over the virtual server and
+        // announced a URL nobody can reach (`/hub` is the sole entry); the world
+        // keeps only its data plane. Its `webRuntime` provider — the ONE
+        // data-plane leg (the `connection` row injects it) — is re-provided by the
+        // mount row with the same neutral facts (loopback bind ⇒ no LAN
+        // literals; the deploy-level trusted-host extras ride along).
+        { id: 'web-runtime', disabled: true },
+        { id: 'client-hmr', disabled: true },
         { id: 'modules', inject: ['webServer'] },
         { insert: [
                 { id: WORLD_MOUNT_ROW_ID, name: WORLD_MOUNT_PLUGIN, config: { key } },
                 { id: WORLD_HUB_ROW_ID, name: WORLD_HUB_PLUGIN },
-                { id: WORLD_WEB_TRUST_ROW_ID, name: WORLD_WEB_TRUST_PLUGIN },
             ] },
     ];
 }

package/superd-hub/dist/world-provision.js

@@ -148,10 +148,11 @@ function provisionWorldProfileUnchecked(opts) {
     //
     // 0.1.7: the profile hmr row arms itself wherever a profileContext exists,
     // and its config reload recomposes the tree from THE PROFILE LAYERS ALONE —
-    // spawn-time extraPatches do not survive it. The zero-listener posture is
-    // therefore PERSISTED in this layer (webserver disabled + ephemeral port,
-    // hmr itself off — a world's composition is a spawn-time fact and must not
-    // be re-derived), exactly mirroring worldMountPatches.
+    // spawn-time extraPatches do not survive it. The world posture is therefore
+    // PERSISTED in this layer (webserver disabled + ephemeral port, hmr itself
+    // off, and — T-D — the webui rows `web-runtime`/`client-hmr` off: a world's
+    // composition is a spawn-time fact and must not be re-derived), exactly
+    // mirroring worldMountPatches.
     writeFileSync(join(profDir, 'cordis.patch.yml'), [
         '# Per-world home pinning (dshHomePath is this tree\'s nested home).',
         ...['settings', 'credentials', 'attachment-local', 'shell-env', 'skill-filesystem'].flatMap((id) => [`- id: ${id}`, '  config:', '    dshHome: !!js dshHomePath()']),
@@ -164,6 +165,12 @@ function provisionWorldProfileUnchecked(opts) {
         '    port: 0',
         '- id: hmr',
         '  disabled: true',
+        '# Webui-less posture (T-D): the world page rows stay off across any',
+        '# recomposition — worlds are pure data planes, `/hub` is the sole entry.',
+        '- id: web-runtime',
+        '  disabled: true',
+        '- id: client-hmr',
+        '  disabled: true',
         '',
     ].join('\n'));
     // @pgmi-builds links, plugin-add shape: adapter + hub into the world