super-dsh 0.1.5-a → 0.1.6

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 })),
     ];
 }