super-dsh 0.1.0 → 0.1.1

package/agent-agy/bridge/agy_bridge.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+# agy_bridge.py — JSONL-over-stdio bridge hosting the google-antigravity SDK.
+#
+# Contract (one JSON object per line; requests on stdin, events on stdout):
+#   -> {"op":"start",  "model":str, "thinking_level"?:"minimal|low|medium|high|extra_high",
+#       "api_key"?:str, "project"?:str, "location"?:str,
+#       "approval_mode"?:"allow"|"ask",          # default "allow"
+#       "workspaces":[str], "save_dir"?:str}
+#      (localharness is NOT spawned here — materializes lazily on first prompt)
+#   -> {"op":"prompt", "text":str, "conversation_id"?:str}
+#      streams back:
+#      <- {"event":"thinking","text":str}        # Thought delta (reasoning)
+#      <- {"event":"chunk","text":str}           # Text delta
+#      <- {"event":"tool","name":str}            # tool dispatched
+#      <- {"event":"approval_request","id":str,"tool":str,"args":str}   # ask mode
+#      <- {"event":"usage","input_tokens":int,"output_tokens":int,
+#          "thinking_tokens":int,"total_tokens":int}                    # best effort
+#      <- {"event":"done","conversation_id":str,"turn_ms":int}
+#      <- {"event":"error","error":str,"recoverable":bool}
+#   -> {"op":"approval","id":str,"allow":bool}   # host reply to approval_request
+#   -> {"op":"ping"} -> {"event":"pong"}
+#   -> {"op":"close"} -> exits 0
+#
+# Auth is transparent: pass api_key (Gemini API key) or project (+ADC) for the
+# Vertex endpoint. CLI (agy) is never invoked.
+
+import asyncio
+import json
+import os
+import sys
+import time
+import uuid
+
+
+def emit(obj):
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+class Bridge:
+    def __init__(self):
+        self.config = None
+        self.started = False
+        self.pending_approvals = {}  # id -> asyncio.Event
+        self.approval_results = {}   # id -> bool
+        self.approval_mode = "allow"
+
+    async def handle_start(self, req):
+        import google.antigravity as ga
+
+        kwargs = {
+            "model": req.get("model") or "gemini-3.5-flash",
+            "workspaces": req.get("workspaces") or [os.getcwd()],
+        }
+        if req.get("save_dir"):
+            kwargs["save_dir"] = req["save_dir"]
+        if req.get("api_key"):
+            kwargs["api_key"] = req["api_key"]
+        if req.get("project"):
+            kwargs["vertex"] = True
+            kwargs["project"] = req["project"]
+            if req.get("location"):
+                kwargs["location"] = req["location"]
+        self.approval_mode = req.get("approval_mode") or "allow"
+        # ask mode requires the SDK to keep hook objects in-process; the current
+        # localharness pickles parts of the config, which fails on runtime
+        # references (SimpleQueue). Opt-in via AGY_BRIDGE_ASK=1 until the SDK
+        # supports in-process hooks; otherwise degrade to allow with a trace.
+        if self.approval_mode == "ask":
+            if os.environ.get("AGY_BRIDGE_ASK") == "1":
+                kwargs["hooks"] = list(kwargs.get("hooks") or []) + [PreToolApprovalBridge(self)]
+            else:
+                emit({"event": "error", "error": "approval_mode=ask unavailable (SDK pickles config; set AGY_BRIDGE_ASK=1 to force); degrading to allow", "recoverable": True})
+                self.approval_mode = "allow"
+        level = req.get("thinking_level")
+        if level:
+            from google.antigravity.models import (
+                GeminiAPIEndpoint, GeminiModelOptions, ModelTarget, VertexEndpoint,
+            )
+            from google.antigravity.types import ThinkingLevel
+            if kwargs.get("vertex"):
+                endpoint = VertexEndpoint(project=kwargs.get("project"),
+                                          location=kwargs.get("location"))
+            else:
+                endpoint = GeminiAPIEndpoint(api_key=kwargs.get("api_key"))
+            kwargs["model"] = None
+            kwargs["models"] = [ModelTarget(
+                name=req["model"],
+                endpoint=endpoint,
+                options=GeminiModelOptions(thinking_level=ThinkingLevel(level)),
+            )]
+        self.config = ga.LocalAgentConfig(**kwargs)
+        self.started = True
+        emit({"event": "started"})
+
+    async def handle_prompt(self, req):
+        if not self.started:
+            emit({"event": "error", "error": "not started", "recoverable": False})
+            return
+        import google.antigravity as ga
+
+        text = req.get("text") or ""
+        cid = req.get("conversation_id")
+        t0 = time.time()
+        agent = ga.Agent(self.config)
+        try:
+            await agent.__aenter__()
+            resp = await agent.chat(text)
+            usage = None
+            # resp.__aiter__ yields only Text strings; .chunks carries the full
+            # typed stream (Thought / ToolCall / ToolResult).
+            async for ch in resp.chunks:
+                kind = type(ch).__name__
+                if isinstance(ch, str):
+                    emit({"event": "chunk", "text": ch})
+                elif kind == "Thought":
+                    emit({"event": "thinking", "text": getattr(ch, "text", "")})
+                elif kind == "Text":
+                    emit({"event": "chunk", "text": getattr(ch, "text", "")})
+                elif kind == "ToolCall":
+                    emit({"event": "tool_call", "id": str(getattr(ch, "id", "") or ""),
+                          "name": str(getattr(ch, "name", "") or "unknown"),
+                          "args": json.dumps(getattr(ch, "args", ""), ensure_ascii=False, default=str)[:600]})
+                elif kind == "ToolResult":
+                    err = getattr(ch, "error", None)
+                    emit({"event": "tool_result", "id": str(getattr(ch, "id", "") or ""),
+                          "name": str(getattr(ch, "name", "") or ""),
+                          "is_error": err is not None,
+                          "result": str(getattr(ch, "result", ""))[:600]})
+            conv = agent.conversation
+            new_cid = (conv.conversation_id if conv else None) or cid or ""
+            if conv is not None:
+                u = getattr(conv, "last_turn_usage", None)
+                if callable(u):
+                    u = u()
+                if u is not None:
+                    d = u.model_dump() if hasattr(u, "model_dump") else {}
+                    emit({"event": "usage",
+                          "input_tokens": int(d.get("prompt_token_count") or 0),
+                          "output_tokens": int(d.get("candidates_token_count") or 0),
+                          "thinking_tokens": int(d.get("thoughts_token_count") or 0),
+                          "total_tokens": int(d.get("total_token_count") or 0)})
+            emit({"event": "done", "conversation_id": new_cid,
+                  "turn_ms": int((time.time() - t0) * 1000)})
+        except Exception as e:  # noqa: BLE001 — surface everything to the host
+            emit({"event": "error", "error": f"{type(e).__name__}: {e}",
+                  "recoverable": True})
+        finally:
+            try:
+                await agent.__aexit__(None, None, None)
+            except Exception:
+                pass
+
+    async def handle_approval(self, req):
+        aid = req.get("id")
+        if aid in self.pending_approvals:
+            self.approval_results[aid] = bool(req.get("allow"))
+            self.pending_approvals.pop(aid).set()
+
+    async def wait_approval(self, aid, timeout=120.0):
+        ev = asyncio.Event()
+        self.pending_approvals[aid] = ev
+        try:
+            await asyncio.wait_for(ev.wait(), timeout)
+            return self.approval_results.get(aid, False)
+        except asyncio.TimeoutError:
+            self.pending_approvals.pop(aid, None)
+            return False
+
+    async def main_loop(self):
+        loop = asyncio.get_event_loop()
+
+        async def read_stdin():
+            # Dedicated reader: approval ops must arrive WHILE a prompt is
+            # in flight (the prompt handler blocks its own coroutine).
+            while True:
+                line = await loop.run_in_executor(None, sys.stdin.readline)
+                if not line:
+                    self.host_gone = True
+                    return
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    req = json.loads(line)
+                except json.JSONDecodeError as e:
+                    emit({"event": "error", "error": f"bad json: {e}", "recoverable": False})
+                    continue
+                op = req.get("op")
+                if op == "approval":
+                    await self.handle_approval(req)
+                elif op == "ping":
+                    emit({"event": "pong"})
+                else:
+                    await self.ops.put(req)  # close included: processed in order
+
+        self.host_gone = False
+        self.ops = asyncio.Queue()
+        reader = asyncio.ensure_future(read_stdin())
+        try:
+            while not self.host_gone:
+                req = await self.ops.get()
+                op = req.get("op")
+                if op == "start":
+                    await self.handle_start(req)
+                elif op == "prompt":
+                    await self.handle_prompt(req)
+                elif op == "close":
+                    emit({"event": "closed"})
+                    return
+                else:
+                    emit({"event": "error", "error": f"unknown op {op!r}", "recoverable": False})
+        finally:
+            reader.cancel()
+
+
+def _sdk_hooks():
+    from google.antigravity import hooks as hooks_mod
+    return hooks_mod
+
+
+try:
+    _HOOKS = _sdk_hooks()
+    _DECIDE_BASE = _HOOKS.PreToolCallDecideHook
+except Exception:  # pragma: no cover — SDK absent in pure-syntax checks
+    _DECIDE_BASE = object
+
+
+class PreToolApprovalBridge(_DECIDE_BASE):
+    """Ask the host over the bridge protocol before every tool call (ask mode)."""
+
+    def __init__(self, bridge: Bridge):
+        self.bridge = bridge
+
+    async def run(self, context, data):  # SDK DecideHook protocol
+        aid = uuid.uuid4().hex
+        emit({"event": "approval_request", "id": aid,
+              "tool": str(getattr(data, "name", "unknown")),
+              "args": str(getattr(data, "args", "") or "")[:400]})
+        allow = await self.bridge.wait_approval(aid)
+        return _HOOKS.HookResult(allow=allow, message=None if allow else "denied by user")
+
+
+async def main():
+    bridge = Bridge()
+    await bridge.main_loop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/agent-agy/bridge/gemini_openai_server.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * gemini_openai_server.mjs — SPIKE: minimal Gemini-protocol front → OpenAI
+ * chat/completions back. Enough surface for the google-antigravity SDK's
+ * generateContent path: text messages, system instruction, SSE streaming,
+ * usage passthrough. Tools / multimodal are NOT translated (spike scope).
+ *
+ * Usage: node gemini_openai_server.mjs <listenPort> <openaiBaseUrl> <openaiKey> <openaiModel>
+ */
+import http from "node:http";
+
+const [port, oaBase, oaKey, oaModel] = process.argv.slice(2);
+const UP = `${oaBase.replace(/\/$/, "")}/chat/completions`;
+
+function g2o(req) {
+  const messages = [];
+  const sys = req.systemInstruction ?? req.system_instruction;
+  const sysText = sys ? partsText(sys.parts ?? sys.parts === undefined ? sys.parts ?? [] : []) : "";
+  if (sysText) messages.push({ role: "system", content: sysText });
+  for (const c of req.contents ?? []) {
+    const t = partsText(c.parts ?? []);
+    if (t) messages.push({ role: c.role === "model" ? "assistant" : "user", content: t });
+  }
+  return { model: oaModel, messages, stream: req.__stream === true };
+}
+function partsText(parts) {
+  return (parts ?? []).map((p) => (typeof p === "string" ? p : p.text ?? "")).join("");
+}
+function o2g(oa, model) {
+  return {
+    candidates: [{
+      content: { role: "model", parts: [{ text: oa.choices?.[0]?.message?.content ?? "" }] },
+      finishReason: oa.choices?.[0]?.finish_reason === "length" ? "MAX_TOKENS" : "STOP",
+    }],
+    usageMetadata: oa.usage
+      ? { promptTokenCount: oa.usage.prompt_tokens, candidatesTokenCount: oa.usage.completion_tokens, totalTokenCount: oa.usage.total_tokens }
+      : undefined,
+    modelVersion: model,
+  };
+}
+async function callUpstream(body) {
+  const r = await fetch(UP, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${oaKey}` },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) throw new Error(`upstream ${r.status}: ${(await r.text()).slice(0, 200)}`);
+  return r;
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, "http://x");
+  if (req.method === "GET" && url.pathname.endsWith("/models")) {
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ models: [{ name: `models/${oaModel}`, supportedGenerationMethods: ["generateContent", "streamGenerateContent"] }] }));
+    return;
+  }
+  if (req.method !== "POST") { res.writeHead(404).end(); return; }
+  let raw = "";
+  for await (const c of req) raw += c;
+  let g; try { g = JSON.parse(raw); } catch { res.writeHead(400).end(); return; }
+  const streaming = url.pathname.includes("streamGenerateContent");
+  const body = g2o({ ...g, __stream: streaming });
+  try {
+    if (!streaming) {
+      const oa = await (await callUpstream(body)).json();
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(o2g(oa, oa.model)));
+    } else {
+      res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+      const up = await callUpstream(body);
+      const dec = new TextDecoder();
+      let buf = "";
+      for await (const chunk of up.body) {
+        buf += dec.decode(chunk, { stream: true });
+        let i;
+        while ((i = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+          if (!line.startsWith("data:")) continue;
+          const payload = line.slice(5).trim();
+          if (payload === "[DONE]") continue;
+          const oa = JSON.parse(payload);
+          const delta = oa.choices?.[0]?.delta?.content ?? "";
+          const ev = {
+            candidates: [{ content: { role: "model", parts: [{ text: delta }] } }],
+          };
+          if (oa.usage) ev.usageMetadata = { promptTokenCount: oa.usage.prompt_tokens, candidatesTokenCount: oa.usage.completion_tokens, totalTokenCount: oa.usage.total_tokens };
+          res.write(`data: ${JSON.stringify(ev)}\n\n`);
+        }
+      }
+      res.end();
+    }
+  } catch (e) {
+    res.writeHead(502, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: { code: 502, message: String(e.message ?? e) } }));
+  }
+});
+server.listen(Number(port), "127.0.0.1", () => console.log(`gemini-openai spike on ${port} -> ${oaModel}`));

package/agent-agy/cordis.patch.yml

@@ -0,0 +1,49 @@
+# @pgmi-builds/agent-adapter-agy bundle patch (AW-G SDK line, pi/hermes form).
+# The `dsh.bundle.patch` layer of the adapter package: mounts the agy provider
+# and disables the native components it replaces. Port/webserver posture is
+# NOT here (worldMountPatches owns it); the world profile patch pins the home.
+#
+# Auth (2026-09-18 consumer-first ruling, 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.
+
+- insert:
+    - id: agy-provider
+      name: '@pgmi-builds/agent-adapter-agy'
+
+# 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.
+- id: agent-presets
+  disabled: true
+- 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/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/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/dist/agent-preset-agy.d.ts

@@ -0,0 +1,47 @@
+/**
+ * SingleAgyPresetRoster — the profile's `agentPresets` service.
+ *
+ * Antigravity is single-mode: the agy CLI/SDK bridge drives its own tools, so
+ * no Dash-side preset composition exists to choose from. But the web surfaces
+ * (new-session mode dropdown, Settings → Agent Preset) render from the roster
+ * RPC, and an absent roster renders "empty" rather than "one mode". This
+ * service publishes exactly one non-authorable preset, `Antigravity`, whose
+ * composition is deliberately empty — mounting it composes nothing, exactly
+ * the rosterless behavior the provider runs on.
+ *
+ * REGISTRATION LESSON (ported verbatim from the omp bridge via hermes): this
+ * service must be constructed on the PROVIDER's own top-level fiber, never
+ * under `ctx.plugin(...)` — a child fiber hides its @Remote routes from the
+ * API gateway's root-level remote enumeration and every agentPresets/* call
+ * 404s.
+ */
+import { type Context } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { type Agent } from "@deepseek-ai/dsh-agent";
+import { type AgentPreset, type AgentPresetDocument, type AgentPresetRoster } from "@deepseek-ai/dsh-agent-presets";
+import type { ScopeKey } from "@deepseek-ai/dsh-scope";
+export declare class SingleAgyPresetRoster extends TypertRemoteService {
+    constructor(ctx: Context);
+    get defaultId(): string;
+    get roots(): readonly never[];
+    get authorable(): boolean;
+    list(): Promise<AgentPreset[]>;
+    resolve(id?: string): Promise<AgentPreset>;
+    mount(_agentCtx: Context, id?: string): Promise<AgentPreset>;
+    recompose(_agentCtx: Context, id: string): Promise<AgentPreset>;
+    read(id: string): Promise<string>;
+    remoteList(): Promise<AgentPresetRoster>;
+    remoteRead(agentPreset: string): Promise<AgentPresetDocument>;
+    remoteCopy(from: string, id: string, name?: string): Promise<void>;
+    remoteDelete(id: string): Promise<void>;
+    /** Fixed roster: one preset, so selecting it is a no-op ack; anything else is unknown. */
+    remoteSelect(agent: Agent, agentPreset: string): Promise<string>;
+    copy(_from: string, id: string, _name?: string): Promise<void>;
+    remove(id: string): Promise<void>;
+    serviceFor(_agent: {
+        ctx: Context;
+    }, _name: string): undefined;
+    composeFrom(_agentCtx: Context, _parentCtx: Context): undefined;
+    composedPreset(_agentCtx: Context): string | undefined;
+    standingKeyFor(id?: string): Promise<ScopeKey>;
+}

package/agent-agy/dist/agent-preset-agy.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 AGY_PRESET = Object.freeze({
+    id: "agy",
+    trust: "system",
+    path: "",
+    name: "Antigravity",
+    description: "Google Antigravity (Gemini) via the agent-agy adapter",
+});
+const COMPOSITION_TEXT = [
+    "# Antigravity (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the Antigravity provider bridges Dash",
+    "sessions to the google-antigravity runtime (CLI stream-json primary, SDK bridge",
+    "fallback). There is no per-session plugin composition to configure, so this",
+    "preset mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `agy` session reads presenters through. */
+const STANDING_KEY = {};
+let SingleAgyPresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SingleAgyPresetRoster 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 AGY_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [AGY_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === AGY_PRESET.id)
+                return AGY_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: agy)`, { agentPreset: id, available: [AGY_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.AGY_TRACE === "1")
+                process.stderr.write("[agy-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: AGY_PRESET.id,
+                        trust: AGY_PRESET.trust,
+                        isDefault: true,
+                        name: AGY_PRESET.name,
+                        description: AGY_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 Antigravity roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Antigravity 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 Antigravity roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Antigravity roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return AGY_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SingleAgyPresetRoster };