super-dsh 0.1.12-a → 0.3.0

package/agent-omp/lib/client/index.js

@@ -0,0 +1,258 @@
+window.__ModuleLoader__.load({ id: "@pgmi-builds/agent-omp", factory: (require) => {
+var module = { exports: {} }; var exports = module.exports;
+
+//#region src/mobile/gesture.ts
+/** Resolved defaults — the `1706b81` constants (120 / viewport÷4 / 40 / 1.3)
+* plus the one addition, the velocity gate. A slow text-selection drag runs
+* ~0.13 px/ms; 0.15 px/ms filters those while any comfortable sweep (0.4
+* px/ms and up) passes.
+*/
+const DEFAULT_SWIPE_THRESHOLDS = {
+	swipeDistancePx: 40,
+	dominanceRatio: 1.3,
+	leftEdgeBandPx: 120,
+	rightZoneRatio: .25,
+	swipeVelocityPxPerMs: .15
+};
+/**
+* Whether a pointerdown may START a gesture — the source's pointerdown
+* gate, verbatim: with both panels closed, only the left band (X120) or
+* the right three quarters of the screen admit; with a panel open, any
+* position admits (that swipe is a dismiss).
+*
+* @param x - pointerdown client X.
+* @param viewportWidth - viewport width at gesture time (px).
+* @param panels - panel state at pointerdown.
+* @param thresholds - resolved recognition thresholds.
+* @returns `true` when the origin is admitted into tracking.
+*/
+function admitsSwipeStart(x, viewportWidth, panels, thresholds) {
+	if (!(panels.leftCollapsed && !panels.rightOpen)) return true;
+	return x <= thresholds.leftEdgeBandPx || x >= viewportWidth * thresholds.rightZoneRatio;
+}
+/**
+* Classify one in-flight drag into a panel action — the source's
+* pointermove decision, verbatim, plus the velocity gate. Callers fire
+* ONCE (then drop the drag): a `null` here means "not yet / not this
+* gesture", and the same drag may classify on a LATER move event as its
+* displacement or velocity grows.
+*
+* @param progress - the drag's displacement and elapsed time so far.
+* @param panels - panel state read live at this event.
+* @param sessionLive - whether a session is current (gates opening the
+*   right panel, mirroring the source's `detailsSession !== undefined`).
+* @param thresholds - resolved recognition thresholds.
+* @returns the action the drag maps to, or `null` when no panel admits
+*   it yet.
+*/
+function classifySwipeProgress(progress, panels, sessionLive, thresholds) {
+	const adx = Math.abs(progress.dx);
+	const ady = Math.abs(progress.dy);
+	if (adx < thresholds.swipeDistancePx) return null;
+	if (adx <= ady * thresholds.dominanceRatio) return null;
+	if (thresholds.swipeVelocityPxPerMs > 0) {
+		if (progress.dtMs <= 0) return null;
+		if (adx / progress.dtMs < thresholds.swipeVelocityPxPerMs) return null;
+	}
+	if (progress.dx < 0) {
+		if (!panels.leftCollapsed) return "close-left";
+		if (sessionLive && !panels.rightOpen) return "open-right";
+		return null;
+	}
+	if (panels.rightOpen) return "close-right";
+	if (panels.leftCollapsed) return "open-left";
+	return null;
+}
+/**
+* Merge the host-injected page config over the defaults. An absent config
+* (host feature off, or an old cached page) resolves to enabled=false — the
+* client half is inert unless the host opted the page in.
+*
+* @param pageConfig - `window.__AGENT_OMP_MOBILE__` as left by the boot script.
+* @returns resolved thresholds plus the enable flag.
+*/
+function resolveMobileConfig(pageConfig) {
+	if (pageConfig === void 0 || pageConfig.enabled !== true) return {
+		enabled: false,
+		...DEFAULT_SWIPE_THRESHOLDS
+	};
+	const n = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+	const v = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+	return {
+		enabled: true,
+		swipeDistancePx: n(pageConfig.swipeDistancePx, DEFAULT_SWIPE_THRESHOLDS.swipeDistancePx),
+		dominanceRatio: n(pageConfig.dominanceRatio, DEFAULT_SWIPE_THRESHOLDS.dominanceRatio),
+		leftEdgeBandPx: n(pageConfig.leftEdgeBandPx, DEFAULT_SWIPE_THRESHOLDS.leftEdgeBandPx),
+		rightZoneRatio: n(pageConfig.rightZoneRatio, DEFAULT_SWIPE_THRESHOLDS.rightZoneRatio),
+		swipeVelocityPxPerMs: v(pageConfig.swipeVelocityPxPerMs, DEFAULT_SWIPE_THRESHOLDS.swipeVelocityPxPerMs)
+	};
+}
+
+//#endregion
+//#region src/mobile/client/index.ts
+/** Left sidebar state, live off AppFrame's semantic attribute. */
+function readLeftCollapsed() {
+	return document.querySelector("[data-sidebar-collapsed]") !== null;
+}
+/**
+* The OFFICIAL right sidebar's state (0.1.5 ui-sidebar-right), read from
+* AppFrame's TWO presentation facets, synchronously (a cached mirror lags
+* the panel's own DOM write by a render, and a close-swipe issued right
+* after an open-swipe would misroute):
+*
+* - `[data-rightbar-collapsed]` — the reserved GRID TRACK facet (present =
+*   zero-width right column). On phones (<768) the panel presents FULLSCREEN
+*   WITHOUT a track (`autoFullscreen` in SidebarRight), so this attribute
+*   alone misreads a panel that covers the whole frame as "closed" — the
+*   2026-09-11 field bug: every close-swipe misrouted to open-left.
+* - `[data-rightbar-fullscreen]` — the overlay facet (present = fullscreen
+*   presentation active, open by definition).
+*
+* Open = track reserved OR fullscreen overlay. On hosts before 0.1.5 both
+* attributes never appear: closed, permanently — left gestures unaffected.
+*/
+function readRightOpen() {
+	const fullscreen = document.querySelector("[data-rightbar-fullscreen]") !== null;
+	const trackless = document.querySelector("[data-rightbar-collapsed]") !== null;
+	return fullscreen || !trackless;
+}
+/**
+* Whether a session is current — the plugin-side stand-in for the source's
+* `detailsSession !== undefined` guard (the right panel is a
+* session-scoped surface; without a session its expand button is not
+* rendered, so opening would be a no-op anyway).
+*/
+function readSessionLive() {
+	return document.querySelector("[data-slot=\"conversation.session.header\"]") !== null;
+}
+/** Panel state snapshot, both sources live. */
+function readPanelState() {
+	return {
+		leftCollapsed: readLeftCollapsed(),
+		rightOpen: readRightOpen()
+	};
+}
+/**
+* Drive the OFFICIAL right sidebar through its own controls (0.1.5
+* ui-sidebar-right): opening clicks `[data-sidebar-right-expand]` (the
+* conversation header corner button — the panel's own documented "way
+* into a hidden panel", rendered exactly while collapsed with a session);
+* closing clicks `[data-sidebar-right-toggle]` (the dock chrome toggle).
+* The store action behind them (`setExpanded`/`toggleExpanded`) is
+* slot-store-internal — cross-plugin imports are the hard boundary, so
+* the native buttons ARE the sanctioned entry. Absent button (pre-0.1.5
+* host, no session, or already in the target state): a no-op, never a
+* crash.
+*/
+function openRightPanel() {
+	document.querySelector("[data-sidebar-right-expand]")?.click();
+}
+function closeRightPanel() {
+	document.querySelector("[data-sidebar-right-toggle]")?.click();
+}
+/**
+* The responsive CSS: zero-width sidebar track whenever upstream's layout
+* has collapsed the sidebar, keyed PURELY to AppFrame's semantic
+* attribute (survives class-hash churn). No width media query of our own
+* (2026-09-11 ruling): upstream owns the auto-collapse threshold (1024
+* today), and this rule simply takes the 56px rail they leave behind to
+* zero. If upstream renames the attribute the rule stops matching and
+* their native rail renders (benign degradation). The tag carries the
+* plugin-owned dataset so the loader's style-claim machinery removes it
+* on unload, like module CSS.
+*/
+function mobileCss() {
+	return [
+		`[data-sidebar-collapsed] {`,
+		`  grid-template-columns: 0px minmax(0, 1fr) 0px !important;`,
+		`}`
+	].join("\n");
+}
+/**
+* Mount the mobile feature: style injection plus the swipe listeners.
+* Inert unless the host's boot script opted the page in.
+*
+* @param ctx - client root context.
+* @returns the effect disposer (style tag + listeners removed on unload).
+*/
+function setupMobileLayout(ctx) {
+	const pageConfig = globalThis.__AGENT_OMP_MOBILE__;
+	const config = resolveMobileConfig(pageConfig);
+	if (!config.enabled) return;
+	const styleTagId = "agent-omp/mobile";
+	ctx.effect(() => {
+		const tag = document.createElement("style");
+		tag.dataset.plugin = "agent-omp";
+		tag.dataset.pluginCss = styleTagId;
+		tag.textContent = mobileCss();
+		document.head.append(tag);
+		const offLayout = ctx.inject(["layout"], (layoutCtx) => {
+			const layout = layoutCtx.get("layout");
+			if (layout === void 0) return;
+			let start;
+			const onPointerDown = (event) => {
+				start = void 0;
+				const viewport = window.innerWidth;
+				const coarsePointer = window.matchMedia?.("(pointer: coarse)").matches === true;
+				const panels = readPanelState();
+				if (!coarsePointer && !panels.leftCollapsed && !panels.rightOpen) return;
+				if (!admitsSwipeStart(event.clientX, viewport, panels, config)) return;
+				start = {
+					x: event.clientX,
+					y: event.clientY,
+					t: event.timeStamp
+				};
+			};
+			const onPointerMove = (event) => {
+				const origin = start;
+				if (origin === void 0) return;
+				const action = classifySwipeProgress({
+					dx: event.clientX - origin.x,
+					dy: event.clientY - origin.y,
+					dtMs: event.timeStamp - origin.t
+				}, readPanelState(), readSessionLive(), config);
+				if (action === null) return;
+				start = void 0;
+				if (action === "open-left" || action === "close-left") layout.toggleSidebar();
+				else if (action === "open-right") openRightPanel();
+				else closeRightPanel();
+			};
+			const onPointerEnd = () => {
+				start = void 0;
+			};
+			document.addEventListener("pointerdown", onPointerDown, true);
+			document.addEventListener("pointermove", onPointerMove, true);
+			document.addEventListener("pointerup", onPointerEnd, true);
+			document.addEventListener("pointercancel", onPointerEnd, true);
+			return () => {
+				document.removeEventListener("pointerdown", onPointerDown, true);
+				document.removeEventListener("pointermove", onPointerMove, true);
+				document.removeEventListener("pointerup", onPointerEnd, true);
+				document.removeEventListener("pointercancel", onPointerEnd, true);
+			};
+		});
+		return () => {
+			tag.remove();
+			Promise.resolve(offLayout.dispose());
+		};
+	}, "agent-omp: mobile layout");
+}
+
+//#endregion
+//#region src/client/index.ts
+/** Required services (cordis fiber inject): the panel-action face only. */
+const inject = ["layout"];
+/**
+* Mount the mobile feature. Inert unless the host's boot script opted the
+* page in via `window.__AGENT_OMP_MOBILE__`.
+*
+* @param ctx - client root context.
+*/
+function apply(ctx) {
+	setupMobileLayout(ctx);
+}
+
+//#endregion
+exports.apply = apply;
+exports.inject = inject;
+return module.exports; } });

package/agent-omp-sdk/dist/world-plugin.d.ts

@@ -3,7 +3,7 @@ export declare const name = "agent-omp-sdk";
 interface HostContext {
     provide(name: string, value: unknown): void;
     inject(deps: string[], callback: (ctx: unknown) => void): unknown;
-    effect?(callback: () => () => void, label?: string): unknown;
+    effect(callback: () => () => Promise<void>, label?: string): unknown;
     get(name: string): unknown;
 }
 export declare function apply(ctx: HostContext): void;

package/agent-omp-sdk/dist/world-plugin.js

@@ -30,7 +30,8 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
 import { join } from 'node:path';
-import { spawnWorld, registerAgent, unregisterAgent, setReady, registerForeignTarget, registerHostMount, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { spawnWorld, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { ownWorld } from '../../superd-hub/dist/world-lifecycle.js';
 import { sdkRuntimeLayout } from './sdk-runtime.js';
 export const name = 'agent-omp-sdk';
 /**
@@ -60,16 +61,6 @@ function diagnoseSdkRuntime(worldHome) {
         `Pre-warm it with \`npm run fetch-sdk-runtime\` (OMP_SDK_PACKAGE_VERSION overrides the pin).`);
 }
 export function apply(ctx) {
-    // Roster membership is FIBER-SCOPED (2026-10-03 acceptance finding):
-    // disabling this row from the plugin manager disposes the fiber, and the
-    // entry must go with it. The `/api/agent-runtime` view hides a row whose
-    // host mount is gone, but the raw roster map is never pruned — so without
-    // this disposer a later re-enable dies on `roster: duplicate agent key
-    // omp-sdk` (reproduced live on 4997).
-    ctx.effect?.(() => {
-        registerAgent({ key: KEY, label: 'OMP (SDK)', ready: false });
-        return () => unregisterAgent(KEY);
-    }, `agent-${KEY}: roster`);
     // 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.
@@ -89,37 +80,18 @@ export function apply(ctx) {
         adapterPkg: '@pgmi-builds/agent-omp-sdk',
         worldHome,
     });
-    const world = (async () => {
-        // T-D: no ctx0 listening-stack wait — the mount record is addressability
-        // only and the /hub family wires its own gate in ctx0 (gateway.ts).
-        const dropHostMount = registerHostMount({ key: KEY, labelPath: `/${KEY}` });
-        const ctxW = await spawnWorld({
-            appName: `superd-${KEY}`,
-            profileName: 'web',
-            installAnchor: resolveInstallAnchor(ctx), // lazy: never at module scope — import must stay side-effect-free
-            home: worldHome,
-            dataHome: worldHome,
-            // The host's live table carries this world: spawnWorld republishes a
-            // widened successor before boot imports anything (spec §2.1), and
-            // @pgmi-builds rows resolve from the profile-local links written above.
-            host: ctx,
-            extraPatches: worldMountPatches(KEY),
-        });
-        const gateway = ctxW.get('typertGateway');
-        registerForeignTarget({ key: KEY, gateway });
-        setReady(KEY, true);
-        ctx.effect?.(() => () => {
-            dropHostMount();
-        }, `agent-${KEY}: mount`);
-        // Toggling the row off must really UNLOAD the world (2026-10-03 acceptance
-        // finding): disposing the world's own fiber disposes its provider, which
-        // releases every held transport, which releases the refcounted sidecar —
-        // without this the bun sidecar (hundreds of MB) outlives its own row.
-        ctx.effect?.(() => () => {
-            void ctxW.fiber?.dispose();
-        }, `agent-${KEY}: world teardown`);
-        return ctxW;
-    })().catch((cause) => {
+    const world = ownWorld(ctx, { key: KEY, label: 'OMP (SDK)' }, (ownerId) => spawnWorld({
+        appName: `superd-${KEY}`,
+        profileName: 'web',
+        installAnchor: resolveInstallAnchor(ctx), // lazy: never at module scope — import must stay side-effect-free
+        home: worldHome,
+        dataHome: worldHome,
+        // The host's live table carries this world: spawnWorld republishes a
+        // widened successor before boot imports anything (spec §2.1), and
+        // @pgmi-builds rows resolve from the profile-local links written above.
+        host: ctx,
+        extraPatches: worldMountPatches(KEY, ownerId),
+    }), (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);
@@ -131,7 +103,6 @@ export function apply(ctx) {
                 console.error(`[super-dsh] ${KEY} startup:`, JSON.stringify(message));
             }
         }
-        return null;
     });
     ctx.provide(`superd.world.${KEY}`, world);
 }

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

@@ -21,12 +21,12 @@
 import { mkdirSync } from 'node:fs';
 import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
 import { join } from 'node:path';
-import { spawnWorld, registerAgent, setReady, registerForeignTarget, registerHostMount, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { spawnWorld, worldMountPatches, provisionWorldProfile, resolveInstallAnchor, } from '../../superd-hub/dist/index.js';
+import { ownWorld } from '../../superd-hub/dist/world-lifecycle.js';
 export const name = 'agent-pi';
 /** Runtime key — also the mount label. */
 const KEY = 'pi';
 export function apply(ctx) {
-    registerAgent({ key: KEY, label: 'Pi', 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.
@@ -44,34 +44,21 @@ export function apply(ctx) {
         adapterPkg: '@pgmi-builds/agent-pi',
         worldHome,
     });
-    const world = (async () => {
-        // T-D: no ctx0 listening-stack wait — the mount record is addressability
-        // only and the /hub family wires its own gate in ctx0 (gateway.ts).
-        const dropHostMount = registerHostMount({ key: KEY, labelPath: `/${KEY}` });
-        const ctxW = await spawnWorld({
-            appName: `superd-${KEY}`,
-            profileName: 'web',
-            installAnchor: resolveInstallAnchor(ctx), // lazy: never at module scope — import must stay side-effect-free
-            home: worldHome,
-            dataHome: worldHome,
-            // The host's live table carries this world: spawnWorld republishes a
-            // widened successor before boot imports anything (spec §2.1), and
-            // @pgmi-builds rows resolve from the profile-local links written above.
-            host: ctx,
-            extraPatches: worldMountPatches(KEY),
-        });
-        const gateway = ctxW.get('typertGateway');
-        registerForeignTarget({ key: KEY, gateway });
-        setReady(KEY, true);
-        ctx.effect?.(() => () => {
-            dropHostMount();
-        }, `agent-${KEY}: mount`);
-        return ctxW;
-    })().catch((cause) => {
+    const world = ownWorld(ctx, { key: KEY, label: 'Pi' }, (ownerId) => spawnWorld({
+        appName: `superd-${KEY}`,
+        profileName: 'web',
+        installAnchor: resolveInstallAnchor(ctx), // lazy: never at module scope — import must stay side-effect-free
+        home: worldHome,
+        dataHome: worldHome,
+        // The host's live table carries this world: spawnWorld republishes a
+        // widened successor before boot imports anything (spec §2.1), and
+        // @pgmi-builds rows resolve from the profile-local links written above.
+        host: ctx,
+        extraPatches: worldMountPatches(KEY, ownerId),
+    }), (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(`superd.world.${KEY}`, world);
 }

package/bundles/manifest.json

@@ -0,0 +1,10 @@
+{
+  "companions": [
+    {
+      "name": "better-dsh",
+      "version": "0.3.0",
+      "tarball": "./better-dsh.tgz",
+      "sha256": "65617864fc50c43730b3fb07140eff515f277b339da6d5acbb2b90cc54467abd"
+    }
+  ]
+}

package/cordis.patch.yml

@@ -12,14 +12,8 @@
 #                              zero-port sibling root, mounted under /<label>
 #   - super-dsh/join           the generic hub joiner for the standalone
 #                              claude adapter (R2)
-#   - super-dsh/web-trust      authentication-only admission (aligned with
-#                              dashr): every serving Host/Origin is accepted
-#                              after native cookie authentication, and the
-#                              browser owns its Host on any authority. No
-#                              trusted-host CLI flags or environment required.
-#                              Set trustAllHosts: false to retain the native
-#                              fence / declared-authorities mode, or disable
-#                              this row explicitly.
+# DSH-only WebTrust, WebServer and onboarding policies belong to the bundled
+# Better Dash package, registered as an independent profile bundle.
 #   - super-dsh/a2a            the agent-facing A2A tool face (mesh P3): the
 #                              single `superd-hub` model tool on ctx0's tools
 #                              service (dormant without tools; world trees
@@ -28,23 +22,20 @@
 # Profile-layer values (webserver port/host, settings path) stay in the USER's
 # profile patch layer, never here.
 - insert:
+    # Register the bundled local companion as an independent native bundle.
+    - id: superd-bundle-setup
+      name: 'super-dsh/setup'
     # 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: superd-hub
       name: 'super-dsh'
-    - id: superd-web-trust
-      name: 'super-dsh/web-trust'
-      config:
-        trustAllHosts: true
     # Native UI fusion transport (plan Task 3): the ctx0 page-level state atom
     # + five call-time patches. Composing this row IS the switch — there is no
     # environment variable in the decision (2026-09-27 user ruling: a release
     # gate living in an env var is deployment state no patch layer can see).
-    # 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).
+    # Better's ownership head uses unshift, so independent bundle reenable
+    # order cannot put it behind this fusion script.
     # To turn the fused surface off: restate this row (same id, same name) with
     # `config: {enabled: false}` or `disabled: true`, or drop it from the
     # composition. Off = the component registers nothing: no script, no global.

package/node_modules/better-dsh/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 RimuruW and Yugimob (original pi-hashline-edit / pi-hashline-edit-pro)
+Copyright (c) 2026 pi-hashline-edit-lsz contributors (pi port, hashline core)
+Copyright (c) 2026 dsh-better-edit contributors (dsh port)
+Copyright (c) 2026 DASHR contributors (dsh-url-schema vendoring)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.