super-dsh 0.1.3 → 0.1.5

package/cordis.patch.yml

@@ -1,4 +1,4 @@
-# super-dsh — the Agent Worlds composite bundle (one `dsh plugin add` face).
+# super-dsh — the Super D composite bundle (one `dsh plugin add` face).
 #
 # better-dsh shape: ONE package, components are this package's own subpath
 # exports, so every row below is individually toggleable on the plugin page
@@ -7,34 +7,57 @@
 #   - super-dsh/hub            the hub: selector + roster + per-world mount
 #                              carrier + V5 gateway delegation (wraps the live
 #                              typertGateway; upstream dispatch untouched)
-#   - super-dsh/world/<label>  one world plugin per adapter (activation IS
+#   - super-dsh/agents/<label>  one world plugin per adapter (activation IS
 #                              roster membership, S2) — each spawns its own
 #                              zero-port sibling root, mounted under /<label>
 #   - super-dsh/join           the generic hub joiner for the standalone
 #                              claude adapter (R2)
+#   - super-dsh/web-trust      the page-trust component (ported from
+#                              better-dsh web-trust, authorities leg): the
+#                              browser-side twin of the server trustedHosts
+#                              fence — declares trusted page authorities so
+#                              the Web UI treats a non-loopback page (Caddy
+#                              domain / LAN IP) as loopback-equivalent.
+#                              On/off: row `disabled: true`, or config
+#                              `trustedPageAuthorities: []` (inert). Default
+#                              derives from the trusted-hosts env.
 #
 # Profile-layer values (webserver port/host, settings path) stay in the USER's
 # profile patch layer, never here.
 - insert:
-    # BARE package row: subpath rows (…/world/omp) are permanently not client
+    # BARE package row: subpath rows (…/agents/omp) are permanently not client
     # rows in client-modules' scan (exactPackageSpecifier), so THIS row is
     # what registers the package's client half — the sidebar selector.
-    - id: agent-hub
+    - id: superd-hub
       name: 'super-dsh'
-    - id: aw-agent-adapter-omp
-      name: 'super-dsh/world/omp'
-    - id: aw-agent-adapter-codex
-      name: 'super-dsh/world/codex'
-    - id: aw-agent-adapter-pi
-      name: 'super-dsh/world/pi'
-    - id: aw-agent-adapter-hermes
-      name: 'super-dsh/world/hermes'
-    - id: aw-agent-adapter-agy
-      name: 'super-dsh/world/agy'
+    - id: superd-web-trust
+      name: 'super-dsh/web-trust'
+    # Native UI fusion transport (plan Task 3): the ctx0 page-level state atom
+    # + five call-time patches, flag-gated (SUPERD_UI_FUSION, default off).
+    # ROW ORDER IS LOAD ORDER and the row MUST stay after superd-web-trust:
+    # the trust script's non-merging `if(!window.__DSH_TRANSPORT__)` verdict
+    # must be evaluated before the fusion script could own that global
+    # (spec §3.4, hard; precedent world-web-server.ts renderIndex).
+    # On/off (Task 5 formalization): env `SUPERD_UI_FUSION` derives the
+    # schema default (off when unset); a profile layer may restate this row
+    # (same id, same name) with `config: {enabled: true|false}` to override.
+    # Off = the component registers nothing: no script, no flag global.
+    - id: superd-fusion-transport
+      name: 'super-dsh/fusion-transport'
+    - id: agent-omp
+      name: 'super-dsh/agents/omp'
+    - id: agent-codex
+      name: 'super-dsh/agents/codex'
+    - id: agent-pi
+      name: 'super-dsh/agents/pi'
+    - id: agent-hermes
+      name: 'super-dsh/agents/hermes'
+    - id: agent-agy
+      name: 'super-dsh/agents/agy'
     # R2 (2026-09-16): the claude adapter ships STANDALONE only — its /world
     # entry is inert. The HUB side joins it: one generic joiner row with the
     # key; spawn/roster/mount wiring lives in super-dsh/join.
-    - id: aw-world-join-claude
+    - id: superd-join-claude
       name: 'super-dsh/join'
       config:
         key: claude

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "super-dsh",
-  "version": "0.1.3",
-  "description": "Agent Worlds for the DeepSeek Harness (DSH) — one dsh plugin that mounts the agent hub (runtime selector, roster, per-runtime worlds) and joins local foreign-agent runtimes (OMP, Codex, Claude, Pi, Hermes, Antigravity) into the DSH Web UI. Each runtime keeps its native home and session store; the hub only bridges.",
+  "version": "0.1.5",
+  "description": "Super D for the DeepSeek Harness (DSH) — one dsh plugin that mounts the superd hub (runtime selector, roster, per-runtime agents) and joins local foreign-agent runtimes (OMP, Codex, Claude, Pi, Hermes, Antigravity) into the DSH Web UI. Each runtime keeps its native home and session store; the hub only bridges.",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -9,27 +9,29 @@
     "url": "git+https://github.com/pgmi-builds/superd.git"
   },
   "exports": {
-    ".": "./agent-hub/dist/index.js",
-    "./hub": "./agent-hub/dist/index.js",
-    "./join": "./agent-hub/dist/world-join.js",
-    "./world/omp": "./agent-omp/dist/world-plugin.js",
-    "./world/codex": "./agent-codex/dist/world-plugin.js",
-    "./world/claude": "./agent-claude/dist/world-plugin.js",
-    "./world/pi": "./agent-pi/dist/world-plugin.js",
-    "./world/hermes": "./agent-hermes/dist/world-plugin.js",
-    "./world/agy": "./agent-agy/dist/world-plugin.js",
+    ".": "./superd-hub/dist/index.js",
+    "./hub": "./superd-hub/dist/index.js",
+    "./join": "./superd-hub/dist/world-join.js",
+    "./agents/omp": "./agent-omp/dist/world-plugin.js",
+    "./agents/codex": "./agent-codex/dist/world-plugin.js",
+    "./agents/claude": "./agent-claude/dist/world-plugin.js",
+    "./agents/pi": "./agent-pi/dist/world-plugin.js",
+    "./agents/hermes": "./agent-hermes/dist/world-plugin.js",
+    "./agents/agy": "./agent-agy/dist/world-plugin.js",
     "./client": "./client/index.js",
     "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./web-trust": "./superd-hub/dist/web-trust.js",
+    "./fusion-transport": "./superd-hub/dist/fusion-transport.js"
   },
   "files": [
     "cordis.patch.yml",
     "client",
     "README.md",
-    "agent-hub/dist",
-    "agent-hub/lib",
-    "agent-hub/package.json",
-    "agent-hub/cordis.patch.yml",
+    "superd-hub/dist",
+    "superd-hub/lib",
+    "superd-hub/package.json",
+    "superd-hub/cordis.patch.yml",
     "agent-omp/dist",
     "agent-omp/package.json",
     "agent-omp/cordis.patch.yml",
@@ -70,24 +72,24 @@
     "@openai/codex-sdk": "0.154.0",
     "bun": "^1.4.2",
     "ws": "^8.21.0",
-    "zod": "3.25.76",
+    "zod": "4.4.3",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-agent-presets": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-api-gateway": "*",
-    "@deepseek-ai/dsh-commands": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-home-paths": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "*",
-    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-scope": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-session-persistence": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-typert-protocol": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-user-approval": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-user-questions": "0.1.5-rc.2"
+    "@deepseek-ai/dsh-agent": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-agent-presets": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-api-gateway": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-commands": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-home-paths": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-scope": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-session": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-session-persistence": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-user-approval": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-user-questions": ">=0.1.5-0 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {

package/{agent-hub → superd-hub}/cordis.patch.yml

@@ -1,4 +1,4 @@
-# Mount the agent-hub host half BESIDE the upstream gateway.
+# Mount the superd-hub host half BESIDE the upstream gateway.
 # The typert-gateway row STAYS ENABLED: disabling it also removed the
 # gateway package's client half from the browser module table (learned
 # 2026-09-10: session-controller's client requires
@@ -8,5 +8,5 @@
 # The /api/agent-runtime selector RPC face rides along (control plane,
 # always CTX0-local).
 - insert:
-    - id: agent-hub
-      name: '@pgmi-builds/agent-hub'
+    - id: superd-hub
+      name: '@pgmi-builds/superd-hub'

package/{agent-hub → superd-hub}/dist/agent-roster.d.ts

@@ -12,7 +12,7 @@
  *   /codex/    → the Codex world's mount
  */
 import type { IndexInjection } from '@deepseek-ai/dsh-host-webserver';
-/** One selectable runtime: its key, its label, and the path that addresses it. */
+/** One selectable runtime: its key, its label, the path that addresses it, its machine. */
 export interface AgentLink {
     /** `native` for ctx0, otherwise the adapter's runtime key. */
     key: string;
@@ -20,6 +20,8 @@ export interface AgentLink {
     label: string;
     /** Mount root, always trailing-slashed except the native `/`. */
     path: string;
+    /** Machine the runtime runs on — the Hub UI's grouping key. */
+    machine: string;
 }
 /** The global this module publishes the roster under. */
 export declare const AGENT_ROSTER_GLOBAL = "__DSH_AGENT_ROSTER__";

package/{agent-hub → superd-hub}/dist/agent-roster.js

@@ -1,7 +1,9 @@
 import { listAgents } from './roster.js';
 import { takeHostMount } from './world-host.js';
+/** Machine of every roster row today — the local constant; the extension point a multi-machine registry replaces. */
+const LOCAL_MACHINE = 'local';
 /** The native runtime's synthetic entry (no adapter plugin backs it). */
-const NATIVE = { key: 'native', label: 'DSH', path: '/' };
+const NATIVE = { key: 'native', label: 'DSH', path: '/', machine: LOCAL_MACHINE };
 /** The global this module publishes the roster under. */
 export const AGENT_ROSTER_GLOBAL = '__DSH_AGENT_ROSTER__';
 /**
@@ -17,7 +19,7 @@ export function agentLinks() {
         if (mount === undefined)
             continue;
         const path = mount.labelPath.endsWith('/') ? mount.labelPath : `${mount.labelPath}/`;
-        links.push({ key: agent.key, label: agent.label, path });
+        links.push({ key: agent.key, label: agent.label, path, machine: LOCAL_MACHINE });
     }
     return links;
 }

package/superd-hub/dist/carrier.d.ts

@@ -0,0 +1,62 @@
+import { type WorldRequest, type WorldResponse } from './world-web-server.js';
+import { WorldMuxServer, type MuxFailure } from './world-mux.js';
+/** The three-method face of a world's typertGateway service instance. */
+export interface CarrierGatewayFace {
+    dispatchRpc(endpoint: string, payload: unknown, signal: AbortSignal): Promise<unknown>;
+    /**
+     * Streams return an async iterable (upstream face is synchronous-returning).
+     * Canonical order: (endpoint, payload, uplink, peer, signal, control) — the
+     * carrier passes no peer (ctx0's fence already authenticated the client),
+     * the mux controller's signal, and the controller itself, exactly as the
+     * native gateway's mux wires its own streams.
+     */
+    openWireStream(endpoint: string, payload: unknown, uplink: AsyncIterable<unknown>, peer: undefined, signal: AbortSignal, control: AbortController): Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>;
+}
+export declare function writeJson(res: WorldResponse, status: number, body: string): void;
+/** Deps the forwarding kernel needs to answer for one world's traffic. */
+export interface ForwardOptions {
+    /** The addressed world's gateway instance. */
+    gateway: CarrierGatewayFace;
+    /** World key addressing the world's published `/api` fetch handler. */
+    label: string;
+    /** URL prefix this carrier strips before the world sees the request (`/omp`, `/hub`). */
+    mountPath: string;
+    /** ctx0's browser-trust fence: returns an HTTP status to reject with. */
+    requestRejection?(req: unknown): number | undefined;
+    /** Max request body bytes (mirrors the connection default). */
+    maxBodyBytes?: number;
+}
+/**
+ * Forward one non-envelope GET/HEAD request into the owning world's shared
+ * `/api` fetch handler (exact Fetch routes first, then the gateway's RPC
+ * interceptor, then 404 — the upstream composition). The caller has already
+ * answered the ctx0 fence by the time we get here; the world's own
+ * browser-auth gate is never consulted (a different tree, a different secret).
+ */
+export declare function forwardWorldFetch(options: {
+    label: string;
+    mountPath: string;
+}, req: WorldRequest, res: WorldResponse): Promise<void>;
+/**
+ * The reusable forwarding kernel (envelope dispatch + world fetch bridge):
+ * decode the connection envelope and dispatch into the ADDRESSED world's
+ * gateway instance; non-envelope GET/HEAD traffic forwards into the world's
+ * own registered fetch routes. Parameterized by (gateway, label, mountPath)
+ * so the `/hub` route family shares this exact behavior — the demux key is
+ * the caller's business, the wire semantics live here.
+ */
+export declare function forwardApiCall(options: ForwardOptions, req: WorldRequest, res: WorldResponse): Promise<void>;
+/** One WorldMuxServer bound to `gateway` — the canonical openWireStream wiring in one place. */
+export declare function worldMuxOf(gateway: CarrierGatewayFace, options?: {
+    heartbeatIntervalMs?: number;
+    failure?: (error: unknown) => MuxFailure;
+}): WorldMuxServer;
+/**
+ * RETIRED with T-D (2026-09-26): the T-C `mountWorld` no-op — which itself
+ * used to register `/<label>/api`, `/<label>/open-in-app` and
+ * `/<label>/api/remote.mux` on the real webServer — is GONE from the module.
+ * The adapter world-plugins' spawn-time call sites were updated in the same
+ * round (the registerHostMount record needs no webServer and no fence; the
+ * `/hub` family reaches each world's gateway through the foreign-target
+ * table). Git history keeps the function.
+ */

package/superd-hub/dist/carrier.js

@@ -0,0 +1,213 @@
+/**
+ * The carrier forwarding kernel (AW-B DL1/DL5 → native UI fusion Task 2 →
+ * path-separation T-C): the wire semantics every foreign-agent entry shares.
+ *
+ * History and the T-C/T-D cuts:
+ *  - The kernel — envelope dispatch ({@link forwardApiCall}), the world fetch
+ *    bridge ({@link forwardWorldFetch}) and the mux construction
+ *    ({@link worldMuxOf}) — is parameterized by (gateway, label, mountPath).
+ *  - It used to be mounted twice: the per-label page family
+ *    (`/<label>/api`, `/<label>/api/remote.mux`, `/<label>/open-in-app` —
+ *    registered by the now-deleted `mountWorld`) and, since 2026-09-26, the
+ *    hub-owned `/hub` family (`hub-route.ts`, demuxed by `?agent=`).
+ *  - T-C (2026-09-26, user ruling "strip off the per agent url path … no need
+ *    the url path fallback (we have git history)"): the per-label family is
+ *    RETIRED — `/hub` is the sole foreign entry and the only remaining
+ *    consumer of this kernel. The world DATA planes are untouched: the same
+ *    gateway faces (dispatchRpc/openWireStream), the same WorldMuxServer, the
+ *    same envelope, the same worldFetchHandlerOf lane, all reached through
+ *    `/hub`.
+ *  - T-D (2026-09-26, "disable their webui build"): the retired `mountWorld`
+ *    no-op and the mount HTML pass re-export left the module; the carrier is
+ *    the forwarding kernel alone.
+ *
+ * Nothing here reads a global: the addressed world travels with the request.
+ */
+import { EnvelopeError, parseClientRequest, serverError, serverResult, wireErrorOf, } from './envelope.js';
+import { stripLabelFromUrl } from './world-web-server.js';
+import { worldFetchHandlerOf } from './world-host.js';
+import { WorldMuxServer } from './world-mux.js';
+/** Default body cap, aligned with the connection service. */
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+async function readBody(req, limit) {
+    const carrier = req;
+    const chunks = [];
+    let size = 0;
+    if (typeof carrier[Symbol.asyncIterator] === 'function') {
+        for await (const chunk of carrier) {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+            size += buf.byteLength;
+            if (size > limit)
+                throw new EnvelopeError({ code: 'gateway/bad-request', message: 'request body too large' });
+            chunks.push(buf);
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    }
+    if (typeof carrier.on !== 'function')
+        return '';
+    return await new Promise((resolve, reject) => {
+        carrier.on?.('data', (chunk) => {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ''));
+            size += buf.byteLength;
+            if (size > limit) {
+                reject(new EnvelopeError({ code: 'gateway/bad-request', message: 'request body too large' }));
+                return;
+            }
+            chunks.push(buf);
+        });
+        carrier.on?.('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        carrier.on?.('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+    });
+}
+export function writeJson(res, status, body) {
+    const carrier = res;
+    carrier.writeHead?.(status, { 'content-type': 'application/json' });
+    res.end(body);
+}
+/** Write a plain-text answer (the shape upstream's own 404/413 answers use). */
+function writeText(res, status, body) {
+    const carrier = res;
+    carrier.writeHead?.(status, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end(body);
+}
+const forwardsFetchMethod = (req) => {
+    const method = req.method;
+    return method === 'GET' || method === 'HEAD';
+};
+/**
+ * Forward one non-envelope GET/HEAD request into the owning world's shared
+ * `/api` fetch handler (exact Fetch routes first, then the gateway's RPC
+ * interceptor, then 404 — the upstream composition). The caller has already
+ * answered the ctx0 fence by the time we get here; the world's own
+ * browser-auth gate is never consulted (a different tree, a different secret).
+ */
+export async function forwardWorldFetch(options, req, res) {
+    const worldFetch = worldFetchHandlerOf(options.label);
+    if (worldFetch === undefined) {
+        writeText(res, 404, 'not found');
+        return;
+    }
+    const method = (req.method ?? 'GET');
+    const resCarrier = res;
+    // Client-disconnect detection rides the response (same reason as the
+    // upstream node:http bridge: the request 'close' fires as soon as a
+    // bodyless GET is consumed).
+    const abort = new AbortController();
+    const onClose = () => {
+        if (resCarrier.writableEnded !== true)
+            abort.abort();
+    };
+    resCarrier.once?.('close', onClose);
+    let headersSent = false;
+    try {
+        const headers = {};
+        for (const [name, value] of Object.entries(req.headers ?? {})) {
+            if (typeof value === 'string')
+                headers[name.toLowerCase()] = value;
+        }
+        // The world route owns the world-relative URL: strip the mount prefix,
+        // keep the query (the session-export route reads it from searchParams).
+        const request = new Request(new URL(stripLabelFromUrl(req.url, options.mountPath), 'http://dsh.internal'), { method, headers, signal: abort.signal });
+        const response = await worldFetch.fetch(request);
+        res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+        headersSent = true;
+        if (response.body === null) {
+            res.end();
+            return;
+        }
+        for await (const chunk of response.body) {
+            // Backpressure: wait for drain instead of buffering unboundedly; a
+            // socket close resolves the wait and the aborted signal ends the stream.
+            if (resCarrier.write?.(chunk) === false && typeof resCarrier.once === 'function') {
+                await new Promise((resolve) => {
+                    const done = () => {
+                        resCarrier.off?.('drain', done);
+                        resCarrier.off?.('close', done);
+                        resolve();
+                    };
+                    resCarrier.once?.('drain', done);
+                    resCarrier.once?.('close', done);
+                });
+            }
+        }
+        res.end();
+    }
+    catch {
+        // The world route owns its statuses; only carrier-level faults land here.
+        if (!headersSent)
+            writeText(res, 500, 'carrier fetch bridge failure');
+        else
+            resCarrier.destroy?.();
+    }
+    finally {
+        resCarrier.off?.('close', onClose);
+    }
+}
+/**
+ * The reusable forwarding kernel (envelope dispatch + world fetch bridge):
+ * decode the connection envelope and dispatch into the ADDRESSED world's
+ * gateway instance; non-envelope GET/HEAD traffic forwards into the world's
+ * own registered fetch routes. Parameterized by (gateway, label, mountPath)
+ * so the `/hub` route family shares this exact behavior — the demux key is
+ * the caller's business, the wire semantics live here.
+ */
+export async function forwardApiCall(options, req, res) {
+    const maxBody = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+    const rejection = options.requestRejection?.(req);
+    if (rejection !== undefined) {
+        writeJson(res, rejection, JSON.stringify({ error: rejection === 401 ? 'unauthorized' : 'forbidden' }));
+        return;
+    }
+    let rpcId = 'invalid-request';
+    try {
+        const text = await readBody(req, maxBody);
+        let envelope;
+        try {
+            envelope = parseClientRequest(text);
+        }
+        catch (error) {
+            // Non-envelope GET/HEAD traffic on the shared mount prefix belongs to
+            // the world's own registered fetch routes; envelopes (and every other
+            // method) keep the transport-level 400 below.
+            if (error instanceof EnvelopeError && forwardsFetchMethod(req)) {
+                await forwardWorldFetch(options, req, res);
+                return;
+            }
+            throw error;
+        }
+        rpcId = envelope.rpcId;
+        const controller = new AbortController();
+        const result = await options.gateway.dispatchRpc(envelope.method, envelope.payload, controller.signal);
+        // The gateway already returns a Result (`{ok:true,value}` | `{ok:false,error}`),
+        // which is exactly the server-response's `result` field.
+        writeJson(res, 200, serverResult(rpcId, result));
+    }
+    catch (error) {
+        const wire = wireErrorOf(error);
+        // Envelope-level failures are transport-level 400s; dispatch failures are
+        // business results carried inside a 200 server-response (upstream shape).
+        if (error instanceof EnvelopeError) {
+            writeJson(res, 400, serverError(rpcId, wire));
+            return;
+        }
+        writeJson(res, 200, serverError(rpcId, wire));
+    }
+}
+/** One WorldMuxServer bound to `gateway` — the canonical openWireStream wiring in one place. */
+export function worldMuxOf(gateway, options) {
+    return new WorldMuxServer((endpoint, payload, uplink, control) => Promise.resolve(gateway.openWireStream(endpoint, payload, uplink, undefined, control.signal, control)), {
+        ...(options?.heartbeatIntervalMs === undefined ? {} : { heartbeatIntervalMs: options.heartbeatIntervalMs }),
+        ...(options?.failure === undefined ? {} : { failure: options.failure }),
+    });
+}
+/**
+ * RETIRED with T-D (2026-09-26): the T-C `mountWorld` no-op — which itself
+ * used to register `/<label>/api`, `/<label>/open-in-app` and
+ * `/<label>/api/remote.mux` on the real webServer — is GONE from the module.
+ * The adapter world-plugins' spawn-time call sites were updated in the same
+ * round (the registerHostMount record needs no webServer and no fence; the
+ * `/hub` family reaches each world's gateway through the foreign-target
+ * table). Git history keeps the function.
+ */
+// The carrier is now purely the forwarding kernel: no mount-time HTML pass,
+// no per-label registration — `/hub` (hub-route.ts) is the sole consumer.

package/superd-hub/dist/fusion-transport.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Fusion transport (native UI fusion, plan Task 3) — the ctx0 page-level head
+ * script plus its injection component.
+ *
+ * The script installs, BEFORE any application bundle materializes:
+ *   - the page-level state atom `__SUPERD_UI_STATE__`
+ *     ({ get activeAgent(): 'native'|string, setAgent(label), subscribe(fn) }),
+ *     initial `'native'`, never persisted (no localStorage);
+ *   - five CALL-TIME patches (the atom is read at request time, never baked
+ *     into a closure — after setAgent the same request expression retargets):
+ *       1. `globalThis.fetch` — while a FOREIGN agent is active, a same-origin
+ *          request whose path starts with `/api` is re-rooted under `/hub`
+ *          and gains exactly one `agent=<label>` param (a pre-existing agent
+ *          key is replaced, never duplicated — the server demuxes repeated
+ *          params to the FIRST value; other query bytes + hash preserved);
+ *       2. `WebSocket` / `EventSource` Proxy constructors + `XMLHttpRequest.open`
+ *          — the same rule (the mux WS lands on `/hub/api/remote.mux`);
+ *       3. `__DSH_FILE_UPLOAD__ = { fetch }` — uploads ride patch 1 (the
+ *          file-upload service reads the hook at construction, so the hook
+ *          must exist before app boot);
+ *       4. `HTMLAnchorElement.prototype.click` — ONLY download anchors with a
+ *          same-origin `/api` href rewrite (the narrow client-shim r2 rule);
+ *          the rewrite is transient — saved around the native click and
+ *          restored after, so an agent switch re-targets the same anchor;
+ *       5. `Storage.prototype` get/set/removeItem — namespace read at call
+ *          time: native = no prefix, foreign = `'<label>:'`.
+ *   - one control-plane exemption: `/api/agent-runtime` is NEVER rewritten —
+ *     the roster always talks to ctx0, so the user can always switch back.
+ * Native mode is zero-interference: every patched face passes its exact
+ * arguments through untouched.
+ *
+ * The component's gated listener ALSO bakes `__SUPERD_UI_FUSION__ = true`
+ * into the ctx0 index (Task 4): the client half's fusion-branch
+ * discriminator, emitted by the same gate as the script so the halves never
+ * disagree (world pages never carry it and keep real hyperlinks — spec §5).
+ *
+ * Quoting discipline: the generated script contains NO double-quoted string —
+ * index-pass rewrites every DOUBLE-quoted root-absolute literal in served
+ * HTML, so all literals stay single-quoted (the client-shim precedent). The
+ * install is idempotent (per-leg guards) and best-effort (every leg is
+ * individually guarded; a failure disables that leg only).
+ *
+ * Injection (the web-trust emission path, ordered AFTER it — spec §3.4 hard
+ * constraint): the row is a `webserver/index-inject` head script pushed by the
+ * `superd-fusion-transport` component, composed through the composite row
+ * `super-dsh/fusion-transport` positioned after `super-dsh/web-trust`. Both
+ * components defer their listener registration behind `inject(['webServer'])`,
+ * so cordis's FIFO effect order guarantees trust pushes first and fusion
+ * pushes last — the non-merging `if(!window.__DSH_TRANSPORT__)` verdict in the
+ * trust script is always evaluated before anything could own that global.
+ * Flag gate (minimal, Task 5 formalizes the config face): row config
+ * `enabled`, defaulting OFF from the `SUPERD_UI_FUSION` env — while the flag
+ * is off the component stays dormant and injects no row at all.
+ *
+ * @module @pgmi-builds/superd-hub/fusion-transport
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/**
+ * Render the page-level fusion transport as a classic script (head injection).
+ * Pure and constant: the active label is state, never a baked literal, so the
+ * script takes no arguments. All string literals are single-quoted (see the
+ * module doc block).
+ * @returns JavaScript source.
+ */
+export declare function renderFusionTransport(): string;
+/** The env name the minimal Task-3 gate reads; Task 5 builds the config face on it. */
+export declare const FUSION_FLAG_ENV = "SUPERD_UI_FUSION";
+/**
+ * The page global the ctx0 index carries when the gate is on: the client
+ * half's fusion-branch discriminator (the Hub UI switch surfaces read its
+ * presence to intercept agent clicks into the switch orchestration instead
+ * of letting the hyperlinks navigate — the sole switch surface since the T-B
+ * RuntimeSeat retirement; world pages never carry it, so they keep the real
+ * navigation half — spec §5 双半边). Baked by the SAME gated listener as the
+ * transport script, so the two halves can never disagree.
+ */
+export declare const FUSION_FLAG_GLOBAL = "__SUPERD_UI_FUSION__";
+/**
+ * The flag's SEMANTICS after the path-separation Part 2 closeout (T-C/T-D
+ * landed; this block is the T-E closeout record) — native-ui-only, there is
+ * no fallback route anywhere:
+ *
+ *   - ON: the ctx0 page fuses. The transport script arms the in-place switch
+ *     and `/hub` is the sole surface for every runtime. The per-label URL
+ *     family (`/<label>/` ctx0 pages, T-C) and the world web UIs (T-D) are
+ *     RETIRED from the product, not gated by this flag — there is nothing
+ *     navigational behind them to fall back to.
+ *   - OFF: NO foreign entry exists AT ALL. The served product is the bare
+ *     native UI plus the Hub panel as an information surface: the roster
+ *     still lists the runtimes (the control plane is not gated), but the
+ *     switch affordances render inert with the degradation hint
+ *     (`switchAffordance` in switch-core) instead of dead controls — a row
+ *     has no /<label>/ page to reach and the Hub UI ships no hrefs to reach
+ *     one with.
+ *
+ * The shipped default stays OFF (truthy env opt-in). Moving the default ON is
+ * the user's 放行 (acceptance/release) round — a two-gate decision per repo
+ * §〇.1, never a code-side choice.
+ *
+ * Derivation: truthy spellings only (`1` / `true` / `yes` / `on`,
+ * case-insensitive, trimmed). Anything else — unset included — is OFF.
+ */
+export declare function deriveFusionFlag(env: string | undefined): boolean;
+/** Row config schema face. */
+export interface FusionConfig {
+    /** Master gate: inject the transport script on ctx0's index. Default off. */
+    enabled?: boolean;
+}
+/** Row config (schema-level default derives from the {@link FUSION_FLAG_ENV} env). */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+}>>, "plain">;
+/** Cordis plugin name. */
+export declare const name = "superd-fusion-transport";
+/**
+ * No static injects: `webServer` is composed conditionally inside
+ * {@link apply}, so the row loads (dormant) in compositions without one.
+ */
+export declare const inject: string[];
+/**
+ * Mount the fusion injection: one `webserver/index-inject` listener pushing
+ * the rendered head script row — the same emission path as the web-trust
+ * component, composed AFTER it (the composite row order is load order, and
+ * both components register their listeners behind `inject(['webServer'])`, so
+ * cordis's FIFO effect order pushes the fusion row last; spec §3.4) — plus
+ * the {@link FUSION_FLAG_GLOBAL} baked global row (Task 4): one gate, both
+ * halves.
+ *
+ * Flag off → the component registers nothing: no listener, no row, no script,
+ * no flag global.
+ * @param ctx - host plugin context.
+ * @param config - the row config.
+ */
+export declare function apply(ctx: Context, config: FusionConfig | undefined): void;
+declare const _default: {
+    name: string;
+    inject: string[];
+    Config: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>, "plain">;
+    apply: typeof apply;
+};
+export default _default;