super-dsh 0.1.9 → 0.1.10-e

package/agent-agy/dist/index.js

@@ -1,15 +1,16 @@
 /**
- * agent-agy provider — Google Antigravity (Gemini) provider plugin for DeepSeek
- * Harness (Super D, consumer-first line, 2026-09-18).
+ * agent-agy provider — Google Antigravity provider plugin for DeepSeek Harness
+ * (Super D, consumer-first line, 2026-09-18).
  *
- * An `AgentFactory` that drives an `AgyBridgeClient` (the Python google-
- * antigravity SDK bridge child — localharness materializes inside it on the
- * FIRST prompt, so create/resume spawn nothing). Auth is consumer-first:
- * a Gemini API key persisted in the adapter's world-home state, or ADC via the
- * environment (the SDK picks it up; we never touch the agy CLI — dev-rules §16a).
+ * An `AgentFactory` that drives an `AgyCliClient` — the user's OWN Antigravity
+ * CLI in headless stream-json mode. 2026-10-02 ruling 「拥抱用户自己的使用环境」:
+ * the adapter shares the user's real `~/.gemini` (native settings.json), their
+ * ADC (`~/.config/gcloud`), and their keyring, instead of isolating a HOME the
+ * CLI never had. The SDK/bridge transport lives in its own opt-in package,
+ * `@pgmi-builds/agent-agy-sdk`.
  *
  * Session identity ("mapping only"): the DSH session id is the authority,
- * supplied by the harness. The SDK conversation id materializes after the
+ * supplied by the harness. The CLI conversation id materializes after the
  * first turn, so the pairing is persisted in `<worldHome>/dsh-sessions.json`
  * (agy-sessions.ts). Resume resolves that record and fails CLOSED
  * (CONVERSATION_NOT_FOUND) when no conversation is recorded. The DSH session
@@ -21,14 +22,15 @@ import { join } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { SessionLogOffset, SessionPreparation, interruptedTurnClosers, } from "@deepseek-ai/dsh-session";
-import { AgyBridgeClient } from "./agy-client.js";
 import { AgyCliClient } from "./agy-cli-client.js";
+import { hasSigninCredential, resolveAuthMode } from "./agy-auth.js";
+import { AgyAuthGateway } from "./agy-auth-gateway.js";
 import { registerAntigravityPreset } from "./agent-preset-agy.js";
-import { readAdapterState, writeAdapterState, readNativeDefaultModel, hasAdcEvidence, readGcloudProject } from "./agy-store.js";
+import { readAdapterState, writeAdapterState, readNativeDefaultModel, hasAdcEvidence } from "./agy-store.js";
 import { AgyLlmAdapter, AGY_PROVIDER_ID } from "./adapter.js";
 import { AgyAgent } from "./agent.js";
 import { sessionRecord, upsertSession } from "./agy-sessions.js";
-import { AGY_MODEL_CATALOG, CLI_DEFAULT_MODEL, parseModelId, toModelSlug } from "./models.js";
+import { AGY_MODEL_CATALOG, CLI_DEFAULT_MODEL, parseModelId, resolveEffort, toModelSlug } from "./models.js";
 /** Realpath of a recorded cwd, accepted only when it names an existing directory. */
 /** Extract the session-selected model id (string form) from agent options. */
 function agentOptionsModel(agentOptions) {
@@ -98,6 +100,26 @@ export class AgyProvider extends Service {
         registerAntigravityPreset(ctx);
         this.registerModelCatalog();
         this.registerDefaultModel();
+        // The Hub settings panel's data plane (P3): an adapter-owned Typert Remote
+        // (`agyAuth/get` | `agyAuth/set`) on this world's context. The hub's
+        // carrier forwards `envelope.method` verbatim, so the panel reaches it
+        // through the existing `/hub/api?agent=agy` family — no new hub route, and
+        // no config knowledge leaks out of the adapter (dev-rules §12). Cordis
+        // keeps the instance alive as this context's `agyAuth` service.
+        new AgyAuthGateway(ctx, this.home, () => this.opts.realHome ?? process.env.HOME ?? "", () => this.authAvailability());
+    }
+    /** Which auth forms are present on this machine right now (probe, not choice). */
+    authAvailability() {
+        return {
+            apiKey: this.resolveApiKey() !== undefined,
+            // The CLI's OWN Google sign-in (Agent Platform) — measured 2026-10-02 as
+            // the plane headless actually uses, and the one that WORKS on this
+            // machine. Hardcoding it to `false` (the old "OAuth is a placeholder"
+            // note) forced the ladder onto ADC, whose project has cloudcode-pa
+            // disabled, so no turn could start.
+            oauth: hasSigninCredential(this.opts.realHome ?? process.env.HOME ?? ""),
+            adc: hasAdcEvidence(process.env, process.env.HOME ?? ""),
+        };
     }
     /** The world's DSH home: boot-provided dshHomePath first, env last. */
     resolveHome() {
@@ -153,7 +175,7 @@ export class AgyProvider extends Service {
     }
     /** Static route: provider `agy` + the resolved default (or the explicit ask).
      *  The selected model id (`slug` or `slug@level`) rides in `options.model`
-     *  so clientOptions can forward slug+thinkingLevel to the bridge start frame. */
+     *  so cliOptions can forward slug+thinkingLevel to the CLI child. */
     sessionAgentOptions(requested) {
         const requestedModel = typeof requested?.model === "string" ? requested.model : undefined;
         const explicit = requestedModel !== undefined && parseModelId(requestedModel) !== undefined
@@ -333,18 +355,29 @@ export class AgyProvider extends Service {
         }
     }
     /**
-     * Live transport routing (2026-09-18 user ruling): gemini-api-key > oauth >
-     * adc. Key present → CLI stream (richest surface). ADC-only → SDK bridge.
-     * Neither → CLI as well (auth fails at first prompt; the §17 onboarding
-     * branch answers locally before any spawn).
+     * Live transport: CLI-ONLY (2026-10-02 user ruling).
+     *
+     * The SDK/bridge route moved to its own package
+     * (`@pgmi-builds/agent-agy-sdk`, delivered disabled by default): the product
+     * case is that the user ALREADY runs Antigravity, so the CLI reuses that
+     * environment for free while the SDK is an opt-in extra. Auth-form selection
+     * still rides the agy-auth ladder.
      */
     createLiveClient(cwd, modelId, reasoningEffort) {
-        const apiKey = this.resolveApiKey();
-        if (apiKey === undefined && hasAdcEvidence(process.env, process.env.HOME ?? "")) {
-            return new AgyBridgeClient(this.clientOptions(cwd, modelId, reasoningEffort));
-        }
         return new AgyCliClient(this.cliOptions(cwd, modelId, reasoningEffort));
     }
+    /**
+     * The auth form this machine should use: an explicitly selected, actually
+     * available form wins; otherwise the ladder Gemini API key → OAuth → ADC
+     * (user ruling 2026-10-02). OAuth is a placeholder this round — no eligible
+     * account exists to characterise which native fields a real sign-in stores —
+     * so nothing reports it present and it can never win. Falls back to `apiKey`
+     * so an unconfigured machine still reaches the §17 onboarding path.
+     */
+    effectiveAuthMode() {
+        const selected = readAdapterState(this.home).authMode;
+        return resolveAuthMode(this.authAvailability(), selected) ?? "apiKey";
+    }
     /**
      * The effective permission preset this provider was mounted with. The
      * cordis.patch.yml default is danger-full-access; a patch-level override
@@ -365,11 +398,31 @@ export class AgyProvider extends Service {
         const parsed = parseModelId(modelId ?? this.resolveDefaultModelId());
         const slug = parsed?.slug ?? CLI_DEFAULT_MODEL.slug;
         // Effort precedence: explicit session reasoningEffort (WebUI Effort
-        // selector → AgentOptions) > legacy @level id suffix > CLI cheap default.
-        const level = reasoningEffort ?? parsed?.thinkingLevel ?? CLI_DEFAULT_MODEL.thinkingLevel;
+        // selector → AgentOptions.reasoningEffort) > legacy `slug@level` id suffix >
+        // THIS model's own declared default.
+        //
+        // The last arm used to read CLI_DEFAULT_MODEL.thinkingLevel, which is the
+        // 3.6-flash cheap-pair constant ("low") — so every model inherited it and
+        // the CLI got `--effort low` while the UI showed the model's own default
+        // (observed 2026-10-02: 3.7 Flash + UI "medium" → `--effort "low"`).
+        // defaultEffortFor() is the per-model answer and existed unused.
+        const level = resolveEffort(slug, reasoningEffort, parsed?.thinkingLevel);
+        // The ID ENCODING IS PLANE-DEPENDENT (measured 2026-10-02):
+        //   OAuth / Agent Platform — `agy models` lists ONLY effort-suffixed ids
+        //     (`gemini-3.7-flash-medium`) and the bare id is not a model at all:
+        //     `--model gemini-3.7-flash --effort medium` → "--effort is not
+        //     supported for model …". The suffixed id starts a turn, and a
+        //     redundant `--effort` alongside it is tolerated.
+        //   apiKey — the bare slug PLUS `--effort` (dev3); the suffixed id is not a
+        //     model on that plane.
+        // The UI catalog therefore stays four base models with an effort slot (no
+        // list explosion) and the transport folds the level into the id when the
+        // active plane wants it that way.
+        const mode = this.effectiveAuthMode();
+        const model = mode === "oauth" && level !== undefined ? `${slug}-${level}` : slug;
         return {
             apiKey: () => this.resolveApiKey(),
-            model: slug,
+            model,
             ...(level === undefined ? {} : { effort: level }),
             cwd,
             proxy: this.opts.proxy ?? process.env.AGY_PROXY,
@@ -379,39 +432,12 @@ export class AgyProvider extends Service {
             // tighter presets keep the CLI's request-review (soft-deny, honest).
             skipPermissions: (this.opts.skipPermissions ?? (this.currentPermissionPreset() === "danger-full-access")),
             agyBin: this.opts.agyBin,
-            nativeCliHome: this.opts.nativeHome,
-            home: this.opts.cliHome ?? process.env.AGY_CLI_HOME,
-            spawnAttempts: this.opts.spawnAttempts,
-        };
-    }
-    /** Bridge child options: world cwd + overrides; the api key rides the start config. */
-    clientOptions(cwd, modelId, reasoningEffort) {
-        // Auth plane (§16a): API key when present; otherwise the SDK's Vertex
-        // endpoint over ADC — which needs an explicit project, read from the
-        // gcloud CLI default. Without either, sessions gate into §17 onboarding.
-        const apiKey = this.resolveApiKey();
-        let project = this.opts.project;
-        let location = this.opts.location;
-        if (apiKey === undefined && project === undefined && hasAdcEvidence(process.env, process.env.HOME ?? "")) {
-            project = readGcloudProject(process.env.HOME ?? "");
-            location = location ?? "global";
-        }
-        // Session-selected model id wins over the provider default (previously a
-        // split-brain: the session showed one model, the bridge started another).
-        // `slug@level` decodes into model + thinking_level for the start frame.
-        const parsed = parseModelId(modelId ?? this.resolveDefaultModelId());
-        return {
-            apiKey,
-            project,
-            location,
-            model: parsed?.slug ?? this.resolveDefaultModelId(),
-            // TUI parity: the native default ships (Medium); without an explicit
-            // level the bridge sends none and thinking blocks rarely stream.
-            thinkingLevel: parsed?.thinkingLevel ?? "medium",
-            approvalMode: this.opts.approvalMode ?? "allow",
-            workspaces: [cwd],
-            bridgePath: this.opts.bridgePath,
-            pythonBin: this.opts.pythonBin,
+            authMode: mode,
+            // The USER's real home — hard-coded relative to the current user, as the
+            // 2026-10-02 ruling requires: the CLI, `~/.config/gcloud` (ADC), the
+            // keyring, and the native settings we maintain all resolve against it, so
+            // the adapter and the user's own TUI share one configuration.
+            realHome: this.opts.realHome ?? process.env.HOME ?? "",
             spawnAttempts: this.opts.spawnAttempts,
         };
     }

package/agent-agy/dist/models.d.ts

@@ -16,6 +16,41 @@ export interface AgyCatalogModel {
     efforts?: readonly string[];
     defaultEffort?: string;
 }
+/**
+ * The effort vocabulary is Antigravity's, not DSH's — the WebUI's Effort slot is
+ * only a SLOT; the values offered through it are borrowed from the runtime
+ * (2026-10-02 user ruling). `agy --help` advertises `low|medium|high|max`, so
+ * `max` belongs in the list: the previous three-value vocabulary was DSH's own
+ * and silently hid a level the CLI accepts.
+ *
+ * Capability stays per-model: a model without `efforts` gets NO effort flag at
+ * all (see resolveEffort), and per-model acceptance of `max` still needs a
+ * working auth plane to confirm — no live plane could be probed on 2026-10-02
+ * (ADC serves no catalog; the account plane is eligibility-gated headless).
+ */
+/**
+ * The catalog as the CLI ACTUALLY serves it (probed 2026-10-02 on dev3 against
+ * the live key plane; the CLI answers `available: <levels>` when `--effort` is
+ * omitted, which is the authoritative per-model vocabulary):
+ *
+ *   gemini-3.1-pro    low, high          (NO medium — a global list cannot say this)
+ *   gemini-3.7-flash  low, medium, high
+ *   gemini-3.6-flash  low, medium, high
+ *   gemini-3.8-flash  low, medium, high
+ *   gemini-2.5-pro / 2.5-flash / 3.5-flash → `not recognized as a known model`
+ *
+ * `efforts` therefore exists to describe a model's real vocabulary, NOT to be
+ * transmitted as a default (see resolveEffort: undecided sends nothing).
+ * `defaultEffort` is the Effort slot's display default only.
+ *
+ * MODEL LIST SOURCE: the CLI itself enumerates via
+ * `POST https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels`
+ * (+ `v1internal:listModelConfigs`), which needs an eligible account AND a
+ * quota project with Cloud Code PA enabled. Neither transport could reach it on
+ * this machine (ADC: API disabled / no bind permission on the project; account:
+ * headless eligibility gate), so this table stays a static capture per
+ * dev-rules §16a — with a probe path recorded for whoever has a working plane.
+ */
 export declare const AGY_MODEL_CATALOG: readonly AgyCatalogModel[];
 /** Selectable model ids (plain slugs). */
 export declare function modelIds(): string[];
@@ -33,6 +68,41 @@ export declare const CLI_DEFAULT_MODEL: {
     slug: string;
     thinkingLevel: string;
 };
+/**
+ * The `--effort` value to send for one model.
+ *
+ * `--effort` is REQUIRED, not optional: omitting it makes the CLI refuse to
+ * start (`--model X requires --effort (available: low, high)` — verified
+ * 2026-10-02 against 3.8-flash, 3.7-flash and 3.1-pro). So this always returns a
+ * level for a known model; the only `undefined` case is a slug with no declared
+ * vocabulary, where we forward exactly what was asked for.
+ *
+ * The per-model step is what matters: the original defect read
+ * CLI_DEFAULT_MODEL's level wholesale (a 3.6-flash constant), so every model
+ * got `--effort low` whatever the UI showed, and 3.1-pro — which serves only
+ * low|high — could never start.
+ *
+ * Precedence: an explicit session choice (the WebUI Effort selector arrives as
+ * `AgentOptions.reasoningEffort`) > a legacy `slug@level` id suffix > THIS
+ * model's own declared default.
+ *
+ * The third arm is the one that matters: it used to read
+ * {@link CLI_DEFAULT_MODEL}'s thinking level wholesale — a constant belonging
+ * to the 3.6-flash cheap pair — so every model was sent `--effort low` no
+ * matter what the UI showed (observed 2026-10-02: 3.7 Flash + UI "medium" →
+ * the CLI received `--effort "low"` and refused it). A slug that declares no
+ * effort support yields `undefined`: sending a flag the model rejects is worse
+ * than sending none.
+ *
+ * `slug` is the model actually being launched; an unrecognised slug (the
+ * caller already fell back to the CLI default pair) inherits that pair's level.
+ *
+ * @param slug - the model id being launched (a catalog slug).
+ * @param explicit - the session's reasoning-effort choice, when it made one.
+ * @param legacyLevel - effort decoded from a `slug@level` id, when present.
+ * @returns the effort to pass, or `undefined` to pass no `--effort`.
+ */
+export declare function resolveEffort(slug: string, explicit?: string | undefined, legacyLevel?: string | undefined): string | undefined;
 /**
  * Normalize a model reference to an SDK-facing slug. The native TUI settings
  * store display names ("Gemini 3.7 Flash (Medium)"); slugs pass through;

package/agent-agy/dist/models.js

@@ -9,12 +9,46 @@
  * AgentOptions.reasoningEffort), NOT extra catalog entries (user ruling
  * 2026-09-18).
  */
+/**
+ * The effort vocabulary is Antigravity's, not DSH's — the WebUI's Effort slot is
+ * only a SLOT; the values offered through it are borrowed from the runtime
+ * (2026-10-02 user ruling). `agy --help` advertises `low|medium|high|max`, so
+ * `max` belongs in the list: the previous three-value vocabulary was DSH's own
+ * and silently hid a level the CLI accepts.
+ *
+ * Capability stays per-model: a model without `efforts` gets NO effort flag at
+ * all (see resolveEffort), and per-model acceptance of `max` still needs a
+ * working auth plane to confirm — no live plane could be probed on 2026-10-02
+ * (ADC serves no catalog; the account plane is eligibility-gated headless).
+ */
+/**
+ * The catalog as the CLI ACTUALLY serves it (probed 2026-10-02 on dev3 against
+ * the live key plane; the CLI answers `available: <levels>` when `--effort` is
+ * omitted, which is the authoritative per-model vocabulary):
+ *
+ *   gemini-3.1-pro    low, high          (NO medium — a global list cannot say this)
+ *   gemini-3.7-flash  low, medium, high
+ *   gemini-3.6-flash  low, medium, high
+ *   gemini-3.8-flash  low, medium, high
+ *   gemini-2.5-pro / 2.5-flash / 3.5-flash → `not recognized as a known model`
+ *
+ * `efforts` therefore exists to describe a model's real vocabulary, NOT to be
+ * transmitted as a default (see resolveEffort: undecided sends nothing).
+ * `defaultEffort` is the Effort slot's display default only.
+ *
+ * MODEL LIST SOURCE: the CLI itself enumerates via
+ * `POST https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels`
+ * (+ `v1internal:listModelConfigs`), which needs an eligible account AND a
+ * quota project with Cloud Code PA enabled. Neither transport could reach it on
+ * this machine (ADC: API disabled / no bind permission on the project; account:
+ * headless eligibility gate), so this table stays a static capture per
+ * dev-rules §16a — with a probe path recorded for whoever has a working plane.
+ */
 export const AGY_MODEL_CATALOG = [
+    { slug: "gemini-3.8-flash", label: "Gemini 3.8 Flash", efforts: ["low", "medium", "high"], defaultEffort: "medium" },
     { slug: "gemini-3.7-flash", label: "Gemini 3.7 Flash", efforts: ["low", "medium", "high"], defaultEffort: "medium" },
     { slug: "gemini-3.6-flash", label: "Gemini 3.6 Flash", efforts: ["low", "medium", "high"], defaultEffort: "low" },
-    { slug: "gemini-3.5-flash", label: "Gemini 3.5 Flash", efforts: ["low", "medium", "high"], defaultEffort: "medium" },
-    { slug: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
-    { slug: "gemini-2.5-flash", label: "Gemini 2.5 Flash" },
+    { slug: "gemini-3.1-pro", label: "Gemini 3.1 Pro", efforts: ["low", "high"], defaultEffort: "low" },
 ];
 /** Selectable model ids (plain slugs). */
 export function modelIds() {
@@ -51,6 +85,71 @@ export const CLI_DEFAULT_MODEL = {
     slug: "gemini-3.6-flash",
     thinkingLevel: "low",
 };
+/**
+ * The `--effort` value to send for one model.
+ *
+ * `--effort` is REQUIRED, not optional: omitting it makes the CLI refuse to
+ * start (`--model X requires --effort (available: low, high)` — verified
+ * 2026-10-02 against 3.8-flash, 3.7-flash and 3.1-pro). So this always returns a
+ * level for a known model; the only `undefined` case is a slug with no declared
+ * vocabulary, where we forward exactly what was asked for.
+ *
+ * The per-model step is what matters: the original defect read
+ * CLI_DEFAULT_MODEL's level wholesale (a 3.6-flash constant), so every model
+ * got `--effort low` whatever the UI showed, and 3.1-pro — which serves only
+ * low|high — could never start.
+ *
+ * Precedence: an explicit session choice (the WebUI Effort selector arrives as
+ * `AgentOptions.reasoningEffort`) > a legacy `slug@level` id suffix > THIS
+ * model's own declared default.
+ *
+ * The third arm is the one that matters: it used to read
+ * {@link CLI_DEFAULT_MODEL}'s thinking level wholesale — a constant belonging
+ * to the 3.6-flash cheap pair — so every model was sent `--effort low` no
+ * matter what the UI showed (observed 2026-10-02: 3.7 Flash + UI "medium" →
+ * the CLI received `--effort "low"` and refused it). A slug that declares no
+ * effort support yields `undefined`: sending a flag the model rejects is worse
+ * than sending none.
+ *
+ * `slug` is the model actually being launched; an unrecognised slug (the
+ * caller already fell back to the CLI default pair) inherits that pair's level.
+ *
+ * @param slug - the model id being launched (a catalog slug).
+ * @param explicit - the session's reasoning-effort choice, when it made one.
+ * @param legacyLevel - effort decoded from a `slug@level` id, when present.
+ * @returns the effort to pass, or `undefined` to pass no `--effort`.
+ */
+export function resolveEffort(slug, explicit, legacyLevel) {
+    const entry = AGY_MODEL_CATALOG.find((m) => m.slug === slug);
+    const allowed = entry?.efforts;
+    const wanted = firstNonEmpty(explicit, legacyLevel);
+    // No declared vocabulary (a slug we do not know): forward exactly what was
+    // asked for and no more. We cannot validate against a set we do not have.
+    if (allowed === undefined)
+        return wanted;
+    if (wanted !== undefined && allowed.includes(wanted))
+        return wanted;
+    // Either nothing was chosen or the chosen level is not one THIS model serves
+    // (a stale session, a model swap). Either way we must still send a level:
+    // the CLI refuses to start without one —
+    //   `--model X requires --effort (available: low, high)`
+    // verified 2026-10-02 against 3.8-flash, 3.7-flash and 3.1-pro. So fall back
+    // to the model's own default, then to its cheapest available level, instead
+    // of transmitting nothing (fatal) or another model's constant (the original
+    // defect: every model got 3.6-flash's "low", and 3.1-pro has no medium).
+    const fallback = entry?.defaultEffort;
+    if (fallback !== undefined && allowed.includes(fallback))
+        return fallback;
+    return allowed[0];
+}
+/** First non-empty string, or undefined. An empty value is an absent choice. */
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (value !== undefined && value !== "")
+            return value;
+    }
+    return undefined;
+}
 /**
  * Normalize a model reference to an SDK-facing slug. The native TUI settings
  * store display names ("Gemini 3.7 Flash (Medium)"); slugs pass through;

package/agent-agy/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pgmi-builds/agent-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.",
+  "description": "Google Antigravity provider for DeepSeek Harness (dsh) — drives the user's own Antigravity CLI headless (`agy --input-format stream-json`). 2026-10-02 ruling 「拥抱用户自己的使用环境」: the adapter shares the real ~/.gemini settings.json, ADC and keyring instead of isolating a HOME. Auth ladder: Gemini API key → OAuth (placeholder) → ADC. The heavy Python SDK transport lives in the opt-in sibling @pgmi-builds/agent-agy-sdk.",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist",
-    "bridge",
     "cordis.patch.yml"
   ],
   "dsh": {
@@ -19,8 +18,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "node --test test/*.test.mjs",
-    "setup-venv": "bash scripts/setup-venv.sh"
+    "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
     "zod": "3.25.76"
@@ -31,7 +29,8 @@
     "@deepseek-ai/dsh-llm": ">=0.1.5-0 <0.3.0-0",
     "@deepseek-ai/dsh-scope": ">=0.1.5-0 <0.3.0-0",
     "@deepseek-ai/dsh-session": ">=0.1.5-0 <0.3.0-0",
-    "@deepseek-ai/dsh-session-persistence": ">=0.1.5-0 <0.3.0-0"
+    "@deepseek-ai/dsh-session-persistence": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.5-0 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -51,6 +50,9 @@
     },
     "@deepseek-ai/dsh-session-persistence": {
       "optional": true
+    },
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
     }
   },
   "devDependencies": {

package/agent-agy-sdk/cordis.patch.yml

@@ -0,0 +1,58 @@
+# @pgmi-builds/agent-agy-sdk bundle patch (opt-in SDK line, pi/hermes form).
+# The `dsh.bundle.patch` layer of the adapter package: mounts the agy-sdk
+# provider and disables the native components it replaces. Port/webserver
+# posture is NOT here (worldMountPatches owns it); the profile patch pins home.
+#
+# Auth (dev-rules §16a): Gemini API key in adapter world-home state (or
+# GEMINI_API_KEY env), else ADC — the SDK consumes either transparently. The
+# agy CLI is never invoked (that is @pgmi-builds/agent-agy).
+#
+# This whole bundle sits behind a `disabled: true` row in the super-dsh
+# composite: the SDK half is opt-in (2026-10-02 user ruling) because the CLI
+# half reuses the user's existing Antigravity environment for free.
+
+
+- insert:
+    - id: agy-sdk-provider
+      name: '@pgmi-builds/agent-agy-sdk'
+
+# The SDK bridge owns the live transcript; disable the built-in loop so it
+# does not double-run alongside the bridge session.
+- id: agent-loop
+  disabled: true
+
+# The agy provider registers the single `agy` route on ctx.llm; leaving the
+# native deepseek row mounted would advertise foreign models in this world.
+- id: llm-deepseek
+  disabled: true
+
+# Single-preset roster like pi: launch-only permission mapping (headless bridge
+# has no per-action approval channel). Full 3-preset restatement per §4.1.
+# 0.1.7: the host AgentPresetRegistry row (renamed `agent-presets` ->
+# `agent-preset-registry`) stays MOUNTED — the adapter registers its one
+# fixed preset into it (src/agent-preset-agy.ts); pin only the default.
+- id: agent-preset-registry
+  config:
+    default: agy
+- 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 both faces of `browse`, unmount the auto row (§4.1).
+- 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-agy-sdk/dist/adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Antigravity-backed `LlmAdapter` registered on `ctx.llm` by the Agy provider.
+ * Catalog is STATIC (models.ts): the SDK has no model-list API and the CLI
+ * catalog path is auth-gated (dev-rules §16a), so every surface is synchronous.
+ * `stream` is never dispatched — the Antigravity agent owns generation through
+ * its bridge child (`AgyAgent`); it throws rather than fabricating a wire route.
+ */
+import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmProviderInfo, type LlmResolvedModelInfo, type StreamChunk } from "@deepseek-ai/dsh-llm";
+export declare const AGY_PROVIDER_ID = "agy";
+export declare class AgyLlmAdapter extends LlmAdapter {
+    providerInfo(provider: string): LlmProviderInfo;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(_options: GenerateOptions): AsyncIterable<StreamChunk>;
+}

package/agent-agy-sdk/dist/adapter.js

@@ -0,0 +1,42 @@
+/**
+ * Antigravity-backed `LlmAdapter` registered on `ctx.llm` by the Agy provider.
+ * Catalog is STATIC (models.ts): the SDK has no model-list API and the CLI
+ * catalog path is auth-gated (dev-rules §16a), so every surface is synchronous.
+ * `stream` is never dispatched — the Antigravity agent owns generation through
+ * its bridge child (`AgyAgent`); it throws rather than fabricating a wire route.
+ */
+import { LlmAdapter, LlmError, ReasoningEffortId, } from "@deepseek-ai/dsh-llm";
+import { AGY_MODEL_CATALOG } from "./models.js";
+export const AGY_PROVIDER_ID = "agy";
+export class AgyLlmAdapter extends LlmAdapter {
+    providerInfo(provider) {
+        return { id: provider, name: provider === AGY_PROVIDER_ID ? "Google" : provider };
+    }
+    async listModels(provider) {
+        return AGY_MODEL_CATALOG.map((model) => ({
+            provider,
+            id: model.slug,
+            name: model.label,
+        }));
+    }
+    async resolveModel(provider, model) {
+        const found = AGY_MODEL_CATALOG.find((candidate) => candidate.slug === model);
+        if (found === undefined) {
+            throw new LlmError(`Agy provider "${provider}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
+        }
+        return {
+            provider,
+            id: found.slug,
+            name: found.label,
+            ...(found.efforts === undefined ? {} : {
+                reasoning: {
+                    efforts: found.efforts.map((level) => ({ id: ReasoningEffortId(level), name: level })),
+                    ...(found.defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(found.defaultEffort) }),
+                },
+            }),
+        };
+    }
+    stream(_options) {
+        throw new LlmError("the Agy adapter does not stream: Antigravity owns generation through its bridge agent", "UNSUPPORTED_STREAM");
+    }
+}

package/agent-agy-sdk/dist/agent-preset-agy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Antigravity preset registration — the profile's one fixed Agent preset.
+ *
+ * 0.1.7 alignment (upstream split `dsh-agent-presets` into `dsh-agent-preset`
+ * + `dsh-agent-preset-registry` and moved roster, selection, document RPC and
+ * the `agentPreset` session projection into the host `AgentPresetRegistry`,
+ * mounted by the dsh-web-app bundle's `agent-preset-registry` row): the
+ * adapter no longer implements the `agentPresets` service — the 0.1.6
+ * SingleAgyPresetRoster and its own projection fold are retired. It only REGISTERS the
+ * single fixed preset into the host registry.
+ *
+ * Antigravity is single-mode: the foreign agent drives its own tools, so no
+ * Dash-side preset composition exists to choose from. The preset's
+ * composition deliberately mounts nothing.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { PresetDefinition } from "@deepseek-ai/dsh-agent-preset-registry";
+export declare const AGY_PRESET_ID = "agy";
+/** The single fixed Antigravity preset: mounting it composes nothing. */
+export declare const AGY_PRESET: PresetDefinition;
+/**
+ * Register the fixed preset into the host `AgentPresetRegistry` once the
+ * service is up. Registration failure keeps the roster row visible as
+ * `broken` inside the registry (upstream owns that lifecycle) — the adapter
+ * only owns the disposer.
+ */
+export declare function registerAntigravityPreset(ctx: Context): void;

package/agent-agy-sdk/dist/agent-preset-agy.js

@@ -0,0 +1,32 @@
+export const AGY_PRESET_ID = "agy";
+/** The single fixed Antigravity preset: mounting it composes nothing. */
+export const AGY_PRESET = Object.freeze({
+    id: AGY_PRESET_ID,
+    name: "Antigravity",
+    description: "Google Antigravity (Gemini) via the agent-agy adapter",
+    plugins: Object.freeze([]),
+});
+/**
+ * Register the fixed preset into the host `AgentPresetRegistry` once the
+ * service is up. Registration failure keeps the roster row visible as
+ * `broken` inside the registry (upstream owns that lifecycle) — the adapter
+ * only owns the disposer.
+ */
+export function registerAntigravityPreset(ctx) {
+    ctx.inject(["agentPresets"], (scoped) => {
+        let dispose;
+        let settled = false;
+        void scoped.agentPresets.register(AGY_PRESET).then((unregister) => {
+            if (settled) {
+                void unregister();
+            }
+            else {
+                dispose = unregister;
+            }
+        });
+        ctx.effect(() => async () => {
+            settled = true;
+            await dispose?.();
+        }, "agyAdapter.preset");
+    });
+}