super-dsh 0.1.0 → 0.1.2

package/agent-hermes/dist/models.js

@@ -0,0 +1,324 @@
+/**
+ * Hermes model catalog for the Dash model selector (AW-H Task 5).
+ *
+ * Source of truth is the gateway `model.options` RPC (247ms-3.3s live — it
+ * probes providers), field-name authority = the Task 1 LIVE capture in
+ * `test/fixtures/gateway-rpc-samples.json`:
+ *
+ * - top level `{ providers: [<row>...], model: "<current default id>",
+ *   provider: "<current provider slug>" }` — the default lives in the top-level
+ *   strings, NOT inside the provider rows;
+ * - provider row `{ slug, name, is_current, is_user_defined,
+ *   models: [<plain id string>...], total_models, source, authenticated,
+ *   capabilities: {"<model-id>": {fast, reasoning, can_disable_reasoning}},
+ *   featured_models, aliases? }` — model entries are plain id strings, and the
+ *   current provider's row carries `is_current: true`.
+ *
+ * `id` is the verbatim selection string — directly consumable by
+ * `session.create {model}` and `command.dispatch "/model <id>"`. Capabilities
+ * carry no context-window hints (Task 1 §3⑦), so `contextWindow` is left unset
+ * rather than invented (Task 7's route metadata treats it as optional).
+ *
+ * Fail-soft everywhere: a missing client, a failing RPC, or a garbage response
+ * degrade to the empty catalog `{ provider: "Hermes", models: [],
+ * defaultModel: undefined }` — never a throw. `defaultModel: undefined` is the
+ * explicit skip signal so Task 7 never pushes a placeholder default outward
+ * (dev-rules: 占位值禁止外流).
+ *
+ * Trim rules (2026-09-17 parity ruling, recorded per dev-rules §12), applied
+ * at mapping time so every downstream consumer (per-slug routes, route
+ * pinning, the default-model push) sees the same trimmed projection:
+ *
+ * 1. `source: "virtual"` rows are dropped (the `moa` Mixture-of-Agents
+ *    synthesizer is not a selectable endpoint).
+ * 2. Mirrored endpoints whose model-id SETS are identical collapse onto one
+ *    row (e.g. `copilot` vs `copilot-acp`, `zai-plan` vs `zhipu`) — the first
+ *    row in gateway order wins, except a later mirrored row flagged
+ *    `is_current` displaces a non-current earlier one (the r4 dedupe
+ *    preference applied to whole rows). The id, not the endpoint, is the
+ *    selection contract, so a mirror is just a second name for the same ids.
+ * 3. Endpoints listing more than 50 models are reordered: `featured_models`
+ *    first (gateway order), then the remainder alphabetically. Small rows
+ *    keep the gateway's own order untouched.
+ *
+ * The `authenticated !== true` filter predates this ruling and is unchanged.
+ *
+ * Row `name`s survive in `HermesCatalog.providerNames` so the synchronous
+ * `providerInfo(slug)` surface can serve the gateway's human label; a
+ * module-level last-known cache (written on every successful fetch) keeps
+ * those names available before and between fetches, with a capitalized-slug
+ * fallback (`hermesProviderDisplayName`).
+ *
+ * Cache: the catalog is an async/expensive source, so reads go through a
+ * module-level in-process cache with a TTL (single-world posture — keyed on
+ * nothing, deliberately not on the client instance). Task 7's probe strategy
+ * (spawn a dedicated probe client → `model.options` → close it) therefore
+ * works: the first fetch populates the cache and later client-less calls are
+ * served from it until the TTL expires. Only non-empty successful catalogs are
+ * cached — failures and garbage are retried on the next call. Concurrent
+ * callers share one in-flight fetch (single-flight).
+ */
+/** Default cache TTL: 5 minutes. */
+export const HERMES_MODEL_CATALOG_DEFAULT_TTL_MS = 5 * 60_000;
+/** The fail-soft brand shown when the real provider slug is unavailable. */
+const FALLBACK_PROVIDER = "Hermes";
+/** A fresh empty catalog. Never shared — callers get their own object. */
+function emptyCatalog() {
+    return { provider: FALLBACK_PROVIDER, models: [], defaultModel: undefined, providerNames: {} };
+}
+/** True when the capability record says the model is fast. */
+function capFast(cap) {
+    return cap !== null && typeof cap === "object" && !Array.isArray(cap) && cap["fast"] === true;
+}
+/** True when the capability record says the model reasons. */
+function capReasoning(cap) {
+    return (cap !== null &&
+        typeof cap === "object" &&
+        !Array.isArray(cap) &&
+        cap["reasoning"] === true);
+}
+/** Label = the id plus capability hints when they are trivially available. */
+function labelFor(id, cap) {
+    const hints = [];
+    if (capFast(cap))
+        hints.push("fast");
+    if (capReasoning(cap))
+        hints.push("reasoning");
+    return hints.length === 0 ? id : `${id} (${hints.join(", ")})`;
+}
+/** Endpoints with more models than this are reordered featured-first (trim 3). */
+export const HERMES_FEATURED_REORDER_MIN_MODELS = 50;
+/** The row's model ids, strings only, gateway order preserved. */
+function sanitizeIds(models) {
+    return models.filter((id) => typeof id === "string" && id !== "");
+}
+/**
+ * Trim 3: for large endpoints (> {@link HERMES_FEATURED_REORDER_MIN_MODELS}
+ * models) put the gateway's `featured_models` first (their own order), then
+ * the remaining ids alphabetically. Smaller rows keep gateway order.
+ */
+function orderFeaturedFirst(ids, featured) {
+    if (ids.length <= HERMES_FEATURED_REORDER_MIN_MODELS || !Array.isArray(featured))
+        return ids;
+    const featuredIds = featured.filter((id) => typeof id === "string" && id !== "" && ids.includes(id));
+    const seen = new Set(featuredIds);
+    const rest = ids.filter((id) => !seen.has(id)).sort((a, b) => a.localeCompare(b));
+    return [...featuredIds, ...rest];
+}
+/**
+ * Validate one provider row against the servability filter and the trims.
+ * Returns `undefined` when the row is dropped: malformed, unauthenticated,
+ * `source: "virtual"` (trim 1). Mirror collapse (trim 2) happens AFTER this
+ * per-row preparation — it needs each candidate's id set, and the winner is
+ * chosen at the group level in mapHermesModelOptions.
+ */
+function prepareRow(row) {
+    if (row === null || typeof row !== "object" || Array.isArray(row))
+        return undefined;
+    const raw = row;
+    const slug = raw["slug"];
+    if (typeof slug !== "string" || slug === "")
+        return undefined;
+    if (raw["source"] === "virtual")
+        return undefined; // trim 1: virtual synthesizers are not selectable
+    const authenticated = raw["authenticated"];
+    const isCurrent = raw["is_current"] === true;
+    if (authenticated !== true && !(isCurrent && authenticated === undefined))
+        return;
+    const models = raw["models"];
+    if (!Array.isArray(models))
+        return undefined;
+    const ids = orderFeaturedFirst(sanitizeIds(models), raw["featured_models"]);
+    if (ids.length === 0)
+        return undefined;
+    const name = raw["name"];
+    const capabilities = raw["capabilities"];
+    return {
+        slug,
+        name: typeof name === "string" && name !== "" ? name : undefined,
+        isCurrent,
+        caps: capabilities !== null && typeof capabilities === "object" && !Array.isArray(capabilities)
+            ? capabilities
+            : undefined,
+        ids,
+        mirrorKey: [...ids].sort().join("\u0000"),
+    };
+}
+/**
+ * Append one prepared row's entries onto `out`.
+ *
+ * Dedupe (r4, unchanged): the id is the VERBATIM gateway selection string
+ * (`session.create {model}` / `/model <id>` consume it as-is) — never
+ * provider-prefixed — so the same id listed under several slugs collapses
+ * onto ONE canonical entry, preferring the `is_current` row, else the first
+ * surviving row in the gateway's own order. The `seen` map records each id's
+ * emitted index + whether its source was current, so a current-row duplicate
+ * REPLACES an earlier non-current entry in place (order preserved).
+ */
+function appendPrepared(prepared, out, seen) {
+    for (const id of prepared.ids) {
+        const entry = {
+            id,
+            label: labelFor(id, prepared.caps === undefined ? undefined : prepared.caps[id]),
+            provider: prepared.slug,
+            // contextWindow intentionally never set: the gateway's capability hints
+            // carry no context windows (Task 1 §3⑦) — values would be invented.
+        };
+        const existing = seen.get(id);
+        if (existing === undefined) {
+            seen.set(id, { index: out.length, isCurrent: prepared.isCurrent });
+            out.push(entry);
+        }
+        else if (prepared.isCurrent && !existing.isCurrent) {
+            // current-provider row wins the duplicate — replace in place (order preserved)
+            out[existing.index] = entry;
+            seen.set(id, { index: existing.index, isCurrent: true });
+        }
+        // else: later duplicate from a non-current (or already-current) row → dropped.
+    }
+}
+/**
+ * Pure mapping from a `model.options` response to the catalog. Total and
+ * fail-soft: any shape degrades toward the empty catalog, never throws.
+ * Exported so tests (and Task 7, if it ever holds a raw response) can map
+ * without touching the cache.
+ */
+export function mapHermesModelOptions(response) {
+    if (response === null || typeof response !== "object" || Array.isArray(response))
+        return emptyCatalog();
+    const raw = response;
+    const entries = [];
+    const seen = new Map();
+    const providerNames = {};
+    const providers = raw["providers"];
+    if (Array.isArray(providers)) {
+        // Trim 2 (mirror collapse): group prepared rows by their id SET; the
+        // first row of each group survives in gateway order, unless a later
+        // mirrored row is `is_current` and displaces a non-current winner.
+        const byMirrorKey = new Map();
+        const ordered = [];
+        for (const candidate of providers) {
+            const prepared = prepareRow(candidate);
+            if (prepared === undefined)
+                continue;
+            const existing = byMirrorKey.get(prepared.mirrorKey);
+            if (existing === undefined) {
+                byMirrorKey.set(prepared.mirrorKey, prepared);
+                ordered.push(prepared);
+            }
+            else if (prepared.isCurrent && !existing.isCurrent) {
+                ordered.splice(ordered.indexOf(existing), 1, prepared);
+                byMirrorKey.set(prepared.mirrorKey, prepared);
+            }
+        }
+        for (const prepared of ordered) {
+            appendPrepared(prepared, entries, seen);
+            if (prepared.name !== undefined)
+                providerNames[prepared.slug] = prepared.name;
+        }
+    }
+    const model = raw["model"];
+    const provider = raw["provider"];
+    return {
+        provider: typeof provider === "string" && provider !== "" ? provider : FALLBACK_PROVIDER,
+        models: entries,
+        defaultModel: typeof model === "string" && model !== "" ? model : undefined,
+        providerNames,
+    };
+}
+let cached = null;
+let inflight = null;
+/** Test seam (the codex `setCodexFactory` pattern): drop the cached catalog and any in-flight fetch. */
+export function resetHermesModelCatalogCache() {
+    cached = null;
+    inflight = null;
+    resetHermesProviderInfoCache();
+}
+/**
+ * Last-known provider display names (module-level, single-world posture):
+ * every successful non-empty fetch rewrites this, so the SYNCHRONOUS
+ * `providerInfo(slug)` surface can serve the gateway's human row names
+ * before and between async fetches (the catalog itself is only reachable
+ * through an await). `hermesProviderDisplayName` falls back to the
+ * capitalized slug before the first fetch or for slugs the gateway never
+ * named.
+ */
+let lastKnownProviderNames = {};
+/**
+ * Human display name for a provider slug: the last-known gateway row name
+ * when one was fetched, else the capitalized slug (`openrouter` →
+ * `Openrouter`). Synchronous by contract (`LlmAdapter.providerInfo`).
+ */
+export function hermesProviderDisplayName(slug) {
+    const known = lastKnownProviderNames[slug];
+    if (typeof known === "string" && known !== "")
+        return known;
+    return slug === "" ? FALLBACK_PROVIDER : slug.charAt(0).toUpperCase() + slug.slice(1);
+}
+/** Test seam: drop the last-known provider display names. */
+export function resetHermesProviderInfoCache() {
+    lastKnownProviderNames = {};
+}
+/** Learn the fetched catalog's row names (successful non-empty fetches only). */
+function rememberProviderNames(catalog) {
+    if (Object.keys(catalog.providerNames).length > 0)
+        lastKnownProviderNames = catalog.providerNames;
+}
+/**
+ * The distinct provider slugs of a catalog, gateway row order preserved —
+ * the `handle.replace` route set for the per-slug registration (2026-09-17
+ * parity ruling). Order is the gateway's own, so the selector lists groups
+ * the way the gateway ranks them.
+ */
+export function hermesProviderSlugs(catalog) {
+    const seen = new Set();
+    const slugs = [];
+    for (const entry of catalog.models) {
+        if (seen.has(entry.provider))
+            continue;
+        seen.add(entry.provider);
+        slugs.push(entry.provider);
+    }
+    return slugs;
+}
+/**
+ * Read the Hermes model catalog (async — the source is a gateway RPC).
+ *
+ * - fresh cache → served, even when `client` is omitted (the Task 7
+ *   probe-client-then-close pattern);
+ * - otherwise `client.modelOptions()` is fetched (single-flight; concurrent
+ *   callers share one RPC) and mapped; a non-empty success populates the
+ *   cache for `ttlMs` (default 5 min);
+ * - missing client / failing RPC / garbage response → the empty catalog
+ * (`defaultModel: undefined` = the placeholder-skip signal). Never throws.
+ */
+export async function readHermesModelCatalog(client, options) {
+    const ttlMs = options?.ttlMs ?? HERMES_MODEL_CATALOG_DEFAULT_TTL_MS;
+    const useCache = ttlMs > 0;
+    if (useCache && cached !== null && cached.expiresAt > Date.now())
+        return cached.value;
+    if (client === undefined)
+        return emptyCatalog();
+    if (inflight !== null)
+        return inflight;
+    const fetch = (async () => {
+        try {
+            const response = await client.modelOptions();
+            const catalog = mapHermesModelOptions(response);
+            if (catalog.models.length > 0)
+                rememberProviderNames(catalog); // learn row names even when the TTL cache is bypassed
+            if (useCache && catalog.models.length > 0) {
+                cached = { value: catalog, expiresAt: Date.now() + ttlMs };
+            }
+            return catalog;
+        }
+        catch {
+            return emptyCatalog(); // fail-soft; failures are never cached
+        }
+        finally {
+            inflight = null;
+        }
+    })();
+    inflight = fetch;
+    return fetch;
+}

package/agent-hermes/dist/permission.js

@@ -0,0 +1,60 @@
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+const PRESETS = {
+    "danger-full-access": true,
+    "workspace-write": true,
+    "read-only": true,
+};
+/** Narrow an untrusted value to a known preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESETS, raw);
+}
+/**
+ * `HERMES_APPROVAL_MODE` when it names a Dash permission preset, else
+ * undefined. Record-only (no launch flag exists on the runtime-approval line);
+ * an invalid value is IGNORED.
+ */
+export function envApprovalMode() {
+    const raw = process.env.HERMES_APPROVAL_MODE;
+    return raw !== undefined && isPresetName(raw) ? raw : undefined;
+}
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails.
+ */
+export function defaultPermissionPreset(ctx) {
+    const service = ctx.get("permissionPresets");
+    if (service === undefined)
+        return undefined;
+    try {
+        const preset = service.defaultPreset;
+        return isPresetName(preset) ? preset : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The session's effective preset: the last `permission/preset` event. */
+export function presetFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === "permission/preset" && isPresetName(event.data?.preset))
+            return event.data.preset;
+    }
+    return undefined;
+}
+/**
+ * Map a Dash approval outcome onto the gateway's `approval.respond` choice.
+ * Pure: no service, no I/O. `allowed-once` grants exactly one run; an
+ * `allowed-always` grant maps to `"always"` ONLY when the pending approval
+ * offered that choice (`options` = the gateway's `choices` array); any other
+ * outcome — rejected / cancelled / unavailable / an unknown value — fails
+ * closed to `"deny"`.
+ */
+export function approvalChoiceFromOutcome(outcome, options) {
+    if (outcome === "allowed-once")
+        return "once";
+    if (outcome === "allowed-always" && options !== undefined && options.includes("always"))
+        return "always";
+    return "deny";
+}

package/agent-hermes/dist/world-plugin.js

@@ -0,0 +1,101 @@
+/**
+ * aw.agent-adapter-hermes — the Hermes adapter's WORLD plugin (spec S2):
+ * activation IS roster membership.
+ *
+ * AW-B URL scheme (DL1–DL5), mirroring `@pgmi-builds/agent-adapter-omp/world`
+ * and `@pgmi-builds/agent-adapter-codex/world` so the hub sees every foreign
+ * runtime through one shape: the world is spawned as a sibling ROOT context
+ * with NO listener (`worldMountPatches`) and mounts itself under `/hermes`
+ * through the hub —
+ *
+ *   1. ctx0 publishes the host mount (real webServer instance) before spawn;
+ *   2. the world's entry row provides the virtual `webServer` in the world
+ *      root, translating every route its plugins declare into `/hermes+path`;
+ *   3. the hub's carrier answers `/hermes/api` + `/hermes/api/remote.mux` in
+ *      ctx0's auth domain and dispatches into this world's gateway instance.
+ */
+import { mkdirSync } from 'node:fs';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { join } from 'node:path';
+import { spawnWorld, registerAgent, setReady, registerForeignTarget, registerHostMount, mountWorld, worldMountPatches, provisionWorldProfile, } from '../../agent-hub/dist/index.js';
+export const name = 'aw.agent-adapter-hermes';
+/** Runtime key — also the mount label. */
+const KEY = 'hermes';
+const ANCHOR = process.env.SUPERD_DSH_ANCHOR
+    ?? '/home/u1/.local/lib/node_modules/@deepseek-ai/dsh/package.json';
+export function apply(ctx) {
+    registerAgent({ key: KEY, label: 'Hermes', ready: false });
+    // 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();
+    // S7 nested home: every runtime owns one root under `agents/<label>`; this
+    // directory is the WORLD's DSH home (spawnWorld home/dataHome) — DSH-side
+    // world data (sessions / settings / workspaces) and the adapter's identity
+    // map (dsh-sessions.json) live here. It is NOT hermes data: the hermes
+    // runtime keeps its native `~/.hermes`, and the gateway child env must
+    // never set HERMES_HOME (Task 3's client's concern — this world spawns no
+    // hermes processes itself).
+    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: KEY,
+        adapterPkg: '@pgmi-builds/agent-adapter-hermes',
+        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: 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.
+            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: KEY, gateway });
+        const mounted = mountWorld({
+            real,
+            label: KEY,
+            gateway,
+            requestRejection: (request) => connection
+                .requestRejection(request),
+        });
+        setReady(KEY, true);
+        ctx.effect?.(() => () => {
+            mounted.dispose();
+            dropHostMount();
+        }, `aw.agent-adapter-${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);
+}

package/agent-hermes/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@pgmi-builds/agent-adapter-hermes",
+  "version": "0.1.0",
+  "description": "Hermes provider for DeepSeek Harness (dsh) — an AgentFactory that embeds Nous Research Hermes Agent via the TUI gateway JSON-RPC (python -m tui_gateway.entry) and bridges its session surface into Dash Agent/Session contracts (Agent Worlds AW-H).",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./world": "./dist/world-plugin.js"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@pgmi-builds/agent-hub": "file:../agent-hub",
+    "zod": "3.25.76"
+  },
+  "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-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"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent-presets": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-scope": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=22.18"
+  }
+}

package/agent-hub/cordis.patch.yml

@@ -0,0 +1,12 @@
+# Mount the agent-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
+# @deepseek-ai/dsh-api-gateway/client). This plugin wraps the live
+# typertGateway service's dispatchRpc instead — selector=native → upstream
+# dispatch; selector=foreign → wire-forward to that context's own /api.
+# The /api/agent-runtime selector RPC face rides along (control plane,
+# always CTX0-local).
+- insert:
+    - id: agent-hub
+      name: '@pgmi-builds/agent-hub'

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

@@ -0,0 +1,34 @@
+/**
+ * The hub's own agent roster row (AW-B, URL scheme).
+ *
+ * The selector is pure navigation: every runtime owns a mount path, so the UI
+ * needs exactly one fact — which paths exist — and nothing else. The hub bakes
+ * that fact into every page it can reach (ctx0's index and every mounted
+ * world's index), so no world implements any selector code and no server-side
+ * selection value exists anywhere.
+ *
+ *   /          → native DSH
+ *   /omp/      → the OMP world's mount
+ *   /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. */
+export interface AgentLink {
+    /** `native` for ctx0, otherwise the adapter's runtime key. */
+    key: string;
+    /** Chip/menu label (`DSH`, `OMP`, `Codex`, …). */
+    label: string;
+    /** Mount root, always trailing-slashed except the native `/`. */
+    path: string;
+}
+/** The global this module publishes the roster under. */
+export declare const AGENT_ROSTER_GLOBAL = "__DSH_AGENT_ROSTER__";
+/**
+ * Every runtime that currently owns a mount, native first.
+ *
+ * A registered agent without a host mount has no addressable path yet (its
+ * world is still spawning) and is therefore not selectable.
+ */
+export declare function agentLinks(): AgentLink[];
+/** The structured index row that publishes {@link agentLinks} to the page. */
+export declare function agentRosterRow(): IndexInjection;

package/agent-hub/dist/agent-roster.js

@@ -0,0 +1,27 @@
+import { listAgents } from './roster.js';
+import { takeHostMount } from './world-host.js';
+/** The native runtime's synthetic entry (no adapter plugin backs it). */
+const NATIVE = { key: 'native', label: 'DSH', path: '/' };
+/** The global this module publishes the roster under. */
+export const AGENT_ROSTER_GLOBAL = '__DSH_AGENT_ROSTER__';
+/**
+ * Every runtime that currently owns a mount, native first.
+ *
+ * A registered agent without a host mount has no addressable path yet (its
+ * world is still spawning) and is therefore not selectable.
+ */
+export function agentLinks() {
+    const links = [NATIVE];
+    for (const agent of listAgents()) {
+        const mount = takeHostMount(agent.key);
+        if (mount === undefined)
+            continue;
+        const path = mount.labelPath.endsWith('/') ? mount.labelPath : `${mount.labelPath}/`;
+        links.push({ key: agent.key, label: agent.label, path });
+    }
+    return links;
+}
+/** The structured index row that publishes {@link agentLinks} to the page. */
+export function agentRosterRow() {
+    return { kind: 'global', name: AGENT_ROSTER_GLOBAL, value: { agents: agentLinks() } };
+}