super-dsh 0.1.0 → 0.1.2

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

@@ -0,0 +1,97 @@
+/**
+ * aw.agent-adapter-agy — the Antigravity (agy) 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 `/agy`.
+ *
+ *   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 `/agy+path`;
+ *   3. the hub's carrier answers `/agy/api` + `/agy/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-agy';
+/** Runtime key — also the mount label. */
+const KEY = 'agy';
+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: 'Antigravity', 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();
+    // Nested home: the world's DSH data lives INSIDE `agents/<label>` (sessions
+    // / settings / workspaces, and the adapter's dsh-sessions.json mapping).
+    // agy: RUNTIME data lives in the SDK (google-antigravity localharness reads is the native ~/.pi (2026-09-17 ruling) — ~/.gemini read-only). Nothing is
+    // seeded or nested for the pi SDK 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-agy',
+        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-agy/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@pgmi-builds/agent-adapter-agy",
+  "version": "0.1.0",
+  "description": "Google Antigravity (Gemini) provider for DeepSeek Harness (dsh) — drives the google-antigravity Python SDK through a JSONL stdio bridge (bridge/agy_bridge.py, localharness embedded). Consumer-first auth: Gemini API key stored adapter-side; ADC picked up transparently by the SDK. The agy CLI is never invoked.",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./world": "./dist/world-plugin.js"
+  },
+  "files": [
+    "dist",
+    "bridge",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test test/*.test.mjs",
+    "setup-venv": "bash scripts/setup-venv.sh"
+  },
+  "dependencies": {
+    "zod": "3.25.76"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "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"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "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
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js"
+}

package/agent-claude/cordis.patch.yml

@@ -0,0 +1,42 @@
+# @pgmi-builds/agent-adapter-claude bundle patch (standalone web app form).
+- insert:
+    - id: claude-provider
+      name: '@pgmi-builds/agent-adapter-claude'
+
+- id: agent-loop
+  disabled: true
+- id: llm-deepseek
+  disabled: true
+- id: llm-pi-ai
+  disabled: true
+- id: agent-presets
+  disabled: true
+
+# The upstream jsonl persistence row STAYS MOUNTED: the provider owns the DSH
+# session log write channel, so list/read/replay are ordinary DSH services.
+
+# Claude has real runtime approval (canUseTool), so the preset table is the
+# 3-preset skeleton plus plan/auto/dontAsk extra tiers (src/permission.ts).
+- id: permission
+  config:
+    presets:
+      read-only:
+        sandbox: read-only
+        approval: ask
+      workspace-write:
+        sandbox: workspace-write
+        approval: ask
+      danger-full-access:
+        sandbox: danger-full-access
+        approval: never
+    defaultPreset: danger-full-access
+
+# Directory picker: pin the in-app browser (both faces) and unmount the auto
+# row — never `disabled: true` the row itself (that removes the entry point).
+- insert:
+    - id: directory-picker-browse
+      name: '@deepseek-ai/dsh-host-directory-picker-browse'
+    - id: directory-picker-browse-surface
+      name: '@deepseek-ai/dsh-client-ui-directory-picker-browse'
+- id: directory-picker
+  disabled: true

package/agent-claude/dist/adapter.js

@@ -0,0 +1,62 @@
+/**
+ * Claude-backed `LlmAdapter` registered on `ctx.llm` by the Claude provider.
+ *
+ * The browser model selector never touches the Claude agent directly: it is an
+ * RPC round-trip through the apiproxy, which reads `ctx.llm.listProviders /
+ * listModels / resolveModel` to build the catalog. This adapter answers those
+ * queries from the models Claude actually reported (`models.ts`) under the
+ * single provider route `claude`.
+ *
+ * The route id must be `claude`, NOT `claude-code`: the upstream package
+ * `@deepseek-ai/dsh-subagent-claude-code` already occupies the subagent
+ * provider name `claude-code`, and a world mounting both must not collide.
+ *
+ * `stream` is never dispatched: Claude owns generation through its own SDK
+ * thread, so the adapter only serves catalog/metadata queries. It throws
+ * rather than fabricating a wire route the harness would misuse.
+ */
+import { LlmAdapter, LlmError, ReasoningEffortId, } from "@deepseek-ai/dsh-llm";
+import { readModelCatalog } from "./models.js";
+/** The one provider route every observed Claude model is served under. */
+export const CLAUDE_PROVIDER_ID = "claude";
+/** Human-readable provider name for selectors and diagnostics. */
+const CLAUDE_PROVIDER_NAME = "Claude";
+export class ClaudeLlmAdapter extends LlmAdapter {
+    providerInfo(_provider) {
+        return { id: CLAUDE_PROVIDER_ID, name: CLAUDE_PROVIDER_NAME };
+    }
+    async listModels(_provider) {
+        return readModelCatalog().models.map((model) => ({
+            provider: CLAUDE_PROVIDER_ID,
+            id: model.id,
+            name: model.label,
+            ...(model.description === undefined ? {} : { description: model.description }),
+        }));
+    }
+    async resolveModel(_provider, model) {
+        const found = readModelCatalog().models.find((candidate) => candidate.id === model);
+        if (found === undefined) {
+            throw new LlmError(`Claude provider "${CLAUDE_PROVIDER_ID}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
+        }
+        return {
+            provider: CLAUDE_PROVIDER_ID,
+            id: found.id,
+            name: found.label,
+            ...(found.description === undefined ? {} : { description: found.description }),
+            // Only a positive window is real metadata: an absent or zero window must
+            // never become `context: { contextWindow: 0 }`.
+            ...(found.contextWindow !== undefined && found.contextWindow > 0
+                ? { context: { contextWindow: found.contextWindow } }
+                : {}),
+            // The CLI's advertised effort levels become adapter-owned reasoning
+            // efforts (omp thinking.efforts parity); the CLI names no default, so
+            // none is invented.
+            ...(found.reasoningEfforts !== undefined && found.reasoningEfforts.length > 0
+                ? { reasoning: { efforts: found.reasoningEfforts.map((effort) => ({ id: ReasoningEffortId(effort), name: effort })) } }
+                : {}),
+        };
+    }
+    stream(_options) {
+        throw new LlmError("the Claude adapter does not stream: Claude owns generation through its SDK thread", "UNSUPPORTED_STREAM");
+    }
+}

package/agent-claude/dist/agent-preset-claude.js

@@ -0,0 +1,169 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+const CLAUDE_PRESET = Object.freeze({
+    id: "claude",
+    trust: "system",
+    path: "",
+    name: "Claude",
+    description: "Claude Code via the agent-claude adapter",
+});
+const COMPOSITION_TEXT = [
+    "# Claude (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the Claude provider bridges Dash",
+    "sessions to a native Claude Code CLI over the official @anthropic-ai/claude-agent-sdk.",
+    "There is no per-session plugin composition to configure, so this preset",
+    "mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `claude` session reads presenters through. */
+const STANDING_KEY = {};
+let SingleClaudePresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SingleClaudePresetRoster extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _remoteList_decorators = [Remote("list")];
+            _remoteRead_decorators = [Remote("read")];
+            _remoteCopy_decorators = [Remote("copy")];
+            _remoteDelete_decorators = [Remote("deletePreset")];
+            _remoteSelect_decorators = [Remote("select")];
+            __esDecorate(this, null, _remoteList_decorators, { kind: "method", name: "remoteList", static: false, private: false, access: { has: obj => "remoteList" in obj, get: obj => obj.remoteList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteRead_decorators, { kind: "method", name: "remoteRead", static: false, private: false, access: { has: obj => "remoteRead" in obj, get: obj => obj.remoteRead }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteCopy_decorators, { kind: "method", name: "remoteCopy", static: false, private: false, access: { has: obj => "remoteCopy" in obj, get: obj => obj.remoteCopy }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteDelete_decorators, { kind: "method", name: "remoteDelete", static: false, private: false, access: { has: obj => "remoteDelete" in obj, get: obj => obj.remoteDelete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteSelect_decorators, { kind: "method", name: "remoteSelect", static: false, private: false, access: { has: obj => "remoteSelect" in obj, get: obj => obj.remoteSelect }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        constructor(ctx) {
+            super(ctx, "agentPresets");
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        get defaultId() {
+            return CLAUDE_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [CLAUDE_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === CLAUDE_PRESET.id)
+                return CLAUDE_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: claude)`, { agentPreset: id, available: [CLAUDE_PRESET.id] });
+        }
+        async mount(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async recompose(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async read(id) {
+            await this.resolve(id);
+            return COMPOSITION_TEXT;
+        }
+        // ── Remote RPC surface (alpha: agentPresets routes come from @Remote) ────
+        async remoteList() {
+            if (process.env.CLAUDE_TRACE === "1")
+                process.stderr.write("[claude-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: CLAUDE_PRESET.id,
+                        trust: CLAUDE_PRESET.trust,
+                        isDefault: true,
+                        name: CLAUDE_PRESET.name,
+                        description: CLAUDE_PRESET.description,
+                    },
+                ],
+                authorable: this.authorable,
+            };
+        }
+        async remoteRead(agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return {
+                agentPreset: preset.id,
+                trust: preset.trust,
+                content: await this.read(preset.id),
+                name: preset.name,
+                description: preset.description,
+            };
+        }
+        async remoteCopy(from, id, name) {
+            await this.copy(from, id, name);
+        }
+        async remoteDelete(id) {
+            await this.remove(id);
+        }
+        /** Fixed roster: one preset, so selecting it is a no-op ack; anything else is unknown. */
+        async remoteSelect(agent, agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return preset.id;
+        }
+        async copy(_from, id, _name) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the Claude roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Claude roster is fixed and ships exactly one preset" });
+        }
+        async remove(id) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the Claude roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Claude roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return CLAUDE_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SingleClaudePresetRoster };

package/agent-claude/dist/agent-preset-projection.js

@@ -0,0 +1,30 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which
+ * the bundle patch disables (the claude provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the
+ * preset hero chip renders only when `session.projectionValues.agentPreset`
+ * resolves, and the session-header label reads it too. Without a registrant
+ * the projection is absent for every adapter session and both surfaces stay
+ * blank — roster or no roster (the omp line's "no mode" bug, re-observed as
+ * the claude "degraded preset" finding).
+ *
+ * Same fold as upstream; adapter-claude is single-preset: default every
+ * session to "claude" so the header chip resolves for sessions whose log
+ * carries no `agent-preset/selected` event yet. Registered under the
+ * provider's own fiber via `ctx.inject(['sessionProjections'])`.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const claudeAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    init: (header) => header.agentPreset ?? "claude",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};