super-dsh 0.1.0 → 0.1.2

package/agent-agy/dist/agy-client.js

@@ -0,0 +1,252 @@
+/**
+ * agy-client.ts — drives the Python SDK bridge (bridge/agy_bridge.py) over
+ * JSONL stdio.
+ *
+ * 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).
+ * - 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 { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const BRIDGE_RELATIVE = join("bridge", "agy_bridge.py");
+export class AgyBridgeClient {
+    child;
+    buffer = "";
+    waiters = [];
+    pending = [];
+    opts;
+    spawnFailures = 0;
+    /** Thinking-delta sink (agent buffers these into a reasoning block). */
+    onThinkingDelta;
+    /** Tool lifecycle sink: tool_call / tool_result (agent writes DSH events). */
+    onToolEvent;
+    /** Bridge-protocol parity for the agent test harness (fake clients). */
+    setToolEventHandler(handler) { }
+    dead = false;
+    startedSent = false;
+    lastUsageValue = undefined;
+    /** Per-turn token usage from the bridge (undefined when the bridge skipped it). */
+    get lastUsage() {
+        return this.lastUsageValue;
+    }
+    /** Register the ask-mode approval handler (agent wires its approval service). */
+    setApprovalHandler(handler) {
+        this.opts.onApprovalRequest = handler;
+    }
+    conversationIdValue = "";
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    get conversationId() {
+        return this.conversationIdValue;
+    }
+    resolveBridgePath() {
+        if (this.opts.bridgePath)
+            return this.opts.bridgePath;
+        // dist/agy-client.js → package root is dist/.. (works through the
+        // world-profile symlink too: node reports the real path here).
+        const here = dirname(fileURLToPath(import.meta.url));
+        for (const base of [here, dirname(here)]) {
+            const p = join(base, BRIDGE_RELATIVE);
+            if (existsSync(p))
+                return p;
+        }
+        throw new Error(`agy bridge script not found (${BRIDGE_RELATIVE})`);
+    }
+    /** Durable venv created by scripts/setup-venv.sh (pkg-root/.venv). */
+    resolvePackagedVenvPython() {
+        try {
+            const pkgRoot = join(dirname(this.resolveBridgePath()), "..");
+            const venv = join(pkgRoot, ".venv", "bin", "python");
+            return existsSync(venv) ? venv : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    spawnBridge() {
+        if (this.child || this.dead)
+            return;
+        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 {
+                this.child = spawn(pythonBin, [bridgePath], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                break;
+            }
+            catch (err) {
+                this.opts.trace?.(`spawn attempt ${attempt} failed:`, err);
+                if (attempt === attempts)
+                    throw err;
+            }
+        }
+        const child = this.child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (d) => this.consume(d));
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (d) => this.opts.trace?.("[bridge stderr]", d.trimEnd()));
+        child.on("exit", (code) => {
+            this.child = undefined;
+            this.opts.trace?.(`bridge exited code=${code}`);
+            this.dispatch({ event: "error", error: `bridge exited code=${code}`, recoverable: !this.dead });
+        });
+    }
+    consume(data) {
+        this.buffer += data;
+        let idx;
+        while ((idx = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            try {
+                const ev = JSON.parse(line);
+                if (ev.event === "done" && ev.conversation_id)
+                    this.conversationIdValue = ev.conversation_id;
+                this.dispatch(ev);
+            }
+            catch (err) {
+                this.opts.trace?.("bad bridge json:", line, err);
+            }
+        }
+    }
+    dispatch(ev) {
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter(ev);
+        else
+            this.pending.push(ev);
+    }
+    nextEvent() {
+        const pending = this.pending.shift();
+        if (pending)
+            return Promise.resolve(pending);
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    send(obj) {
+        if (!this.child)
+            throw new Error("bridge not running");
+        this.child.stdin.write(JSON.stringify(obj) + "\n");
+    }
+    /** Wait for a specific event kind, surfacing `error` events as throws. */
+    async expect(kind) {
+        for (;;) {
+            const ev = await this.nextEvent();
+            if (ev.event === kind)
+                return ev;
+            if (ev.event === "error")
+                throw new Error(`agy bridge: ${ev.error}`);
+        }
+    }
+    /** Ping round trip (spawns the bridge if needed — use for liveness probes). */
+    async ping() {
+        this.spawnBridge();
+        this.send({ op: "ping" });
+        await this.expect("pong");
+    }
+    /**
+     * Run one turn. First call materializes the bridge child and sends the
+     * buffered `start` config followed by `prompt` (lazy spawn per §14-i).
+     * Yields streamed text chunks; resolves with the full turn text.
+     */
+    async *turn(text) {
+        this.spawnBridge();
+        if (!this.startedSent) {
+            this.send({
+                op: "start",
+                model: this.opts.model,
+                ...(this.opts.thinkingLevel === undefined ? {} : { thinking_level: this.opts.thinkingLevel }),
+                ...(this.opts.approvalMode === undefined ? {} : { approval_mode: this.opts.approvalMode }),
+                api_key: this.opts.apiKey,
+                project: this.opts.project,
+                location: this.opts.location,
+                workspaces: this.opts.workspaces,
+                save_dir: this.opts.saveDir,
+            });
+            await this.expect("started");
+            this.startedSent = true;
+        }
+        this.send({ op: "prompt", text, conversation_id: this.conversationIdValue || undefined });
+        let full = "";
+        this.lastUsageValue = undefined;
+        for (;;) {
+            const ev = await this.nextEvent();
+            if (ev.event === "chunk") {
+                full += ev.text;
+                yield ev.text;
+            }
+            else if (ev.event === "thinking") {
+                this.onThinkingDelta?.(ev.text);
+            }
+            else if (ev.event === "tool_call" || ev.event === "tool_result") {
+                this.onToolEvent?.(ev);
+            }
+            else if (ev.event === "tool") {
+                this.opts.trace?.("tool (legacy)", ev.name);
+            }
+            else if (ev.event === "usage") {
+                this.lastUsageValue = ev;
+            }
+            else if (ev.event === "approval_request") {
+                // ask mode only; fail closed when no handler / handler throws.
+                let allow = false;
+                try {
+                    allow = this.opts.onApprovalRequest
+                        ? await this.opts.onApprovalRequest({ id: ev.id, tool: ev.tool, args: ev.args })
+                        : false;
+                }
+                catch (err) {
+                    this.opts.trace?.("approval handler failed — deny:", err);
+                    allow = false;
+                }
+                this.send({ op: "approval", id: ev.id, allow });
+            }
+            else if (ev.event === "done") {
+                return full;
+            }
+            else if (ev.event === "error") {
+                throw new Error(`agy bridge: ${ev.error}`);
+            }
+        }
+    }
+    async close() {
+        if (!this.child)
+            return;
+        this.dead = true;
+        try {
+            this.send({ op: "close" });
+        }
+        catch {
+            /* child already gone */
+        }
+        const child = this.child;
+        setTimeout(() => {
+            if (!child.killed)
+                child.kill("SIGKILL");
+        }, 2000).unref();
+        await new Promise((resolve) => {
+            child.on("exit", () => resolve());
+        });
+        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/dist/agy-sessions.d.ts

@@ -0,0 +1,24 @@
+/** 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. Prod-guarded.
+ */
+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/dist/agy-sessions.js

@@ -0,0 +1,116 @@
+/**
+ * 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 { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+/** Prod homes that must never be resolved into (repo red line). */
+const PROD_HOMES = [join(homedir(), ".dsh"), join(homedir(), ".superd")];
+function assertNotProdHome(path, label) {
+    if (PROD_HOMES.includes(path) || PROD_HOMES.some((p) => path.startsWith(`${p}/`))) {
+        throw new Error(`agy-sessions: refusing prod home as ${label}: ${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. Prod-guarded.
+ */
+export function resolveAgyWorldHome(home) {
+    const base = resolve(home ?? process.env.DSH_HOME ?? join(process.cwd(), ".tests", "aw"));
+    const dir = basename(base) === "agy" && basename(dirname(base)) === "agents" ? base : join(base, "agents", "agy");
+    assertNotProdHome(dir, "agy world home");
+    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/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/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/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/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/dist/index.d.ts

@@ -0,0 +1,80 @@
+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";
+    /** danger-full-access → CLI --dangerously-skip-permissions (default: true, patch default preset). */
+    skipPermissions?: boolean;
+    /** agy binary override (CLI path tests). */
+    agyBin?: string;
+    /** Forward proxy for the geo-fenced Gemini API (CLI path; dev3 gost). */
+    proxy?: string;
+    /** HOME override for the CLI child (isolated key-mode home; dev knob). */
+    cliHome?: string;
+}
+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 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).
+     */
+    private createLiveClient;
+    /**
+     * The effective permission preset this provider was mounted with. The
+     * cordis.patch.yml default is danger-full-access; a patch-level override
+     * would surface through the permission service config, which we read
+     * best-effort (fail → the patch default).
+     */
+    private currentPermissionPreset;
+    /** CLI transport options: key-first default is the cheapest live pair. */
+    private cliOptions;
+    /** Bridge child options: world cwd + overrides; the api key rides the start config. */
+    private clientOptions;
+    private createStoredSession;
+}
+export default AgyProvider;