super-dsh 0.1.9 → 0.1.10-e

package/{agent-agy → agent-agy-sdk}/dist/agy-client.d.ts

@@ -5,6 +5,8 @@
  * Discipline (agent-adapter-dev-rules §14-i / §16a):
  * - LAZY: no python child until the first real prompt. `start` config is
  *   buffered and flushed with the first `prompt` (one round trip).
+ * - LAZY VENV (2026-10-02 ruling): the durable Python venv is fetched on that
+ *   same first use, into the world home — never at install time (sdk-venv.ts).
  * - Transient spawn failures retry in-place up to AGY_SPAWN_ATTEMPTS (3);
  *   prompt-level errors are surfaced, never auto-retried.
  * - The agy CLI is never invoked; auth is transparent (api_key param or ADC
@@ -23,8 +25,17 @@ export interface AgyClientOptions {
     location?: string;
     workspaces?: string[];
     saveDir?: string;
-    /** Python interpreter (test knob; prod resolves via PATH). */
+    /**
+     * Python interpreter override. Set → the durable venv is NOT fetched
+     * (tests point this at `process.execPath` for the mock bridge; an operator
+     * can point it at an interpreter that already has the SDK).
+     */
     pythonBin?: string;
+    /**
+     * World home anchoring the durable SDK venv (`<worldHome>/sdk-venv`). Absent
+     * ⇒ the venv root falls back to `$DSH_HOME/agents/agy-sdk`.
+     */
+    worldHome?: string;
     /** Bridge script override (tests point this at a mock). */
     bridgePath?: string;
     spawnAttempts?: number;
@@ -128,6 +139,8 @@ export declare class AgyBridgeClient {
     }) => void): void;
     private dead;
     private startedSent;
+    /** In-flight first-use bootstrap (venv fetch + spawn); cleared when it settles. */
+    private spawnPromise;
     private lastUsageValue;
     /** Per-turn token usage from the bridge (undefined when the bridge skipped it). */
     get lastUsage(): AgyTurnUsage | undefined;
@@ -137,9 +150,18 @@ export declare class AgyBridgeClient {
     constructor(opts?: AgyClientOptions);
     get conversationId(): string;
     private resolveBridgePath;
-    /** Durable venv created by scripts/setup-venv.sh (pkg-root/.venv). */
-    private resolvePackagedVenvPython;
-    private spawnBridge;
+    /** The world home anchoring the durable venv (default `$DSH_HOME/agents/agy-sdk`). */
+    private worldHome;
+    /**
+     * Resolve the interpreter and spawn the child, once.
+     *
+     * Interpreter precedence: explicit `pythonBin` (tests / operator override) →
+     * `AGY_PYTHON` → the durable world-home venv, fetched on this first use.
+     * Concurrent first turns share one in-flight bootstrap.
+     */
+    private ensureChild;
+    private spawnOnce;
+    private spawnWith;
     private consume;
     private dispatch;
     private nextEvent;
@@ -156,5 +178,3 @@ export declare class AgyBridgeClient {
     turn(text: string): AsyncGenerator<string, string, void>;
     close(): Promise<void>;
 }
-/** Convenience: read the venv python path recorded by scripts/setup-venv.sh. */
-export declare function resolveVenvPython(worldHome: string): string | undefined;

package/{agent-agy → agent-agy-sdk}/dist/agy-client.js

@@ -5,15 +5,18 @@
  * Discipline (agent-adapter-dev-rules §14-i / §16a):
  * - LAZY: no python child until the first real prompt. `start` config is
  *   buffered and flushed with the first `prompt` (one round trip).
+ * - LAZY VENV (2026-10-02 ruling): the durable Python venv is fetched on that
+ *   same first use, into the world home — never at install time (sdk-venv.ts).
  * - Transient spawn failures retry in-place up to AGY_SPAWN_ATTEMPTS (3);
  *   prompt-level errors are surfaced, never auto-retried.
  * - The agy CLI is never invoked; auth is transparent (api_key param or ADC
  *   environment picked up by the SDK itself).
  */
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { ensureSdkVenv, resolveSdkPython } from "./sdk-venv.js";
 const BRIDGE_RELATIVE = join("bridge", "agy_bridge.py");
 export class AgyBridgeClient {
     child;
@@ -30,6 +33,8 @@ export class AgyBridgeClient {
     setToolEventHandler(handler) { }
     dead = false;
     startedSent = false;
+    /** In-flight first-use bootstrap (venv fetch + spawn); cleared when it settles. */
+    spawnPromise;
     lastUsageValue = undefined;
     /** Per-turn token usage from the bridge (undefined when the bridge skipped it). */
     get lastUsage() {
@@ -59,25 +64,46 @@ export class AgyBridgeClient {
         }
         throw new Error(`agy bridge script not found (${BRIDGE_RELATIVE})`);
     }
-    /** Durable venv created by scripts/setup-venv.sh (pkg-root/.venv). */
-    resolvePackagedVenvPython() {
+    /** The world home anchoring the durable venv (default `$DSH_HOME/agents/agy-sdk`). */
+    worldHome() {
+        if (this.opts.worldHome)
+            return this.opts.worldHome;
+        const dshHome = process.env.DSH_HOME;
+        if (typeof dshHome === "string" && dshHome !== "")
+            return join(dshHome, "agents", "agy-sdk");
+        return join(process.env.HOME ?? "", ".dsh", "agents", "agy-sdk");
+    }
+    /**
+     * Resolve the interpreter and spawn the child, once.
+     *
+     * Interpreter precedence: explicit `pythonBin` (tests / operator override) →
+     * `AGY_PYTHON` → the durable world-home venv, fetched on this first use.
+     * Concurrent first turns share one in-flight bootstrap.
+     */
+    ensureChild() {
+        if (this.child || this.dead)
+            return Promise.resolve();
+        this.spawnPromise ??= this.spawnOnce();
+        return this.spawnPromise;
+    }
+    async spawnOnce() {
         try {
-            const pkgRoot = join(dirname(this.resolveBridgePath()), "..");
-            const venv = join(pkgRoot, ".venv", "bin", "python");
-            return existsSync(venv) ? venv : undefined;
+            const worldHome = this.worldHome();
+            const pythonBin = this.opts.pythonBin
+                ?? process.env.AGY_PYTHON
+                ?? resolveSdkPython(worldHome)
+                ?? await ensureSdkVenv(worldHome, {
+                    ...(this.opts.trace === undefined ? {} : { trace: this.opts.trace }),
+                });
+            if (!this.child && !this.dead)
+                this.spawnWith(pythonBin);
         }
-        catch {
-            return undefined;
+        finally {
+            this.spawnPromise = undefined;
         }
     }
-    spawnBridge() {
-        if (this.child || this.dead)
-            return;
+    spawnWith(pythonBin) {
         const attempts = this.opts.spawnAttempts ?? 3;
-        const pythonBin = this.opts.pythonBin
-            ?? this.resolvePackagedVenvPython()
-            ?? process.env.AGY_PYTHON
-            ?? "python3";
         const bridgePath = this.resolveBridgePath();
         for (let attempt = 1; attempt <= attempts; attempt++) {
             try {
@@ -152,7 +178,7 @@ export class AgyBridgeClient {
     }
     /** Ping round trip (spawns the bridge if needed — use for liveness probes). */
     async ping() {
-        this.spawnBridge();
+        await this.ensureChild();
         this.send({ op: "ping" });
         await this.expect("pong");
     }
@@ -162,7 +188,7 @@ export class AgyBridgeClient {
      * Yields streamed text chunks; resolves with the full turn text.
      */
     async *turn(text) {
-        this.spawnBridge();
+        await this.ensureChild();
         if (!this.startedSent) {
             this.send({
                 op: "start",
@@ -242,11 +268,3 @@ export class AgyBridgeClient {
         this.child = undefined;
     }
 }
-/** Convenience: read the venv python path recorded by scripts/setup-venv.sh. */
-export function resolveVenvPython(worldHome) {
-    const p = join(worldHome, "agy-venv-python.txt");
-    if (!existsSync(p))
-        return undefined;
-    const v = readFileSync(p, "utf8").trim();
-    return v || undefined;
-}

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

@@ -0,0 +1,25 @@
+/** Prod homes that must never be resolved into (repo red line). */
+/** One persisted DSH → Antigravity conversation pairing. */
+export interface AgySessionRecord {
+    /** The SDK conversation id; `null` until the first turn materializes it. */
+    readonly conversationId: string | null;
+    /** The cwd the bridge session was (or is to be) spawned in. */
+    readonly cwd: string;
+    /** Epoch ms of the DSH session's creation. */
+    readonly createdAt: number;
+    /** Record-only permission preset at create, when one was known. */
+    readonly preset: string | null;
+}
+export type AgySessionMap = Record<string, AgySessionRecord>;
+/**
+ * The adapter's DSH-side world home. Form-A (boot home = DSH home root) nests
+ * `agents/agy`; Form-B (already `<root>/agents/agy`) passes through.
+ */
+export declare function resolveAgyWorldHome(home?: string): string;
+export declare function sessionMapPath(home?: string): string;
+/** Read the map. Fail-soft: missing or malformed file reads as `{}`. */
+export declare function readSessionMap(home?: string): AgySessionMap;
+/** One session's record, or `undefined` when the id is unknown. */
+export declare function sessionRecord(home: string | undefined, dshSessionId: string): AgySessionRecord | undefined;
+/** Insert or merge one record, persisted atomically (temp file + rename). */
+export declare function upsertSession(home: string | undefined, dshSessionId: string, patch: Partial<AgySessionRecord>): AgySessionRecord;

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

@@ -0,0 +1,107 @@
+/**
+ * DSH-session ↔ Antigravity-conversation identity map (the "mapping only"
+ * model, mirroring hermes-store.ts; 2026-09-18).
+ *
+ * The DSH session id is the authority. The SDK's `conversationId` only
+ * materializes after the first turn (first bridge prompt), so the pairing is
+ * persisted in the adapter's DSH-side app dir — `<worldHome>/dsh-sessions.json`
+ * (never the runtime's native `~/.gemini`). Mapping only: resume resolves the
+ * record or fails closed; native conversation storage is never scanned.
+ *
+ * Shape: `{ "<dshSessionId>": { conversationId, cwd, createdAt, preset } }` —
+ * `conversationId` is `null` until the first turn materializes it.
+ */
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+/**
+ * The adapter's DSH-side world home. Form-A (boot home = DSH home root) nests
+ * `agents/agy`; Form-B (already `<root>/agents/agy`) passes through.
+ */
+export function resolveAgyWorldHome(home) {
+    const base = resolve(home ?? process.env.DSH_HOME ?? join(process.cwd(), ".tests", "superd"));
+    const dir = basename(base) === "agy" && basename(dirname(base)) === "agents" ? base : join(base, "agents", "agy");
+    return dir;
+}
+export function sessionMapPath(home) {
+    return join(resolveAgyWorldHome(home), "dsh-sessions.json");
+}
+/** Read the map. Fail-soft: missing or malformed file reads as `{}`. */
+export function readSessionMap(home) {
+    let raw;
+    try {
+        raw = readFileSync(sessionMapPath(home), "utf8");
+    }
+    catch {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const out = {};
+    for (const [id, value] of Object.entries(parsed)) {
+        const record = coerceRecord(value);
+        if (record !== undefined)
+            out[id] = record;
+    }
+    return out;
+}
+function coerceRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const cwd = raw["cwd"];
+    const createdAt = raw["createdAt"];
+    if (typeof cwd !== "string" || cwd === "")
+        return undefined;
+    const conversationId = raw["conversationId"];
+    const preset = raw["preset"];
+    return {
+        conversationId: typeof conversationId === "string" && conversationId !== "" ? conversationId : null,
+        cwd,
+        createdAt: typeof createdAt === "number" && Number.isFinite(createdAt) ? createdAt : 0,
+        preset: typeof preset === "string" && preset !== "" ? preset : null,
+    };
+}
+/** One session's record, or `undefined` when the id is unknown. */
+export function sessionRecord(home, dshSessionId) {
+    return readSessionMap(home)[dshSessionId];
+}
+/** Insert or merge one record, persisted atomically (temp file + rename). */
+export function upsertSession(home, dshSessionId, patch) {
+    const path = sessionMapPath(home);
+    const map = readSessionMap(home);
+    const previous = map[dshSessionId];
+    const next = {
+        conversationId: patch.conversationId !== undefined ? patch.conversationId : previous?.conversationId ?? null,
+        cwd: patch.cwd !== undefined ? patch.cwd : previous?.cwd ?? "",
+        createdAt: patch.createdAt !== undefined ? patch.createdAt : previous?.createdAt ?? Date.now(),
+        preset: patch.preset !== undefined ? patch.preset : previous?.preset ?? null,
+    };
+    map[dshSessionId] = next;
+    writeMapAtomic(path, map);
+    return next;
+}
+function writeMapAtomic(path, map) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(map, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The rename failure is primary.
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * agy-store.ts — adapter-owned state + native-home read-only access.
+ *
+ * Home discipline (agent-adapter-dev-rules §5/§13/§16a):
+ * - Adapter state (Gemini API key, cached default model) lives in the WORLD
+ *   DSH home: `<worldHome>/agy-adapter.json`. Never written into `~/.gemini`.
+ * - The native home (`~/.gemini`) is READ-ONLY for us: default model comes
+ *   from `~/.gemini/antigravity-cli/settings.json` (`model` field). Paths are
+ *   injectable so tests use fixtures instead of env knobs (prod path has no
+ *   redirection).
+ */
+export interface AgyAdapterState {
+    /** Gemini API key the user pasted through the onboarding session. */
+    apiKey?: string;
+    /** Cached default model slug (from native settings or catalog head). */
+    defaultModel?: string;
+}
+export declare function adapterStatePath(worldHome: string): string;
+export declare function readAdapterState(worldHome: string): AgyAdapterState;
+export declare function writeAdapterState(worldHome: string, state: AgyAdapterState): void;
+/**
+ * ADC evidence probe: the SDK picks up Application Default Credentials on its
+ * own, so their mere existence satisfies auth (§16a transparency). Checks the
+ * two standard sources — the env-pointed service-account key and the gcloud
+ * user ADC file. Read-only; paths injectable for tests.
+ */
+export declare function hasAdcEvidence(env: NodeJS.ProcessEnv, home: string): boolean;
+/**
+ * Read the gcloud CLI default project (ADC companion): the SDK's Vertex
+ * endpoint needs an explicit project when no api_key is given. Parses
+ * `~/.config/gcloud/configurations/config_default` (read-only, fixture-friendly).
+ */
+export declare function readGcloudProject(home: string): string | undefined;
+/**
+ * Default model as the agy TUI would report it. Read-only probe of the
+ * native home; missing file / missing field → undefined (caller falls back
+ * to the static catalog head).
+ */
+export declare function readNativeDefaultModel(nativeHome: string): string | undefined;

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

@@ -0,0 +1,83 @@
+/**
+ * agy-store.ts — adapter-owned state + native-home read-only access.
+ *
+ * Home discipline (agent-adapter-dev-rules §5/§13/§16a):
+ * - Adapter state (Gemini API key, cached default model) lives in the WORLD
+ *   DSH home: `<worldHome>/agy-adapter.json`. Never written into `~/.gemini`.
+ * - The native home (`~/.gemini`) is READ-ONLY for us: default model comes
+ *   from `~/.gemini/antigravity-cli/settings.json` (`model` field). Paths are
+ *   injectable so tests use fixtures instead of env knobs (prod path has no
+ *   redirection).
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function adapterStatePath(worldHome) {
+    return join(worldHome, "agy-adapter.json");
+}
+export function readAdapterState(worldHome) {
+    const p = adapterStatePath(worldHome);
+    if (!existsSync(p))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(p, "utf8"));
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeAdapterState(worldHome, state) {
+    writeFileSync(adapterStatePath(worldHome), JSON.stringify(state, null, 2) + "\n");
+}
+/**
+ * ADC evidence probe: the SDK picks up Application Default Credentials on its
+ * own, so their mere existence satisfies auth (§16a transparency). Checks the
+ * two standard sources — the env-pointed service-account key and the gcloud
+ * user ADC file. Read-only; paths injectable for tests.
+ */
+export function hasAdcEvidence(env, home) {
+    const fromEnv = env.GOOGLE_APPLICATION_CREDENTIALS;
+    if (typeof fromEnv === "string" && fromEnv !== "" && existsSync(fromEnv))
+        return true;
+    return existsSync(join(home, ".config", "gcloud", "application_default_credentials.json"));
+}
+/**
+ * Read the gcloud CLI default project (ADC companion): the SDK's Vertex
+ * endpoint needs an explicit project when no api_key is given. Parses
+ * `~/.config/gcloud/configurations/config_default` (read-only, fixture-friendly).
+ */
+export function readGcloudProject(home) {
+    const p = join(home, ".config", "gcloud", "configurations", "config_default");
+    if (!existsSync(p))
+        return undefined;
+    try {
+        for (const line of readFileSync(p, "utf8").split("\n")) {
+            const m = /^\s*project\s*=\s*(\S+)\s*$/.exec(line);
+            if (m)
+                return m[1];
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return undefined;
+}
+/**
+ * Default model as the agy TUI would report it. Read-only probe of the
+ * native home; missing file / missing field → undefined (caller falls back
+ * to the static catalog head).
+ */
+export function readNativeDefaultModel(nativeHome) {
+    const p = join(nativeHome, "antigravity-cli", "settings.json");
+    if (!existsSync(p))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(p, "utf8"));
+        return typeof parsed.model === "string" && parsed.model.length > 0
+            ? parsed.model
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Minimal in-memory inbox for the Hermes agent shim.
+ *
+ * The 0.1.5 `dsh-agent` contract exposes the inbox as an interface
+ * (`Inbox` in `runtime-types`); the durable projection-backed implementation
+ * (`ReactLoopInbox`) lives inside the (disabled) `dsh-agent-loop`. Hermes owns
+ * its own transcript and the adapter delivers messages directly to the Hermes
+ * client (`HermesAgent.#deliver`), so this inbox is never queued into — it
+ * exists to satisfy the `Agent` interface's `inbox` surface with correct
+ * (empty) semantics: `nextTurn`/`nextStep` stay empty and every mutation is
+ * a faithful in-memory splice.
+ */
+import type { Inbox as InboxContract, InboxTarget } from "@deepseek-ai/dsh-agent";
+import type { UserMessage } from "@deepseek-ai/dsh-session";
+import type { MessageId } from "@deepseek-ai/dsh-llm";
+export declare class Inbox implements InboxContract {
+    #private;
+    get nextTurn(): readonly UserMessage[];
+    get nextStep(): readonly UserMessage[];
+    clear(): void;
+    append(target: InboxTarget, message: UserMessage): void;
+    prepend(target: InboxTarget, message: UserMessage): void;
+    replace(messageId: MessageId, newMessage: UserMessage): boolean;
+    remove(messageId: MessageId): boolean;
+    splice(target: InboxTarget, start: number, deleteCount: number, inserted: UserMessage[]): UserMessage[];
+}

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

@@ -0,0 +1,53 @@
+export class Inbox {
+    #nextTurn = [];
+    #nextStep = [];
+    get nextTurn() {
+        return this.#nextTurn;
+    }
+    get nextStep() {
+        return this.#nextStep;
+    }
+    clear() {
+        this.#nextTurn = [];
+        this.#nextStep = [];
+    }
+    append(target, message) {
+        this.#list(target).push(message);
+    }
+    prepend(target, message) {
+        this.#list(target).unshift(message);
+    }
+    replace(messageId, newMessage) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1, newMessage);
+        return true;
+    }
+    remove(messageId) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1);
+        return true;
+    }
+    splice(target, start, deleteCount, inserted) {
+        return this.#list(target).splice(start, deleteCount, ...inserted);
+    }
+    #list(target) {
+        return target === "next-turn" ? this.#nextTurn : this.#nextStep;
+    }
+    #find(messageId) {
+        if (this.#nextTurn.some((message) => message.id === messageId))
+            return this.#nextTurn;
+        if (this.#nextStep.some((message) => message.id === messageId))
+            return this.#nextStep;
+        return undefined;
+    }
+}

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

@@ -0,0 +1,93 @@
+/**
+ * agent-agy-sdk provider — Google Antigravity provider plugin for DeepSeek
+ * Harness (Super D, opt-in SDK line, 2026-10-02 split).
+ *
+ * The SDK half of the Antigravity split. 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;
+ * this package NEVER invokes the agy CLI — dev-rules §16a). The CLI transport
+ * is the sibling package `@pgmi-builds/agent-agy`.
+ *
+ * Session identity ("mapping only"): the DSH session id is the authority,
+ * supplied by the harness. The SDK 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
+ * log is the transcript authority, written through the upstream
+ * `sessionPersistence` service (hermes create/resume transaction shape).
+ *
+ * Deployment (2026-10-02 user ruling): the composite ships this row DISABLED
+ * and the package declares NO Python dependency and no postinstall — the
+ * durable venv under the world home is fetched lazily on first real use
+ * (sdk-venv.ts).
+ */
+import { Context, Service } from "@deepseek-ai/cordis";
+import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from "@deepseek-ai/dsh-agent";
+/** Test/override knobs for the bridge child (prod: all unset). */
+export interface AgyProviderOptions {
+    bridgePath?: string;
+    pythonBin?: string;
+    spawnAttempts?: number;
+    /** Native home override for tests (prod: ~/.gemini, read-only). */
+    nativeHome?: string;
+    /** Vertex project/location override (ADC mode). Default: gcloud CLI config. */
+    project?: string;
+    location?: string;
+    /** Tool-approval posture surfaced to every session's bridge start frame. */
+    approvalMode?: "allow" | "ask";
+}
+export declare class AgyProvider extends Service implements AgentFactory {
+    static inject: string[];
+    /** Plain holder — prevents Cordis re-tracing the factory's ctx through a caller shadow. */
+    private readonly runtime;
+    /** The world's DSH home — anchors adapter-owned state (session map, api-key state). */
+    private readonly home;
+    private readonly opts;
+    private defaultModelKey;
+    constructor(ctx: Context, opts?: AgyProviderOptions);
+    /** The world's DSH home: boot-provided dshHomePath first, env last. */
+    private resolveHome;
+    /** Effective Gemini API key: adapter state first, then the environment. */
+    private resolveApiKey;
+    /**
+     * Auth evidence for the §17 onboarding gate: an API key (state or env) OR
+     * ADC evidence is enough — the SDK consumes either transparently, so a user
+     * with gcloud ADC must NOT be pushed into key onboarding.
+     */
+    private hasAuthEvidence;
+    /** Default model id: adapter state → native TUI default (slug-normalized) → catalog head. */
+    private resolveDefaultModelId;
+    /** Legacy slug-only default (default-model push keeps slug form). */
+    private resolveDefaultModel;
+    /** 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. */
+    private sessionAgentOptions;
+    private requirePersistence;
+    private agentRuntime;
+    /** Persist the Dash↔conversation pairing once the first turn materializes it. */
+    private readonly followConversationId;
+    private registerModelCatalog;
+    /** Push the resolved default model into the world's `agentDefaultModel`. */
+    private registerDefaultModel;
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+    /**
+       * Live transport: SDK-ONLY (2026-10-02 user ruling).
+       *
+       * This package is the opt-in SDK half of the Antigravity split: it drives the
+       * Python google-antigravity SDK through the JSONL bridge and NEVER invokes the
+       * user's `agy` CLI (that transport is `@pgmi-builds/agent-agy`).
+       * Auth (§16a transparency): a key from adapter state / `GEMINI_API_KEY` rides
+       * the start frame; without one the SDK falls back to ADC (Vertex, project read
+       * from the gcloud default). Neither ⇒ the §17 onboarding branch answers the
+       * first turn locally, before anything spawns.
+       */
+    private createLiveClient;
+    /** Bridge child options: world cwd + overrides; the api key rides the start config. */
+    private clientOptions;
+    private createStoredSession;
+}
+export default AgyProvider;