super-dsh 0.1.5 → 0.1.6

package/superd-hub/dist/labels.js

@@ -0,0 +1,83 @@
+/**
+ * Label table (AW-B DL2/DL4): one world ↔ one mount path under the ctx0 origin.
+ *
+ * The addressed world is the request's path (`/<label>/...`), so the label is
+ * the ONLY routing key. Reserving it must be atomic against the real
+ * webServer's duplicate-registration throw — that throw is the only collision
+ * signal the framework offers (the route tables are private and there is no
+ * query API), so it is used here as the probe.
+ *
+ * A collision is a composition-level conflict and must be loud; an optional
+ * alternate root lets a deployment re-home instead of failing to boot.
+ */
+const claims = new Map();
+function isRecordLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Reject keys that cannot be a single path segment. */
+function assertKey(key) {
+    if (typeof key !== 'string' || key === '' || key.includes('/') || key.includes('?')) {
+        throw new Error(`labels: invalid label key ${JSON.stringify(key)} (one non-empty path segment required)`);
+    }
+}
+function joinRoot(root, key) {
+    const trimmed = root.replace(/\/+$/, '');
+    return trimmed === '' ? `/${key}` : `${trimmed}/${key}`;
+}
+/**
+ * Reserve the mount path for `key`.
+ * @param key - runtime key (one path segment).
+ * @param opts - registration probe plus optional roots.
+ * @returns the live claim.
+ */
+export function claimLabel(key, opts) {
+    assertKey(key);
+    const existing = claims.get(key);
+    if (existing !== undefined) {
+        throw new Error(`labels: key ${JSON.stringify(key)} already claimed at "${existing.path}"`);
+    }
+    const roots = [opts.root ?? '', ...(opts.alternateRoots ?? [])];
+    const tried = [];
+    for (const root of roots) {
+        const path = joinRoot(root, key);
+        if (tried.includes(path))
+            continue;
+        tried.push(path);
+        let dispose;
+        try {
+            dispose = opts.register(path);
+        }
+        catch {
+            continue;
+        }
+        const claim = {
+            key,
+            path,
+            release: () => {
+                if (claims.get(key)?.path !== path)
+                    return;
+                claims.delete(key);
+                dispose?.();
+            },
+        };
+        claims.set(key, claim);
+        return claim;
+    }
+    throw new Error(`labels: no free mount path for ${JSON.stringify(key)} (tried ${tried.map(p => `"${p}"`).join(', ')})`);
+}
+/** The reserved mount root for a key, or undefined when unclaimed. */
+export function labelOf(key) {
+    return claims.get(key)?.path;
+}
+/** Release a key's claim; unknown keys are a no-op. */
+export function releaseLabel(key) {
+    claims.get(key)?.release();
+}
+/** Claimed keys, registration order. */
+export function listLabels() {
+    return [...claims.keys()];
+}
+/** Test/introspection helper: is this object a claim? */
+export function isLabelClaim(value) {
+    return isRecordLike(value) && typeof value['key'] === 'string' && typeof value['path'] === 'string';
+}

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

@@ -15,6 +15,8 @@ export interface RosterEntry {
     label: string;
     /** True once the adapter's world context is spawned and its target registered. */
     ready: boolean;
+    /** True once the world's spawn REJECTED (world-join catch) — stays mounted for diagnosis. */
+    failed?: boolean;
 }
 /** Register an agent. Duplicate keys are a plugin bug — throw loud. */
 export declare function registerAgent(entry: RosterEntry): void;
@@ -22,6 +24,8 @@ export declare function registerAgent(entry: RosterEntry): void;
 export declare function unregisterAgent(key: string): void;
 /** Flip readiness (world spawned / disposed). Unknown keys are a plugin bug. */
 export declare function setReady(key: string, ready: boolean): void;
+/** Flip failure (world spawn rejected). Unknown keys are a plugin bug. */
+export declare function setFailed(key: string, failed: boolean): void;
 /** Snapshot copy — callers can hold it without aliasing the roster. */
 export declare function listAgents(): RosterEntry[];
 /** Subscribe to roster changes; returns an unsubscribe function. */

package/superd-hub/dist/roster.js

@@ -9,7 +9,7 @@ function emit() {
 export function registerAgent(entry) {
     if (entries.has(entry.key))
         throw new Error(`roster: duplicate agent key ${entry.key}`);
-    entries.set(entry.key, { ...entry });
+    entries.set(entry.key, { ...entry, failed: entry.failed ?? false });
     emit();
 }
 /** Drop an agent (adapter plugin disposed). */
@@ -25,6 +25,14 @@ export function setReady(key, ready) {
     e.ready = ready;
     emit();
 }
+/** Flip failure (world spawn rejected). Unknown keys are a plugin bug. */
+export function setFailed(key, failed) {
+    const e = entries.get(key);
+    if (!e)
+        throw new Error(`roster: unknown agent ${key}`);
+    e.failed = failed;
+    emit();
+}
 /** Snapshot copy — callers can hold it without aliasing the roster. */
 export function listAgents() {
     return [...entries.values()].map((e) => ({ ...e }));

package/superd-hub/dist/switch-core.d.ts

@@ -628,3 +628,43 @@ export interface SwitchController {
  * switch's pointer-restored view).
  */
 export declare function createSwitchController(host: SwitchHost, options?: SwitchOptions): SwitchController;
+/** What attemptSwitch does with a roster row: run the machine / report failure / wait for readiness. */
+export type PreFlightDecision = 'run' | 'failed' | 'wait';
+/** The roster fields the pre-flight reads (the projection carries both since C1 task 3). */
+export interface PreFlightRow {
+    ready?: boolean;
+    failed?: boolean;
+}
+/**
+ * The pure pre-flight decision. `native` always runs; an absent row (roster
+ * fetch failed, or the key is not listed) also runs — the machine's roster
+ * probe is the authority on unknown targets, exactly as before C1.
+ */
+export declare function decidePreFlight(label: string, row: PreFlightRow | undefined): PreFlightDecision;
+/** Default bound on one readiness wait (the page never locks behind a stuck world). */
+export declare const WAIT_BOUND_MS = 120000;
+/** Default poll interval for one readiness wait. */
+export declare const WAIT_POLL_MS = 1000;
+/** The waiter's injected faces (tests drive time and the roster by hand). */
+export interface ReadinessWaiterFaces {
+    /** Read the target's roster row; undefined on any failure. */
+    fetchRow(): Promise<PreFlightRow | undefined>;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+/** One bounded readiness wait. */
+export interface ReadinessWaiter {
+    /** Resolves when the row flips ready ('ready'), reports failure ('failed'), the bound expires ('bound'), or the waiter is cancelled ('cancelled'). */
+    wait(label: string): Promise<'ready' | 'failed' | 'bound' | 'cancelled'>;
+    /** A newer switch attempt cancels a pending wait (it resolves 'cancelled'). */
+    cancel(): void;
+}
+/**
+ * Build a bounded readiness waiter over injected faces. The poll re-reads
+ * the roster row every {@link ReadinessWaiterOptions.pollMs}; `failed`
+ * short-circuits immediately; the bound always terminates the wait.
+ */
+export declare function createReadinessWaiter(faces: ReadinessWaiterFaces, options?: {
+    boundMs?: number;
+    pollMs?: number;
+}): ReadinessWaiter;

package/superd-hub/dist/switch-core.js

@@ -732,3 +732,75 @@ export function createSwitchController(host, options = {}) {
         },
     };
 }
+/**
+ * The pure pre-flight decision. `native` always runs; an absent row (roster
+ * fetch failed, or the key is not listed) also runs — the machine's roster
+ * probe is the authority on unknown targets, exactly as before C1.
+ */
+export function decidePreFlight(label, row) {
+    if (label === NATIVE_AGENT)
+        return 'run';
+    if (row === undefined)
+        return 'run';
+    if (row.failed === true)
+        return 'failed';
+    if (row.ready !== true)
+        return 'wait';
+    return 'run';
+}
+/** Default bound on one readiness wait (the page never locks behind a stuck world). */
+export const WAIT_BOUND_MS = 120_000;
+/** Default poll interval for one readiness wait. */
+export const WAIT_POLL_MS = 1_000;
+/**
+ * Build a bounded readiness waiter over injected faces. The poll re-reads
+ * the roster row every {@link ReadinessWaiterOptions.pollMs}; `failed`
+ * short-circuits immediately; the bound always terminates the wait.
+ */
+export function createReadinessWaiter(faces, options = {}) {
+    const boundMs = options.boundMs ?? WAIT_BOUND_MS;
+    const pollMs = options.pollMs ?? WAIT_POLL_MS;
+    let pending;
+    let pollHandle;
+    let boundHandle;
+    let settled = false;
+    const settle = (outcome) => {
+        if (settled)
+            return;
+        settled = true;
+        if (pollHandle !== undefined)
+            faces.clearTimeout(pollHandle);
+        if (boundHandle !== undefined)
+            faces.clearTimeout(boundHandle);
+        pending?.(outcome);
+        pending = undefined;
+    };
+    return {
+        wait(label) {
+            return new Promise((resolve) => {
+                pending = resolve;
+                boundHandle = faces.setTimeout(() => { settle('bound'); }, boundMs);
+                const tick = () => {
+                    if (settled)
+                        return;
+                    void faces.fetchRow().then((row) => {
+                        if (settled)
+                            return;
+                        if (row?.failed === true) {
+                            settle('failed');
+                            return;
+                        }
+                        if (row?.ready === true) {
+                            settle('ready');
+                            return;
+                        }
+                        pollHandle = faces.setTimeout(tick, pollMs);
+                    }, () => { if (!settled)
+                        pollHandle = faces.setTimeout(tick, pollMs); });
+                };
+                tick();
+            });
+        },
+        cancel() { settle('cancelled'); },
+    };
+}

package/superd-hub/dist/toast-core.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Toast feedback core (C1 task 4) — the pure, host-half half of the
+ * official-primitive toast: the props seam and the module store. The React
+ * wrapper (the always-mounted host component + element factory) lives in
+ * `src/client/toast.ts`; this split mirrors switch-core (pure logic where
+ * tsc emits and node tests import; the DOM/React face is injected by the
+ * client lane).
+ *
+ * The toast copy rides the platform's `Toast` primitive — top-center
+ * banner, dark surface in both themes, warn-orange icon seat, green
+ * `tone="success"` — rendered by the HOST's React tree through the
+ * primitive's own body portal. Failure notices hold ~6 s: the primitive's
+ * docblock prescribes longer holds for failures that name what broke.
+ *
+ * @module superd-hub/toast-core
+ */
+/** Options: the toast tone and hold window. */
+export interface SuperdToastOptions {
+    /** `'success'` renders the primitive's green check glyph. */
+    tone?: 'success';
+    /** Full-opacity hold before the fade; defaults to {@link TOAST_DEFAULT_HOLD_MS}. */
+    holdMs?: number;
+}
+/** Failures that name what broke need a longer read than a one-liner. */
+export declare const TOAST_DEFAULT_HOLD_MS = 6000;
+/** One pending toast: a monotonic sequence plus its resolved copy. */
+export interface PendingSuperdToast {
+    readonly seq: number;
+    readonly text: string;
+    readonly options: SuperdToastOptions;
+}
+/** The exact props the official primitive receives (pure — the unit seam). */
+export declare function toastProps(text: string, options?: SuperdToastOptions): {
+    text: string;
+    tone?: 'success';
+    holdMs: number;
+};
+/** Fire one toast (best-effort: without a mounted owner nothing renders). */
+export declare function showSuperdToast(text: string, options?: SuperdToastOptions): void;
+/** Clear a shown toast (the fade's `onDone`); stale sequences are no-ops. */
+export declare function clearSuperdToast(done: number): void;
+/** Subscribe to the store (the host's effect face); returns unsubscribe. */
+export declare function onSuperdToast(fn: (toast: PendingSuperdToast | undefined) => void): () => void;

package/superd-hub/dist/toast-core.js

@@ -0,0 +1,63 @@
+/**
+ * Toast feedback core (C1 task 4) — the pure, host-half half of the
+ * official-primitive toast: the props seam and the module store. The React
+ * wrapper (the always-mounted host component + element factory) lives in
+ * `src/client/toast.ts`; this split mirrors switch-core (pure logic where
+ * tsc emits and node tests import; the DOM/React face is injected by the
+ * client lane).
+ *
+ * The toast copy rides the platform's `Toast` primitive — top-center
+ * banner, dark surface in both themes, warn-orange icon seat, green
+ * `tone="success"` — rendered by the HOST's React tree through the
+ * primitive's own body portal. Failure notices hold ~6 s: the primitive's
+ * docblock prescribes longer holds for failures that name what broke.
+ *
+ * @module superd-hub/toast-core
+ */
+/** Failures that name what broke need a longer read than a one-liner. */
+export const TOAST_DEFAULT_HOLD_MS = 6_000;
+/** The exact props the official primitive receives (pure — the unit seam). */
+export function toastProps(text, options = {}) {
+    const props = {
+        text,
+        holdMs: options.holdMs ?? TOAST_DEFAULT_HOLD_MS,
+    };
+    if (options.tone !== undefined)
+        props.tone = options.tone;
+    return props;
+}
+// ---- the module store (last-wins; transient notices never queue) ----------
+let seq = 0;
+let current;
+const listeners = new Set();
+function emit() {
+    for (const fn of [...listeners]) {
+        try {
+            fn(current);
+        }
+        catch { /* a broken listener never breaks the store */ }
+    }
+}
+/** Fire one toast (best-effort: without a mounted owner nothing renders). */
+export function showSuperdToast(text, options = {}) {
+    current = { seq: ++seq, text, options };
+    emit();
+}
+/** Clear a shown toast (the fade's `onDone`); stale sequences are no-ops. */
+export function clearSuperdToast(done) {
+    if (current === undefined || current.seq !== done)
+        return;
+    current = undefined;
+    emit();
+}
+/** Subscribe to the store (the host's effect face); returns unsubscribe. */
+export function onSuperdToast(fn) {
+    listeners.add(fn);
+    // Initial push: an owner mounting after a toast fired still shows it
+    // (the host's effect subscribes post-mount).
+    try {
+        fn(current);
+    }
+    catch { /* a broken listener never breaks the store */ }
+    return () => { listeners.delete(fn); };
+}

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

@@ -32,7 +32,7 @@
 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 { registerAgent, setFailed, setReady } from './roster.js';
 import { registerForeignTarget } from './targets.js';
 import { spawnWorld } from './spawn-world.js';
 import { provisionWorldProfile, resolveInstallAnchor } from './world-provision.js';
@@ -92,9 +92,14 @@ export function apply(ctx, config) {
         }, `superd-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).
+        // A failed world degrades to a FAILED roster row (mount stays for
+        // diagnosis; ready stays false); a rejected provided promise would fail
+        // the entire host boot (loader entry apply).
         console.error(`[super-dsh] ${key} world failed:`, cause);
+        try {
+            setFailed(key, true);
+        }
+        catch { /* roster row already gone */ }
         return null;
     });
     ctx.provide(`superd.world.${key}`, world);

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

@@ -79,4 +79,31 @@ export type WorldPatchLayer = {
  * @param key - runtime key (`omp`, `codex`, …) — the mount label.
  * @returns patch layers to append to the world's composition.
  */
+/**
+ * Wave-1 of world composition minimization (spec
+ * docs/specs/world-composition-minimization): native-agent machinery the
+ * foreign runtimes replace. Dependency-cleared 2026-09-27 against the KEEP
+ * set (api controllers, session core, adapters' agents/sessions/llm/
+ * agentDefaultModel/settings/agentPresets). Wave-2 candidates (client-ui
+ * family, tools, bash-sandbox, terminal-controller, …) live in the spec,
+ * NOT here.
+ */
+export declare const WORLD_WAVE1_DISABLED_ROWS: readonly string[];
+/**
+ * Wave-2 of world composition minimization: the CLIENT lane. The
+ * multi-ctx-multi-ui → native-ui-only transition (0.1.5 / T-D) retired the
+ * world's own web UI (webserver/hmr/web-runtime/client-hmr above); wave-2
+ * completes it by stripping the browser-half rows of the web-app bundle —
+ * every dsh-client-* row plus the cordis client runner. In a world these
+ * only registered modules into a table no browser ever reads.
+ *
+ * Dependency-cleared 2026-09-27: the KEEP side (api controllers, gateway,
+ * session core, adapters) injects none of their services with ONE
+ * exceptions — `connection` (dsh-client-connection: the world's typert
+ * gateway injects it) and `modules` (dsh-client-modules: its activation
+ * work fails in world trees ("client bundles not found") and at least one
+ * fiber treats it as required — the load-bearing parking restatement
+ * `inject: [webServer]` keeps it waiting forever, superseding a disable).
+ */
+export declare const WORLD_WAVE2_DISABLED_ROWS: readonly string[];
 export declare function worldMountPatches(key: string): readonly WorldPatchLayer[];

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

@@ -68,6 +68,63 @@ export function superdTrustedHosts(value) {
  * @param key - runtime key (`omp`, `codex`, …) — the mount label.
  * @returns patch layers to append to the world's composition.
  */
+/**
+ * Wave-1 of world composition minimization (spec
+ * docs/specs/world-composition-minimization): native-agent machinery the
+ * foreign runtimes replace. Dependency-cleared 2026-09-27 against the KEEP
+ * set (api controllers, session core, adapters' agents/sessions/llm/
+ * agentDefaultModel/settings/agentPresets). Wave-2 candidates (client-ui
+ * family, tools, bash-sandbox, terminal-controller, …) live in the spec,
+ * NOT here.
+ */
+export const WORLD_WAVE1_DISABLED_ROWS = [
+    'agent-loop',
+    'mcp-resources',
+    // skills
+    'skill', 'skill-filesystem', 'skill-badge', 'tool-skill', 'ui-skill',
+    // jobs
+    'jobs', 'tool-jobs', 'ui-jobs', 'job-controller',
+    // subagents
+    'subagent', 'subagent-spawn-in-process', 'subagent-fork-in-process',
+    'tool-subagent-control', 'tool-subagent-list-agents', 'tool-subagent',
+    'tool-subagent-fork', 'tool-subagent-codex', 'tool-subagent-claude-code',
+    'subagent-model-selection-settings', 'ui-subagent', 'ui-settings-subagent',
+    'ui-settings-agent-loop',
+];
+/**
+ * Wave-2 of world composition minimization: the CLIENT lane. The
+ * multi-ctx-multi-ui → native-ui-only transition (0.1.5 / T-D) retired the
+ * world's own web UI (webserver/hmr/web-runtime/client-hmr above); wave-2
+ * completes it by stripping the browser-half rows of the web-app bundle —
+ * every dsh-client-* row plus the cordis client runner. In a world these
+ * only registered modules into a table no browser ever reads.
+ *
+ * Dependency-cleared 2026-09-27: the KEEP side (api controllers, gateway,
+ * session core, adapters) injects none of their services with ONE
+ * exceptions — `connection` (dsh-client-connection: the world's typert
+ * gateway injects it) and `modules` (dsh-client-modules: its activation
+ * work fails in world trees ("client bundles not found") and at least one
+ * fiber treats it as required — the load-bearing parking restatement
+ * `inject: [webServer]` keeps it waiting forever, superseding a disable).
+ */
+export const WORLD_WAVE2_DISABLED_ROWS = [
+    'cordis-client-runner',
+    'directory-picker-browse-surface',
+    'file-upload',
+    'locale',
+    'resources',
+    'ui-agent-preset', 'ui-approval', 'ui-attachment', 'ui-brand-official',
+    'ui-chat', 'ui-commands', 'ui-conversation', 'ui-cordis', 'ui-deliverables',
+    'ui-goal', 'ui-input-trigger', 'ui-layout', 'ui-message-feedback',
+    'ui-model-selection', 'ui-open-in-app', 'ui-permission', 'ui-plan',
+    'ui-plugin-manager', 'ui-reference', 'ui-renderer', 'ui-session',
+    'ui-settings', 'ui-settings-account', 'ui-settings-general',
+    'ui-settings-models', 'ui-settings-plugin-inventory', 'ui-settings-plugins',
+    'ui-settings-shell', 'ui-settings-web-search', 'ui-sidebar',
+    'ui-sidebar-browser', 'ui-sidebar-documentpreview', 'ui-sidebar-files',
+    'ui-sidebar-right', 'ui-sidebar-terminal', 'ui-theme', 'ui-tool',
+    'ui-trajectory', 'ui-user-questions', 'ui-workflow-run', 'ui-workspace',
+];
 export function worldMountPatches(key) {
     if (typeof key !== 'string' || key === '' || key.includes('/')) {
         throw new Error(`world-mount: invalid key ${JSON.stringify(key)}`);
@@ -96,10 +153,20 @@ export function worldMountPatches(key) {
         // literals; the deploy-level trusted-host extras ride along).
         { id: 'web-runtime', disabled: true },
         { id: 'client-hmr', disabled: true },
+        // PARKED, not disabled: the modules row's activation work fails in world
+        // trees (no built client bundles) and the omp fiber treats it as
+        // required — waiting on the never-provided webServer keeps it inert
+        // without a startup failure (2026-09-27 wave-2 rig evidence).
         { 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 },
             ] },
+        // Wave-1 minimization: the foreign runtimes replace the native agent
+        // machinery — these rows never mount in a world tree.
+        ...WORLD_WAVE1_DISABLED_ROWS.map((id) => ({ id, disabled: true })),
+        // Wave-2 minimization: the client lane (native-ui-only completion) —
+        // no browser ever reads a world's module table.
+        ...WORLD_WAVE2_DISABLED_ROWS.map((id) => ({ id, disabled: true })),
     ];
 }