super-dsh 0.1.0 → 0.1.2

package/agent-hub/dist/spawn-world.d.ts

@@ -0,0 +1,46 @@
+/**
+ * spawnWorld (S2): spawn a sibling ROOT context for a foreign agent world
+ * from the CTX0 tree — the library form of the PoC (ADR 0008 mechanism,
+ * .scratch/multi-context-poc/spawner2.mjs collapsed into a function).
+ *
+ * AW-A posture: SHARED home (ADR 0008 constraint 2 fallback). The ctxN
+ * `dshHomePath` service override is an AW-C1 item (spec §三/§十一.2) — the
+ * boot() provide/prepare ordering fact is pinned by
+ * test/boot-prepare-ordering.test.mjs. Data detachment at this stage comes
+ * from the adapter side (foreign app-home redirection, spec §七).
+ *
+ * Profile resolution: loadProfile(name, profileName, installAnchor, home)
+ * reads profiles under `<home>/profiles/<profileName>` and heals the
+ * `@deepseek-ai/*` fallback farm into `<home>/profiles/node_modules` from
+ * the install anchor (single instance — same physical installation).
+ */
+import { boot } from '@deepseek-ai/dsh-app-boot';
+export interface SpawnWorldOptions {
+    /** App name for the spawned root (also its fiber label). */
+    appName: string;
+    /** Profile directory name under `<home>/profiles/`. */
+    profileName: string;
+    /** package.json of the @deepseek-ai installation that owns the bundle closure. */
+    installAnchor: string;
+    /**
+     * The world's own home root: profiles resolve from `<home>/profiles/<name>`.
+     * The caller passes the NESTED root (`<line home>/agents/<label>`) — every
+     * runtime owns one root, nothing is shared between runtimes.
+     */
+    home: string;
+    /**
+     * The world's DSH data root (sessions / settings / workspaces). Defaults to
+     * {@link home}. When it differs from `home`, the child tree's `dshHomePath`
+     * service is overridden in the boot `prepare` slot — which runs AFTER boot's
+     * own provide and BEFORE the plugin tree mounts, so every `!!js
+     * dshHomePath(...)` expression in the composition resolves inside this root
+     * (ADR 0008 constraint 2: per-context home can only be an in-tree service
+     * override; `process.env` is a shared resolver).
+     */
+    dataHome?: string;
+    /** Extra patch layers appended after the profile's own (e.g. an adapter's insert row). */
+    extraPatches?: Parameters<typeof boot>[2];
+    /** Override the bare-name resolution base (defaults to the install anchor's node_modules). */
+    bareModuleBaseUrl?: string;
+}
+export declare function spawnWorld(opts: SpawnWorldOptions): Promise<import("@deepseek-ai/cordis").Context>;

package/agent-hub/dist/spawn-world.js

@@ -0,0 +1,72 @@
+/**
+ * spawnWorld (S2): spawn a sibling ROOT context for a foreign agent world
+ * from the CTX0 tree — the library form of the PoC (ADR 0008 mechanism,
+ * .scratch/multi-context-poc/spawner2.mjs collapsed into a function).
+ *
+ * AW-A posture: SHARED home (ADR 0008 constraint 2 fallback). The ctxN
+ * `dshHomePath` service override is an AW-C1 item (spec §三/§十一.2) — the
+ * boot() provide/prepare ordering fact is pinned by
+ * test/boot-prepare-ordering.test.mjs. Data detachment at this stage comes
+ * from the adapter side (foreign app-home redirection, spec §七).
+ *
+ * Profile resolution: loadProfile(name, profileName, installAnchor, home)
+ * reads profiles under `<home>/profiles/<profileName>` and heals the
+ * `@deepseek-ai/*` fallback farm into `<home>/profiles/node_modules` from
+ * the install anchor (single instance — same physical installation).
+ */
+import { loadProfile, boot } from '@deepseek-ai/dsh-app-boot';
+import { provideCmdline } from '@deepseek-ai/dsh-cmdline';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const EMPTY_ROOT = '[]\n';
+export async function spawnWorld(opts) {
+    const profile = loadProfile(opts.appName, opts.profileName, opts.installAnchor, opts.home);
+    // Empty include root: the tree is composed entirely as patch layers
+    // (bundle rows in profile order + profile patch + extras).
+    writeFileSync(join(profile.dir, 'cordis.yml'), EMPTY_ROOT);
+    const patches = [
+        ...profile.layers.flatMap((l) => l.patches),
+        ...profile.patches,
+        ...(opts.extraPatches ?? []),
+    ];
+    // Bare plugin names resolve from the installation's node_modules (the
+    // anchor owns the complete plugin closure). Same cordis on both sides —
+    // no cross-copy Symbol split.
+    // Loader wants a file:// URL base; accept a plain path and normalize.
+    const rawBase = opts.bareModuleBaseUrl ?? join(opts.installAnchor, '..', 'node_modules', '/');
+    const bareModuleBaseUrl = rawBase.startsWith('file:')
+        ? rawBase
+        : pathToFileURL(rawBase.endsWith('/') ? rawBase : rawBase + '/').href;
+    // Embedding-host facts via the PUBLIC cmdline API (risk-2 probe: boot owns
+    // dshHomePath, so the prepare slot is for OUR provides — cmdlineArgs is not
+    // boot-provided and upstream documents the empty-args embedding path).
+    // Worlds take no flags and never open a browser; exit = dispose own fiber.
+    // LAN authorities for the world's trust fence (deploy-level, env-driven):
+    // the world webserver must accept the Host the browser actually sends.
+    const trusted = (process.env.AW_TRUSTED_HOSTS ?? '')
+        .split(/[\s,]+/).filter(Boolean)
+        .flatMap((h) => ['--trusted-host', h]);
+    let fiber;
+    const ctxW = await boot(opts.appName, join(profile.dir, 'cordis.yml'), patches, (ctx) => {
+        provideCmdline(ctx, {
+            args: ['--no-open', ...trusted],
+            exit: () => { void fiber?.dispose(); },
+        });
+        // This tree reads its own home from here on: sessions, settings.yaml,
+        // workspace store — all under the world's nested root.
+        //
+        // `set` (not `provide`): boot already registered `dshHomePath` on this
+        // root, and cordis refuses a second `provide` in the same scope
+        // ("service … has been registered at <root>"). `set` is the documented
+        // "overwrite a provided service's value" path for the owning fiber, which
+        // the prepare slot is — and ADR 0008 constraint 2 prescribes exactly this
+        // in-tree override (process.env is a shared resolver and must not change).
+        if (opts.dataHome !== undefined) {
+            const dataHome = opts.dataHome;
+            ctx.set('dshHomePath', (...segments) => join(dataHome, ...segments));
+        }
+    }, bareModuleBaseUrl);
+    fiber = ctxW.fiber;
+    return ctxW;
+}

package/agent-hub/dist/targets.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Foreign target registry: which runtime key maps to which context's
+ * typertGateway SERVICE INSTANCE.
+ *
+ * The instance is the whole target: its two methods (dispatchRpc /
+ * openWireStream) address their upstream through their own owning context
+ * (ctx.typert, ctx.reflect) and their own instance state (remoteEvents,
+ * registered by that tree's api-remotes). Delegating a call to the instance
+ * therefore delegates BOTH address spaces at once — Cordis ctx and JS this.
+ * An out-of-process target (subprocess app / remote machine) implements the
+ * same GatewayFace over the wire (ADR 0007 loopback relay) — the caller
+ * cannot tell the difference.
+ */
+/** The structural face of a typertGateway service instance. */
+export interface GatewayFace {
+    dispatchRpc(endpoint: string, payload: unknown, signal: AbortSignal): Promise<unknown>;
+    openWireStream(endpoint: string, payload: unknown, signal: AbortSignal): AsyncIterable<unknown>;
+}
+/** One addressable runtime world behind the selector. */
+export interface ForeignTarget {
+    /** Runtime key (`omp`, …) — what the selector addresses. */
+    key: string;
+    /** The context's typertGateway service instance (or a wire adapter with the same face). */
+    gateway: GatewayFace;
+}
+/** Register (or replace) the target for a runtime key. */
+export declare function registerForeignTarget(target: ForeignTarget): void;
+/** Drop a target (context disposed). */
+export declare function unregisterForeignTarget(key: string): void;
+/** Live runtime keys: the native world plus every registered foreign key. */
+export declare function listRuntimeKeys(): string[];
+/** Test/introspection hook. */
+export declare function getTarget(key: string): ForeignTarget | undefined;

package/agent-hub/dist/targets.js

@@ -0,0 +1,30 @@
+/**
+ * Foreign target registry: which runtime key maps to which context's
+ * typertGateway SERVICE INSTANCE.
+ *
+ * The instance is the whole target: its two methods (dispatchRpc /
+ * openWireStream) address their upstream through their own owning context
+ * (ctx.typert, ctx.reflect) and their own instance state (remoteEvents,
+ * registered by that tree's api-remotes). Delegating a call to the instance
+ * therefore delegates BOTH address spaces at once — Cordis ctx and JS this.
+ * An out-of-process target (subprocess app / remote machine) implements the
+ * same GatewayFace over the wire (ADR 0007 loopback relay) — the caller
+ * cannot tell the difference.
+ */
+const targets = new Map();
+/** Register (or replace) the target for a runtime key. */
+export function registerForeignTarget(target) {
+    targets.set(target.key, target);
+}
+/** Drop a target (context disposed). */
+export function unregisterForeignTarget(key) {
+    targets.delete(key);
+}
+/** Live runtime keys: the native world plus every registered foreign key. */
+export function listRuntimeKeys() {
+    return ['native', ...targets.keys()];
+}
+/** Test/introspection hook. */
+export function getTarget(key) {
+    return targets.get(key);
+}

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

@@ -0,0 +1,31 @@
+/**
+ * World-side mount plugin (AW-B DL1/DL3) — `@pgmi-builds/agent-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.
+ *
+ * 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.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Stable Cordis plugin name. */
+export declare const name = "aw.world.mount";
+/** Row config: which world this root is. */
+export interface Config {
+    key: string;
+}
+/** Apply the world mount. @param ctx - the WORLD root context. @param config - `{ key }`. */
+export declare function apply(ctx: Context, config?: {
+    key?: unknown;
+}): void;
+export default apply;

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

@@ -0,0 +1,51 @@
+import { noteWorldServer, publishWorldFetch, takeHostMount } from './world-host.js';
+import { WorldWebServer } from './world-web-server.js';
+/** Stable Cordis plugin name. */
+export const name = 'aw.world.mount';
+/** Apply the world mount. @param ctx - the WORLD root context. @param config - `{ key }`. */
+export function apply(ctx, config) {
+    const key = typeof config?.key === 'string' ? config.key : undefined;
+    if (key === undefined) {
+        ctx.logger?.warn?.('aw.world.mount: missing config.key — world not mounted');
+        return;
+    }
+    const mount = takeHostMount(key);
+    if (mount === undefined) {
+        ctx.logger?.warn?.(`aw.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,
+    });
+    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.
+    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?.();
+    }, 'aw.world.mount: virtual webServer');
+}
+export default apply;

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

@@ -0,0 +1,69 @@
+/**
+ * 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/agent-hub` at the same path), which is where the host hands the
+ * world everything it needs to mount itself:
+ *
+ *   ctx0 hub  → registerHostMount({ key, labelPath, real })   (before spawn)
+ *   world     → takeHostMount(key) → provides the virtual `webServer`
+ *
+ * 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. */
+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;
+/** Record the virtual webServer a world root provided (diagnostics/tests). */
+export declare function noteWorldServer(key: string, server: unknown): void;
+/** The virtual webServer a world root provided, if it mounted yet. */
+export declare function worldServerOf(key: string): unknown;
+/** Read one host mount (called from inside the world root). */
+export declare function takeHostMount(key: string): HostMount | undefined;
+/** Keys with a published host mount. */
+export declare function listHostMounts(): string[];
+/**
+ * The structural face of a world connection's shared `/api` fetch handler
+ * (upstream `ConnectionFetchHandler` from `client/connection`): exact Fetch
+ * routes first, then the shared-channel RPC interceptor, then 404. Trust and
+ * authentication are NOT part of this face — upstream applies them in the
+ * physical carrier around it, which under a mount is the hub's carrier with
+ * ctx0's fence.
+ */
+export interface WorldFetchHandler {
+    /** Resolve body handling for one request before any bytes are read. */
+    requestBodyMode(request: {
+        readonly method: string;
+        readonly url: URL;
+    }): 'buffered' | 'streaming';
+    /** Dispatch one already-authenticated request to its route owner. */
+    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.
+ */
+export declare function publishWorldFetch(key: string, handler: WorldFetchHandler): () => void;
+/** The world's published shared `/api` fetch handler, if its root published one yet. */
+export declare function worldFetchHandlerOf(key: string): WorldFetchHandler | undefined;

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

@@ -0,0 +1,44 @@
+const mounts = new Map();
+/** Publish the host side of one world mount (idempotent replace). */
+export function registerHostMount(mount) {
+    mounts.set(mount.key, mount);
+    return () => {
+        if (mounts.get(mount.key) === mount)
+            mounts.delete(mount.key);
+    };
+}
+const servers = new Map();
+/** Record the virtual webServer a world root provided (diagnostics/tests). */
+export function noteWorldServer(key, server) {
+    servers.set(key, server);
+}
+/** The virtual webServer a world root provided, if it mounted yet. */
+export function worldServerOf(key) {
+    return servers.get(key);
+}
+/** Read one host mount (called from inside the world root). */
+export function takeHostMount(key) {
+    return mounts.get(key);
+}
+/** Keys with a published host mount. */
+export function listHostMounts() {
+    return [...mounts.keys()];
+}
+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.
+ */
+export function publishWorldFetch(key, handler) {
+    worldFetchHandlers.set(key, handler);
+    return () => {
+        if (worldFetchHandlers.get(key) === handler)
+            worldFetchHandlers.delete(key);
+    };
+}
+/** The world's published shared `/api` fetch handler, if its root published one yet. */
+export function worldFetchHandlerOf(key) {
+    return worldFetchHandlers.get(key);
+}

package/agent-hub/dist/world-join.d.ts

@@ -0,0 +1,16 @@
+/** Stable Cordis plugin name. */
+export declare const name = "aw.world.join";
+/** Row config: which world to join, under which roster label. */
+export interface Config {
+    key: string;
+    label?: string;
+}
+/** Structural slice of the ctx0 services the join needs. */
+interface HostContext {
+    provide(name: string, value: unknown): void;
+    inject(deps: string[], callback: (ctx: unknown) => void): unknown;
+    effect?(callback: () => () => void, label?: string): unknown;
+}
+/** Apply the join. @param ctx - the CTX0 root context. @param config - `{ key, label? }`. */
+export declare function apply(ctx: HostContext, config?: Partial<Config>): void;
+export default apply;

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

@@ -0,0 +1,122 @@
+/**
+ * Hub-side world joiner (AW-B DL1–DL5) — `@pgmi-builds/agent-hub/join`.
+ *
+ * Ruling R2 (2026-09-16): an adapter may ship STANDALONE only — joining the
+ * agent-worlds hub is the HUB side's job. This plugin is that job, generic:
+ * the ctx0 composition inserts one row with `{ key }` and the hub does the
+ * spawn/roster/mount wiring the adapter's own world plugin would otherwise
+ * carry (the omp/codex adapters ship active per-adapter plugins; the claude
+ * 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;
+ *   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.
+ *
+ * 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
+ * shape) or this plugin promoted to per-row instances. The world's PROFILE
+ * (bundles incl. its adapter) is provisioned by `provisionWorldProfile`
+ * (registry installs) or the line bootstrap (dev); this row only spawns,
+ * registers and mounts what that profile composes.
+ */
+import { mkdirSync } from 'node:fs';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { join } from 'node:path';
+import { registerAgent, setReady } from './roster.js';
+import { registerForeignTarget } from './targets.js';
+import { spawnWorld } from './spawn-world.js';
+import { provisionWorldProfile } 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 = 'aw.world.join';
+const ANCHOR = process.env.SUPERD_DSH_ANCHOR
+    ?? '/home/u1/.local/lib/node_modules/@deepseek-ai/dsh/package.json';
+/** Apply the join. @param ctx - the CTX0 root context. @param config - `{ key, label? }`. */
+export function apply(ctx, config) {
+    const key = typeof config?.key === 'string' ? config.key : undefined;
+    if (key === undefined || key === '' || key.includes('/')) {
+        ctx.provide('aw.world.join.error', `invalid config.key ${JSON.stringify(config?.key)}`);
+        return;
+    }
+    const label = typeof config?.label === 'string' && config.label !== '' ? config.label : key;
+    registerAgent({ key, label, ready: false });
+    // S7 nested home: the world's whole tree lives under `agents/<key>` (its
+    // profiles were provisioned there by the line bootstrap; DSH data lands
+    // inside the same root via spawnWorld's dataHome override).
+    // Harness resolver (env → ~/.dsh): a consumer install has no DSH_HOME and
+    // no cwd contract — deriving the world root from cwd spawns worlds into a
+    // garbage tree or throws inside apply() and kills the whole host boot.
+    const root = resolveDshHome();
+    const worldHome = join(root, 'agents', key);
+    mkdirSync(join(worldHome, 'profiles'), { recursive: true });
+    // Publish story: a foreign install has no line bootstrap, so the nested
+    // profile + @pgmi-builds links are provisioned HERE (idempotent; dev lines
+    // keep parity — smoke.mjs wrote the same layout, and AW_BARE_BASE still
+    // overrides the resolved base).
+    const bareBase = provisionWorldProfile({
+        key,
+        adapterPkg: '@pgmi-builds/agent-adapter-claude',
+        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),
+        });
+        const ctxW = await spawnWorld({
+            appName: `aw-${key}`,
+            profileName: 'web',
+            installAnchor: ANCHOR,
+            home: worldHome,
+            dataHome: worldHome,
+            // Adapter-local bundle names resolve from the profile's own
+            // node_modules (heal owns @deepseek-ai there; @pgmi-builds links are
+            // provisioned by provisionWorldProfile above, or by the line bootstrap
+            // when the adapter package was not resolvable — env wins over both).
+            bareModuleBaseUrl: process.env.AW_BARE_BASE ?? bareBase ?? undefined,
+            extraPatches: worldMountPatches(key),
+        });
+        const gateway = ctxW.get('typertGateway');
+        registerForeignTarget({ key, gateway });
+        const mounted = mountWorld({
+            real,
+            label: key,
+            gateway,
+            requestRejection: (request) => connection
+                .requestRejection(request),
+        });
+        setReady(key, true);
+        ctx.effect?.(() => () => {
+            mounted.dispose();
+            dropHostMount();
+        }, `aw.world.join: ${key} mount`);
+        return ctxW;
+    })().catch((cause) => {
+        // A failed world degrades to a not-ready roster row; a rejected provided
+        // promise would fail the entire host boot (loader entry apply).
+        console.error(`[super-dsh] ${key} world failed:`, cause);
+        return null;
+    });
+    ctx.provide(`aw.world.${key}`, world);
+}
+export default apply;

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

@@ -0,0 +1,52 @@
+/**
+ * World composition patches for the mount (AW-B DL1/DL3).
+ *
+ * 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.
+ *
+ * Patch layers are plain data: the patch engine applies arbitrary entry
+ * overrides (`vendor/include/src/index.ts:77-121`).
+ */
+/** Id of the inserted world-mount row. */
+export declare const WORLD_MOUNT_ROW_ID = "aw-world-mount";
+/** Plugin name providing the world's virtual webServer. */
+export declare const WORLD_MOUNT_PLUGIN = "@pgmi-builds/agent-hub/world";
+/** Id of the inserted hub row (the same plugin ctx0 itself composes). */
+export declare const WORLD_HUB_ROW_ID = "aw-agent-hub";
+/** Plugin name of the hub itself — one UI, one roster, every runtime. */
+export declare const WORLD_HUB_PLUGIN = "@pgmi-builds/agent-hub";
+/** One patch layer understood by the loader (structural; no app-boot import). */
+export type WorldPatchLayer = {
+    id: string;
+    disabled?: boolean;
+    inject?: readonly string[];
+} | {
+    insert: ReadonlyArray<{
+        id: string;
+        name: string;
+        config?: Record<string, unknown>;
+    }>;
+};
+/**
+ * The layers that turn a listener-owning world into a mounted one:
+ *
+ *   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/agent-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.
+ * @param key - runtime key (`omp`, `codex`, …) — the mount label.
+ * @returns patch layers to append to the world's composition.
+ */
+export declare function worldMountPatches(key: string): readonly WorldPatchLayer[];

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

@@ -0,0 +1,52 @@
+/**
+ * World composition patches for the mount (AW-B DL1/DL3).
+ *
+ * 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.
+ *
+ * Patch layers are plain data: the patch engine applies arbitrary entry
+ * overrides (`vendor/include/src/index.ts:77-121`).
+ */
+/** Id of the inserted world-mount row. */
+export const WORLD_MOUNT_ROW_ID = 'aw-world-mount';
+/** Plugin name providing the world's virtual webServer. */
+export const WORLD_MOUNT_PLUGIN = '@pgmi-builds/agent-hub/world';
+/** Id of the inserted hub row (the same plugin ctx0 itself composes). */
+export const WORLD_HUB_ROW_ID = 'aw-agent-hub';
+/** Plugin name of the hub itself — one UI, one roster, every runtime. */
+export const WORLD_HUB_PLUGIN = '@pgmi-builds/agent-hub';
+/**
+ * The layers that turn a listener-owning world into a mounted one:
+ *
+ *   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/agent-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.
+ * @param key - runtime key (`omp`, `codex`, …) — the mount label.
+ * @returns patch layers to append to the world's composition.
+ */
+export function worldMountPatches(key) {
+    if (typeof key !== 'string' || key === '' || key.includes('/')) {
+        throw new Error(`world-mount: invalid key ${JSON.stringify(key)}`);
+    }
+    return [
+        { id: 'webserver', 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 },
+            ] },
+    ];
+}