@khorsheed/dsh-local-agent-codex 0.2.0-rc.1 → 0.2.0-rc.3

package/lib/index.js

@@ -1,12 +1,12 @@
 import z from "@deepseek-ai/schemastery";
-import { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, modelDirectoryContextKey, persistChildSession, probeCliVersion, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol } from "@khorsheed/dsh-local-agent";
+import { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, firstModelOf, modelDirectoryContextKey, persistChildSession, probeCliVersion, readModelList, readModelListSync, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol, writeModelList } from "@khorsheed/dsh-local-agent";
 import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV, endpointHost } from "@khorsheed/dsh-local-agent/types";
 import { randomUUID } from "node:crypto";
 import { createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
-import { NO_START_CAPABILITIES, settleRunResult, subprocessRunHandle } from "@deepseek-ai/dsh-subagent";
+import { NO_START_CAPABILITIES, SUBAGENT_DESCRIPTOR_VERSION, settleRunResult, subprocessRunHandle } from "@deepseek-ai/dsh-subagent";
 import { StringDecoder } from "node:string_decoder";
-import { open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 //#region lib/types/records.js
 /**
@@ -38,21 +38,6 @@ const ROLLOUT_WINDOW_SLACK_MS = 3e5;
 /** Extra future slack for the window end (file timestamps may skew ahead). */
 const ROLLOUT_WINDOW_FUTURE_MS = 6e4;
 /**
-* Whether the scoped home holds usable Codex credentials: the `auth.json`
-* file exists. Absent means the device-code flow has not completed.
-* @param homeDir - the `codex` harness's scoped home.
-* @returns true when credentials are present.
-*/
-async function codexAuthenticated(homeDir) {
-	try {
-		await readFile(join(homeDir, "auth.json"));
-		return true;
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-}
-/**
 * Parse the first line of a rollout file for the listing fields. Unknown or
 * malformed values yield an undefined record rather than failing the list.
 * @param text - the raw rollout file content (only the head is read).
@@ -430,6 +415,293 @@ async function codexRolloutRoundFacts(homeDir, locator) {
 	};
 }
 //#endregion
+//#region lib/types/endpoint-auth.js
+/**
+* Endpoint-key authentication — the codex harness's ONLY auth mode. There is
+* no web login anywhere in this package: a delegation round reaches its
+* endpoint with a custom `model_providers` entry on the argv pointing at the
+* relay and the key traveling as `OPENAI_API_KEY` in the process environment
+* (verified against codex-cli 0.163.0: a fresh scoped home with only these
+* runs `codex exec` with no login file at all). With no credential the spawn
+* carries no auth at all — it fails loudly at the endpoint, exactly the
+* honest reading the status shows.
+*
+* Verified against codex-cli 0.163.0 (2026-10-20): a fresh scoped home with
+* only `OPENAI_API_KEY` plus the two `-c` overrides below runs
+* `codex exec -m <model>` end-to-end through an OpenAI-compatible relay
+* (openproxy, `wire_api = "responses"`) — no login, no auth.json, no
+* onboarding gate.
+*
+* Two layers, merged per field, file over config:
+*
+* - `<scopedHome>/endpoint-auth.json` (mode 0600) — the per-scope credential.
+*   Its name deliberately matches the eval contract hash's credential denylist
+*   (`auth`), so the key material never enters an evaluation's condition
+*   fingerprint; the file's mtime serves as the credential stamp, which makes
+*   "edit the file" the recovery gesture for a `rejected` grade.
+* - The plugin config's `baseUrl` / `apiKey` — the deployment default every
+*   scope without a file shares. Read PER ROUND, so a profile edit applies to
+*   the next round (and a host restart clears the in-memory `rejected` mark).
+*
+* `wireApi` is a file-only escape hatch: the settings card never edits it,
+* the default `responses` is codex's native wire (relay-verified), and a
+* hand-edit to `"chat"` survives the card's whole-file writes because the
+* read merges it back. The env layer rides the family's existing plumbing:
+* `delegationEnv` on the host, `containerExecSpawn`'s name-only `-e`
+* forwarding into a container — a containerized round authenticates with the
+* same credential as the host, nothing is authorized inside the unit.
+* @module @khorsheed/dsh-local-agent-codex/endpoint-auth
+*/
+/**
+* The scoped-home credential file's name. Chosen to match the eval contract
+* hash's credential-shaped denylist (`/token|key|credential|secret|password|auth|\.env/i`),
+* so the file is excluded from condition fingerprints by name.
+*/
+const ENDPOINT_AUTH_FILE = "endpoint-auth.json";
+/** The custom provider's TOML key in the `-c` overrides (bare-key safe). */
+const ENDPOINT_PROVIDER_NAME = "dsh-endpoint";
+/** The env var the custom provider reads the key from (`env_key`). */
+const ENDPOINT_ENV_KEY = "OPENAI_API_KEY";
+/** Trim and normalize one credential field; blank reads as absent. */
+function field(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/** Whether a resolved endpoint carries a usable credential. */
+function hasEndpointCredential(auth) {
+	return auth !== void 0 && field(auth.apiKey) !== void 0;
+}
+/**
+* Read the scope's endpoint-auth.json. Absent or unreadable yields undefined
+* (the caller falls back to the plugin config); malformed JSON or a non-object
+* payload also yields undefined — a torn file must not fail a status read.
+* Non-string fields are dropped, never carried through.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the file's endpoint credential, or undefined.
+*/
+async function readEndpointAuthFile(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, ENDPOINT_AUTH_FILE), "utf8");
+	} catch {
+		return;
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const baseUrl = field(parsed["baseUrl"]);
+		const apiKey = field(parsed["apiKey"]);
+		const wireApi = field(parsed["wireApi"]);
+		return {
+			...baseUrl === void 0 ? {} : { baseUrl },
+			...apiKey === void 0 ? {} : { apiKey },
+			...wireApi === void 0 ? {} : { wireApi }
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Resolve one scope's effective endpoint credential: the scope's
+* endpoint-auth.json merged FIELD BY FIELD over the plugin config's
+* `baseUrl` / `apiKey` (a file that names only a key rotates the key while
+* keeping the deployment's relay URL). The result may carry no credential at
+* all — {@link hasEndpointCredential} is the judgment, kept separate so the
+* caller can still route/log the resolved baseUrl.
+* @param homeDir - the scope's scoped home.
+* @param config - the plugin config's deployment-level endpoint pair.
+* @returns the merged endpoint auth.
+*/
+async function resolveEndpointAuth(homeDir, config) {
+	const file = await readEndpointAuthFile(homeDir);
+	const configBaseUrl = field(config.baseUrl);
+	const configApiKey = field(config.apiKey);
+	return {
+		...configBaseUrl === void 0 ? {} : { baseUrl: configBaseUrl },
+		...configApiKey === void 0 ? {} : { apiKey: configApiKey },
+		...file
+	};
+}
+/**
+* The spawn-env layer for a resolved endpoint: the key under the custom
+* provider's `env_key` name, nothing else. A credential-less resolution
+* yields an empty layer — the spread then adds no keys at all, byte-identical
+* to the pre-endpoint env. With no baseUrl the CLI's built-in OpenAI provider
+* reads the same variable, so an official platform key needs no `-c`
+* override either.
+* @param auth - the resolved endpoint auth, or undefined.
+* @returns the explicit env entries for the delegation spawn.
+*/
+function endpointAuthEnv(auth) {
+	const apiKey = field(auth?.apiKey);
+	return apiKey === void 0 ? {} : { [ENDPOINT_ENV_KEY]: apiKey };
+}
+/** Quote one TOML basic string for the `-c` config override. */
+function tomlString$1(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/**
+* The `-c` config overrides routing the CLI at the resolved relay: a custom
+* `model_providers` entry plus the `model_provider` selection, as a flat argv
+* fragment (`-c <override>` pairs). Empty unless BOTH a key and a baseUrl are
+* present — a key without a relay URL is served by the built-in provider
+* through the env layer alone, and a relay URL without a key would route
+* every round into a 401. Verified end-to-end against codex-cli 0.163.0.
+* @param auth - the resolved endpoint auth, or undefined.
+* @returns the argv fragment, possibly empty.
+*/
+function endpointConfigOverrides(auth) {
+	const baseUrl = field(auth?.baseUrl);
+	const apiKey = field(auth?.apiKey);
+	if (baseUrl === void 0 || apiKey === void 0) return [];
+	const wireApi = field(auth?.wireApi) ?? "responses";
+	return [
+		"-c",
+		`model_provider=${tomlString$1(ENDPOINT_PROVIDER_NAME)}`,
+		"-c",
+		`model_providers.${ENDPOINT_PROVIDER_NAME}={name=${tomlString$1(ENDPOINT_PROVIDER_NAME)},base_url=${tomlString$1(baseUrl)},env_key=${tomlString$1(ENDPOINT_ENV_KEY)},wire_api=${tomlString$1(wireApi)}}`
+	];
+}
+/**
+* The credential marker's modification stamp (epoch ms): the endpoint file's
+* mtime, or undefined when the scope has no file (a config-sourced credential
+* has no marker — rotating it pairs with the profile edit and instance
+* restart that clear the in-memory grade marks). A fresh file write is a
+* fresh stamp, which is how an edited-in key recovers a `rejected` grade.
+* @param homeDir - the scope's scoped home.
+* @returns the stamp, or undefined.
+*/
+async function endpointAuthStamp(homeDir) {
+	try {
+		return (await stat(join(homeDir, ENDPOINT_AUTH_FILE))).mtimeMs;
+	} catch {
+		return;
+	}
+}
+/** Whether the scope carries its own endpoint file at all. */
+async function endpointAuthFileExists(homeDir) {
+	return await endpointAuthStamp(homeDir) !== void 0;
+}
+/**
+* Write the scope's endpoint-auth.json (mode 0600, mkdir -p first). The
+* payload preserves the file-only `wireApi` across card writes: callers pass
+* the merged object (current file + edits), never a bare card payload.
+* @param homeDir - the scope's scoped home.
+* @param auth - the endpoint credential to persist.
+*/
+async function writeEndpointAuth(homeDir, auth) {
+	await mkdir(homeDir, { recursive: true });
+	const baseUrl = field(auth.baseUrl);
+	const apiKey = field(auth.apiKey);
+	const wireApi = field(auth.wireApi);
+	const payload = {
+		...baseUrl === void 0 ? {} : { baseUrl },
+		...apiKey === void 0 ? {} : { apiKey },
+		...wireApi === void 0 ? {} : { wireApi }
+	};
+	await writeFile(join(homeDir, ENDPOINT_AUTH_FILE), JSON.stringify(payload, void 0, 2) + "\n", { mode: 384 });
+}
+/**
+* Clear the scope's OWN endpoint credential (the endpoint-auth.json file).
+* A deployment-level credential from the plugin config is untouched — the
+* core's logout reply then names the profile row as the place to edit.
+* @param homeDir - the scope's scoped home.
+*/
+async function clearEndpointAuth(homeDir) {
+	await rm(join(homeDir, ENDPOINT_AUTH_FILE), { force: true });
+}
+/** How many served model ids the check reply lists before truncating. */
+const CHECK_MODEL_LIST_LIMIT = 8;
+/** Bound on the error-body excerpt a failed check reports. */
+const CHECK_ERROR_BODY_LIMIT = 200;
+/**
+* `GET <baseUrl>/v1/models` with `Authorization: Bearer <key>` — the
+* token-free endpoint probe shared by the `/codex check` verdict and any
+* future catalog. OpenAI's own API serves this route with the platform key;
+* relays (openproxy verified 2026-10-20, 139 models) proxy it and answer the
+* same OpenAI-list shape. Never throws: every failure mode folds into the
+* result.
+* @param endpoint - the resolved endpoint auth with a decided baseUrl.
+* @param fetchImpl - the HTTP fetch; default the host's global fetch.
+* @param signal - abort for the whole probe (timeout bundled by the caller).
+* @returns the folded result.
+*/
+async function fetchEndpointModels(endpoint, fetchImpl, signal) {
+	const headers = {};
+	if (endpoint.apiKey !== void 0) headers["authorization"] = `Bearer ${endpoint.apiKey}`;
+	const fetcher = fetchImpl ?? globalThis.fetch;
+	const root = endpoint.baseUrl.replace(/\/+$/, "");
+	const url = `${root}${root.endsWith("/v1") ? "" : "/v1"}/models`;
+	let response;
+	try {
+		response = await fetcher(url, {
+			headers,
+			signal: signal ?? AbortSignal.timeout(8e3)
+		});
+	} catch (error) {
+		return {
+			kind: "unreachable",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	if (!response.ok) return {
+		kind: "http",
+		status: response.status,
+		body: (await response.text().catch(() => "")).slice(0, CHECK_ERROR_BODY_LIMIT)
+	};
+	let data;
+	try {
+		data = JSON.parse(await response.text()).data;
+	} catch {
+		return { kind: "malformed" };
+	}
+	if (!Array.isArray(data)) return { kind: "malformed" };
+	const models = [];
+	for (const entry of data) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const id = entry.id;
+		if (typeof id === "string" && id !== "") models.push(id);
+	}
+	return {
+		kind: "models",
+		models
+	};
+}
+/**
+* Probe the resolved endpoint with a cheap, token-free round-trip: `GET
+* <baseUrl>/v1/models` with the resolved credential's Bearer header. A 200
+* proves both reachability and credential validity — the exact evidence a
+* "verify" button needs — and the served model list rides the reply. One
+* transport-level retry rides along: a local proxy restart (a Surge/clash
+* reload) stalls the first attempt into the timeout and answers the retry
+* immediately. Never throws: every failure mode folds into the reply text,
+* since the reply IS the diagnostic.
+* @param endpoint - the resolved endpoint auth (scope file over settings).
+* @param fetchImpl - the HTTP fetch; default the host's global fetch.
+* @param timeoutMs - one attempt's deadline (two attempts at most).
+* @returns the human-readable verdict for the check reply.
+*/
+async function checkCodexEndpoint(endpoint, fetchImpl, timeoutMs = 2e4) {
+	if (!hasEndpointCredential(endpoint)) return "No endpoint credential configured — fill Base URL and API Key on the settings card (or the profile row) first.";
+	const baseUrl = (endpoint.baseUrl ?? "https://api.openai.com").replace(/\/+$/, "");
+	let result = await fetchEndpointModels({
+		...endpoint,
+		baseUrl
+	}, fetchImpl, AbortSignal.timeout(timeoutMs));
+	if (result.kind === "unreachable") result = await fetchEndpointModels({
+		...endpoint,
+		baseUrl
+	}, fetchImpl, AbortSignal.timeout(timeoutMs));
+	if (result.kind === "unreachable") return `Endpoint unreachable (${baseUrl}): ${result.message}`;
+	if (result.kind === "http") return `Endpoint answered HTTP ${String(result.status)} (${baseUrl})${result.body === "" ? "" : `: ${result.body}`}`;
+	if (result.kind === "malformed") return `Endpoint reachable (${baseUrl}) but the model list did not parse — the credential worked, the reply was not /v1/models-shaped.`;
+	if (result.models.length === 0) return `Endpoint reachable (${baseUrl}); it serves no models.`;
+	const listed = result.models.slice(0, CHECK_MODEL_LIST_LIMIT).join(", ");
+	const more = result.models.length > CHECK_MODEL_LIST_LIMIT ? `, … +${String(result.models.length - CHECK_MODEL_LIST_LIMIT)} more` : "";
+	return `Endpoint reachable (${baseUrl}): ${String(result.models.length)} model(s) served — ${listed}${more}`;
+}
+//#endregion
 //#region lib/types/live-driver.js
 /**
 * The codex provider's live driver: one resident `codex app-server --stdio`
@@ -948,11 +1220,13 @@ var CodexLiveDriver = class {
 		const member = registerCodexMemberRun(this.ctx, String(spec.childSession.id), spec.parentSessionId);
 		const startModel = spec.startModel?.trim();
 		const model = spec.configuration !== void 0 ? spec.configuration.model : startModel !== void 0 && startModel !== "" ? startModel : this.config.model?.(key)?.trim();
+		const endpoint = this.config.endpoint === void 0 ? void 0 : await this.config.endpoint(spec.homeDir).catch(() => void 0);
 		const spawnSpec = {
 			argv: [
 				"codex",
 				"app-server",
 				...member === void 0 ? [] : ["-c", member.configOverride],
+				...endpointConfigOverrides(endpoint),
 				...model === void 0 || model === "" ? [] : ["-c", `model=${JSON.stringify(model)}`],
 				...spec.configuration?.effort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(spec.configuration.effort)}`],
 				"--stdio"
@@ -964,7 +1238,10 @@ var CodexLiveDriver = class {
 				stderr: "pipe"
 			},
 			graceMs: DEFAULT_DISPOSE_GRACE_MS,
-			env: delegationEnv({ CODEX_HOME: spec.homeDir })
+			env: delegationEnv({
+				CODEX_HOME: spec.homeDir,
+				...endpointAuthEnv(endpoint)
+			})
 		};
 		let child;
 		try {
@@ -1593,7 +1870,7 @@ var CodexLiveDriver = class {
 		});
 		await Promise.race([accepted, abortBranch.catch(() => void 0)]);
 		return subprocessRunHandle({
-			id: childSession.id,
+			id: SessionId(randomUUID()),
 			result,
 			signal: request.signal,
 			onAbort,
@@ -1608,31 +1885,33 @@ var CodexLiveDriver = class {
 //#endregion
 //#region lib/types/provision.js
 /**
-* Codex scoped-home provisioning: pin file-based credential storage so the
-* device-code login writes `auth.json` inside the scoped home. Codex's
-* `cli_auth_credentials_store` defaults to `auto` — on macOS that resolves
-* to the keychain, which would both leak credentials outside the scoped
-* home and defeat the `auth.json` presence check this package's records
-* adapter uses for authentication. An existing config is respected
-* untouched; sign-out removes the credential file.
+* Codex scoped-home provisioning: a working `config.toml` (a person may edit
+* it — custom providers, model, effort) plus the one-way sweep of the web
+* login's leftover `auth.json`. The harness is endpoint-key only: a stale
+* grant sitting next to an endpoint credential would keep authenticating the
+* built-in provider while the status reads "unauthenticated", so provisioning
+* deletes it on every boot (claude-code's OAuth-remnant sweep, same idea).
 * @module @khorsheed/dsh-local-agent-codex/provision
 */
-/** Credential file inside the scoped home; its presence marks auth. */
-const AUTH_FILE = "auth.json";
-/** Minimal scoped config: keep credentials in the scoped home. */
+/** Minimal scoped config: keep any hand-run login's credentials in the scoped home. */
 const SCOPED_CONFIG = `# Written by dsh-local-agent-codex: keep the device-code
 # credentials inside the scoped home (auth.json) instead of the OS keychain.
 cli_auth_credentials_store = "file"
 `;
+/** The web login's credential file, swept on every boot (endpoint-key only now). */
+const LEGACY_AUTH_FILE = "auth.json";
 /**
-* Provision `<homeDir>/config.toml` unless one already exists. A present
-* config is respected untouched (a person may have edited it); otherwise a
-* minimal config pinning file-based credential storage is written so login
-* lands in the scoped home's `auth.json`.
+* Provision the scoped home: ensure a `config.toml` exists (a minimal one —
+* codex reads it for custom providers, model, and effort; the historical
+* `cli_auth_credentials_store = "file"` pin stays so a hand-run `codex login`
+* under the scoped home can never spill into the macOS keychain), and sweep
+* the web login's leftover `auth.json` (the harness no longer consults it —
+* endpoint key or nothing).
 * @param homeDir - the `codex` harness's scoped home.
 * @returns true when a config was written, false when one already existed.
 */
 async function provisionCodexConfig(homeDir) {
+	await rm(join(homeDir, LEGACY_AUTH_FILE), { force: true });
 	try {
 		await readFile(join(homeDir, "config.toml"));
 		return false;
@@ -1767,30 +2046,6 @@ async function listCodexConfigModels(homeDir) {
 	}
 	return found;
 }
-/**
-* The credential file's modification stamp (epoch ms), undefined when absent.
-* A completed device-code login rewrites `auth.json`, so the stamp
-* distinguishes a fresh login from a leftover (possibly revoked) credential.
-* @param homeDir - the `codex` harness's scoped home.
-* @returns the marker's mtime, or undefined when no credential exists.
-*/
-async function codexCredentialStamp(homeDir) {
-	try {
-		return (await stat(join(homeDir, AUTH_FILE))).mtimeMs;
-	} catch {
-		return;
-	}
-}
-/**
-* Sign out of the scoped account: remove the credential file, so `/<name>
-* status` reports not authenticated and the next login authorizes a fresh
-* account. With `cli_auth_credentials_store = "file"` the credentials live
-* solely in `auth.json`, so removing it is the logout path.
-* @param homeDir - the `codex` harness's scoped home.
-*/
-async function codexLogout(homeDir) {
-	await rm(join(homeDir, AUTH_FILE), { force: true });
-}
 //#endregion
 //#region lib/types/codex-cli-provider.js
 /**
@@ -1889,6 +2144,7 @@ var CodexCliProvider = class {
 	live;
 	model;
 	overrides;
+	endpoint;
 	name = "codex-local";
 	capabilities = NO_START_CAPABILITIES;
 	inheritsParentContext = false;
@@ -1899,22 +2155,33 @@ var CodexCliProvider = class {
 	*   while a retiring generation still hosts it).
 	* @param model - resolver for the configured model, read PER ROUND so a
 	*   settings-card write takes effect on the next delegation without a
-	*   reload. Undefined (the resolver absent, or returning undefined) leaves
-	*   the argv exactly as it was before the key existed — the scoped
-	*   config.toml's own `model` then decides, as it always did.
+	*   reload; it receives the round's scope (a named scope's curated list
+	*   answers first). Undefined (the resolver absent, or returning
+	*   undefined) leaves the argv exactly as it was before the key existed —
+	*   the scoped config.toml's own `model` then decides, as it always did.
 	* @param overrides - resolver for the member's session-level model override
 	*   (the composer picker, owned by the model broker). It outranks BOTH the
 	*   delegation's recorded model and the configured one: on the exec path it
 	*   re-points the next round's `-m`, and on the live path it is the member's
 	*   start model — a resident runtime bound to a different model is retired
 	*   so the round respawns onto the override.
+	* @param endpoint - resolver for the scope's endpoint credential, read PER
+	*   ROUND so a settings-card write takes effect on the next delegation
+	*   without a reload. A resolution carrying a key routes the round at the
+	*   relay (a custom `model_providers` entry on the argv, the key in the
+	*   env); with no key the spawn carries no credential at all.
 	*/
-	constructor(ctx, sandbox = "workspace-write", live, model, overrides) {
+	constructor(ctx, sandbox = "workspace-write", live, model, overrides, endpoint) {
 		this.ctx = ctx;
 		this.sandbox = sandbox;
 		this.live = live;
 		this.model = model;
 		this.overrides = overrides;
+		this.endpoint = endpoint;
+	}
+	/** The scope's endpoint credential for this round; absent resolver = never. */
+	resolveEndpoint(homeDir) {
+		return this.endpoint === void 0 ? Promise.resolve(void 0) : this.endpoint(homeDir).catch(() => void 0);
 	}
 	/** Resolve the live driver for one round's member, if live is on for it. */
 	liveDriver(childSessionId) {
@@ -1950,7 +2217,7 @@ var CodexCliProvider = class {
 				...record?.configurationLock === void 0 ? {} : { configurationLock: record.configurationLock }
 			}, (configuration) => this.startCodexResume(request, intent, cwd, homeDir, exec, scope, record?.model, configuration), request.signal, intent?.onAdmitted);
 		}
-		const childSessionId = SessionId(intent?.preparedMemberId ?? randomUUID());
+		const childSessionId = SessionId(intent?.preparedMemberId ?? intent?.childSessionId ?? randomUUID());
 		if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") {
 			if (intent?.effort !== void 0) throw new Error("Codex effort requires the configuration admission core");
 			return this.startCodexFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId);
@@ -1979,16 +2246,19 @@ var CodexCliProvider = class {
 				delegationDepth: (request.parent.session.header.delegationDepth ?? 0) + 1
 			} });
 			const harness = this.ctx.localAgent.get("codex");
-			const label = subagentDelegationLabel(harness?.displayName ?? "codex", request.descriptor.label);
+			const label = subagentDelegationLabel(harness?.displayName ?? "codex", request.label || void 0);
 			childSession.append("subagent/descriptor", {
-				...request.descriptor,
+				version: SUBAGENT_DESCRIPTOR_VERSION,
+				mode: "one-shot",
+				provider: this.name,
 				label
 			});
 			establishSubagentCatalogChild(request.parent.session, childSession.header, label);
 		} catch (error) {
 			this.ctx.logger.warn(`subagent-codex: subagent session record failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
-		const baseUrl = await readCodexBaseUrl(homeDir).catch(() => void 0);
+		const endpoint = await this.resolveEndpoint(homeDir);
+		const baseUrl = hasEndpointCredential(endpoint) ? endpoint.baseUrl : await readCodexBaseUrl(homeDir).catch(() => void 0);
 		this.ctx.logger.info(`subagent-codex: delegating via ${baseUrl ?? "codex default endpoint"}`);
 		const live = exec === void 0 ? this.liveDriver(runId) : void 0;
 		if (live !== void 0 && childSession !== void 0 && !live.disabled) {
@@ -2022,11 +2292,15 @@ var CodexCliProvider = class {
 		try {
 			const run = await startCodexCliRun(request, {
 				cwd,
-				env: delegationEnv({ CODEX_HOME: homeDir }),
+				env: delegationEnv({
+					CODEX_HOME: homeDir,
+					...endpointAuthEnv(endpoint)
+				}),
 				...exec === void 0 ? {} : { exec },
 				endpointLabel: baseUrl,
+				endpointArgv: endpointConfigOverrides(endpoint),
 				sandbox: this.sandbox,
-				...configuration?.resolved ?? resolveRoundModel(this.overrides?.(runId) ?? requestedModel, this.model),
+				...configuration?.resolved ?? resolveRoundModel(this.overrides?.(runId) ?? requestedModel, () => this.model?.(scope)),
 				disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
 				spawn: (spec) => this.ctx.subprocess.spawn(spec),
 				onError: (error, stopReason) => {
@@ -2072,7 +2346,8 @@ var CodexCliProvider = class {
 			const childSession = this.ctx.get("sessions")?.get(SessionId(intent.childSessionId));
 			if (childSession === void 0) throw new Error(`subagent-codex: resume target child session ${intent.childSessionId} is not live — start a fresh delegation instead`);
 			const nextTurn = childSession.snapshotEvents().filter((event) => event.type === "turn/start").length + 1;
-			const baseUrl = await readCodexBaseUrl(homeDir).catch(() => void 0);
+			const endpoint = await this.resolveEndpoint(homeDir);
+			const baseUrl = hasEndpointCredential(endpoint) ? endpoint.baseUrl : await readCodexBaseUrl(homeDir).catch(() => void 0);
 			this.ctx.logger.info(`subagent-codex: resuming via ${baseUrl ?? "codex default endpoint"}`);
 			const live = exec === void 0 ? this.liveDriver(intent.childSessionId) : void 0;
 			if (live !== void 0 && !live.disabled) {
@@ -2106,11 +2381,15 @@ var CodexCliProvider = class {
 			try {
 				run = await startCodexCliRun(request, {
 					cwd,
-					env: delegationEnv({ CODEX_HOME: homeDir }),
+					env: delegationEnv({
+						CODEX_HOME: homeDir,
+						...endpointAuthEnv(endpoint)
+					}),
 					...exec === void 0 ? {} : { exec },
 					endpointLabel: baseUrl,
+					endpointArgv: endpointConfigOverrides(endpoint),
 					sandbox: this.sandbox,
-					...configuration?.resolved ?? resolveRoundModel(this.overrides?.(intent.childSessionId) ?? requestedModel, this.model),
+					...configuration?.resolved ?? resolveRoundModel(this.overrides?.(intent.childSessionId) ?? requestedModel, () => this.model?.(scope)),
 					disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
 					spawn: (spec) => this.ctx.subprocess.spawn(spec),
 					onError: (error, stopReason) => {
@@ -2357,11 +2636,13 @@ function startCodexCliRun(request, spec) {
 	if (request.signal.aborted) throw new Error("subagent-codex: request was aborted before the CLI started");
 	const turn = spec.resume?.turn ?? 1;
 	const memberArgv = spec.member === void 0 ? [] : ["-c", spec.member.configOverride];
+	const endpointArgv = spec.endpointArgv ?? [];
 	const modelArgv = [...spec.model === void 0 ? [] : ["-m", spec.model], ...spec.effort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(spec.effort)}`]];
 	const argv = spec.resume === void 0 ? [
 		"codex",
 		"exec",
 		...memberArgv,
+		...endpointArgv,
 		...modelArgv,
 		"--sandbox",
 		spec.sandbox,
@@ -2372,6 +2653,7 @@ function startCodexCliRun(request, spec) {
 		"codex",
 		"exec",
 		...memberArgv,
+		...endpointArgv,
 		...modelArgv,
 		"--sandbox",
 		spec.sandbox,
@@ -2521,7 +2803,7 @@ function startCodexCliRun(request, spec) {
 		return mirrorCodexAfterExit(spec, task, turn, output, liveMirror, startedAtMs);
 	}, () => {});
 	return Promise.resolve(subprocessRunHandle({
-		id: spec.childSession?.id ?? SessionId(randomUUID()),
+		id: SessionId(randomUUID()),
 		result,
 		signal: request.signal,
 		onAbort,
@@ -2881,7 +3163,8 @@ var LiveDriverSwitch = class {
 		this.active = next.live ? new CodexLiveDriver(this.ctx, {
 			...this.options.sandbox === void 0 ? {} : { sandbox: this.options.sandbox },
 			...this.options.liveIdleMs === void 0 ? {} : { liveIdleMs: this.options.liveIdleMs },
-			...this.options.model === void 0 ? {} : { model: this.options.model }
+			...this.options.model === void 0 ? {} : { model: this.options.model },
+			...this.options.endpoint === void 0 ? {} : { endpoint: this.options.endpoint }
 		}) : void 0;
 		if (retiring !== void 0) {
 			this.draining.add(retiring);
@@ -2954,7 +3237,7 @@ var CodexModelBroker = class {
 				await this.deps.refreshDirectory?.(home, binding.cwd);
 				directory = this.deps.directory?.(home, binding.cwd);
 			}
-			const model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel() ?? await readCodexModel(home) ?? this.deps.catalogDefault(home, binding.cwd);
+			const model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel(home) ?? await readCodexModel(home) ?? this.deps.catalogDefault(home, binding.cwd);
 			const entry = directory?.entries.find((entry) => entry.value === model);
 			const explicitEffort = selection.effort.mode === "value" ? selection.effort.value : selection.effort.mode === "inherit" ? binding.effort : void 0;
 			const effort = explicitEffort ?? await readCodexReasoningEffort(home) ?? entry?.reasoning?.default;
@@ -3019,7 +3302,7 @@ var CodexModelBroker = class {
 		if (override !== void 0) return override;
 		const recorded = this.deps.ctx.localAgent.getDelegation(childSessionId)?.model?.trim();
 		if (recorded !== void 0 && recorded !== "") return recorded;
-		return this.deps.settingsModel();
+		return this.deps.settingsModel(this.deps.homeDir(childSessionId));
 	}
 	/**
 	* Read the model surface. The cliDefault and the discovered identifiers come
@@ -3030,8 +3313,8 @@ var CodexModelBroker = class {
 	* re-fetches on open, so it never blocks on a CLI boot).
 	*/
 	async modelInfo(childSessionId, delegationModel) {
-		const settings = this.deps.settingsModel();
 		const homeDir = this.deps.homeDir(childSessionId);
+		const settings = this.deps.settingsModel(homeDir);
 		const [cliDefault, discovered] = await Promise.all([readCodexModel(homeDir).catch(() => void 0), listCodexConfigModels(homeDir).catch(() => [])]);
 		const override = childSessionId === void 0 ? void 0 : this.deps.overrides.get(childSessionId);
 		const delegation = delegationModel?.trim() === "" ? void 0 : delegationModel;
@@ -3039,6 +3322,7 @@ var CodexModelBroker = class {
 		const effective = override ?? delegation ?? settings ?? cliDefault ?? (catalogDefaultRaw === void 0 || catalogDefaultRaw === "" ? void 0 : catalogDefaultRaw);
 		const source = override !== void 0 ? "override" : delegation !== void 0 ? "delegation" : settings !== void 0 ? "settings" : cliDefault !== void 0 ? "cli-config" : "cli-builtin";
 		const inFlight = childSessionId !== void 0 && this.activeDelegations().includes(childSessionId);
+		const curated = this.deps.modelList?.(homeDir) ?? [];
 		return {
 			...effective === void 0 ? {} : { effective },
 			source,
@@ -3050,8 +3334,8 @@ var CodexModelBroker = class {
 				settings,
 				cliDefault,
 				...discovered
-			], this.deps.recentModels()) },
-			choices: dedupeChoices([
+			], curated.length > 0 ? [] : this.deps.recentModels()) },
+			choices: curated.length > 0 ? [...curated] : dedupeChoices([
 				settings,
 				cliDefault,
 				...discovered,
@@ -3083,6 +3367,16 @@ var CodexModelBroker = class {
 };
 /** Grace between stdin EOF and terminate when the probe tears the process down. */
 const PROBE_EOF_GRACE_MS = 1e3;
+/** One directory answer that names why it is empty. */
+function unsupported(reason) {
+	return {
+		entries: [],
+		complete: false,
+		customInput: true,
+		unsupported: true,
+		reason
+	};
+}
 /** Preserve native metadata, including hidden candidates; reject malformed pages. */
 function catalogEntries(result) {
 	const page = result;
@@ -3138,7 +3432,7 @@ var CodexModelCatalog = class {
 		this.cache = new ModelDirectoryCache({
 			load: (key, signal) => {
 				const context = JSON.parse(key);
-				return this.probe(context.homeDir, context.cwd, signal);
+				return this.load(context.homeDir, context.cwd, signal);
 			},
 			ttlMs: deps.ttlMs ?? 3e5,
 			...deps.now === void 0 ? {} : { now: deps.now },
@@ -3146,7 +3440,11 @@ var CodexModelCatalog = class {
 		});
 	}
 	key(homeDir, cwd = homeDir) {
-		const files = [join(homeDir, "config.toml"), join(homeDir, "auth.json")];
+		const files = [
+			join(homeDir, "config.toml"),
+			join(homeDir, "auth.json"),
+			join(homeDir, ENDPOINT_AUTH_FILE)
+		];
 		for (let directory = cwd;; directory = dirname(directory)) {
 			files.push(join(directory, ".codex", "config.toml"));
 			if (dirname(directory) === directory) break;
@@ -3181,16 +3479,69 @@ var CodexModelCatalog = class {
 		return (await this.cache.refresh(this.key(homeDir, cwd))).entries.filter((entry) => !entry.hidden).map((entry) => entry.value);
 	}
 	/**
-	* One bounded probe: spawn the app-server against the scoped home, answer
-	* the initialize handshake exactly as the live driver shapes it, ask
-	* `model/list`, then tear the process down (stdin EOF → grace →
-	* terminate). The overall timeout kills the process on expiry. Failures propagate to the shared cache, which preserves prior data.
+	* One directory load: the endpoint's served id list is the vocabulary (the
+	* card's add dialog can only offer what the endpoint answers), folded
+	* CONCURRENTLY with the native app-server probe's metadata. The endpoint
+	* answers are deliberate:
+	*
+	* - no credential resolved → empty with a "save a key first" reason;
+	* - 401/403 → empty with the rejection (definitive — cached as data);
+	* - another HTTP status → empty with it (the relay serves no model route);
+	* - a transport failure THROWS, so the cache keeps the last good list and
+	*   retries on schedule instead of blanking a momentarily-down endpoint
+	*   (the openproxy relay once 500'd and recovered — 2026-10-22).
+	*
+	* The native probe's failure never fails the load: endpoint data alone is
+	* complete (it warns once via the deps sink). The endpoint fetch gets a
+	* 20s ceiling by default (mirrors claude's catalog timeout); the native
+	* probe keeps its own tighter bound internally.
+	*/
+	async load(homeDir, cwd, signal) {
+		const endpoint = this.deps.endpoint === void 0 ? void 0 : await this.deps.endpoint(homeDir).catch(() => void 0);
+		if (!hasEndpointCredential(endpoint)) return unsupported("No endpoint credential configured — the model list loads from the endpoint once an API Key is saved");
+		const combined = AbortSignal.any([signal, AbortSignal.timeout(this.deps.timeoutMs ?? 2e4)]);
+		const [result, native] = await Promise.all([fetchEndpointModels({
+			...endpoint,
+			baseUrl: endpoint.baseUrl ?? "https://api.openai.com"
+		}, this.deps.fetchImpl, combined), this.probeNative(homeDir, cwd, combined).catch((error) => {
+			this.deps.warn?.(`local-agent-codex: the native model/list probe failed (metadata only — the endpoint's list stands): ${error instanceof Error ? error.message : String(error)}`);
+		})]);
+		if (result.kind === "unreachable") throw new Error(`endpoint unreachable: ${result.message}`);
+		if (result.kind === "malformed") return unsupported("The endpoint answered but the model list did not parse (not /v1/models-shaped)");
+		if (result.kind === "http") {
+			if (result.status === 401 || result.status === 403) return unsupported(`The endpoint rejected the credential (HTTP ${String(result.status)}) — the list loads once a valid key is saved`);
+			return unsupported(`The endpoint does not serve a model list (HTTP ${String(result.status)})`);
+		}
+		if (result.models.length === 0) return unsupported("The endpoint serves no models");
+		const nativeByValue = new Map((native?.entries ?? []).map((entry) => [entry.value, entry]));
+		const entries = result.models.map((id) => nativeByValue.get(id) ?? {
+			value: id,
+			label: id,
+			source: "native"
+		});
+		const defaultModel = native?.defaultModel;
+		return {
+			entries,
+			complete: true,
+			customInput: true,
+			...defaultModel === void 0 ? {} : { defaultModel }
+		};
+	}
+	/**
+	* One bounded NATIVE probe — the metadata-enrichment side of {@link load}:
+	* spawn the app-server against the scoped home, answer the initialize
+	* handshake exactly as the live driver shapes it, ask `model/list`, then
+	* tear the process down (stdin EOF → grace → terminate). The overall
+	* timeout kills the process on expiry. Failures propagate to the caller
+	* (load demotes them to a warn).
 	*/
-	async probe(homeDir, cwd, signal) {
+	async probeNative(homeDir, cwd, signal) {
+		const endpoint = this.deps.endpoint === void 0 ? void 0 : await this.deps.endpoint(homeDir).catch(() => void 0);
 		const spec = {
 			argv: [
 				"codex",
 				"app-server",
+				...endpointConfigOverrides(endpoint),
 				"--stdio"
 			],
 			cwd,
@@ -3200,7 +3551,10 @@ var CodexModelCatalog = class {
 				stderr: "pipe"
 			},
 			graceMs: DEFAULT_DISPOSE_GRACE_MS,
-			env: delegationEnv({ CODEX_HOME: homeDir })
+			env: delegationEnv({
+				CODEX_HOME: homeDir,
+				...endpointAuthEnv(endpoint)
+			})
 		};
 		const child = this.deps.spawn(spec);
 		const decoder = new StringDecoder("utf8");
@@ -3337,8 +3691,8 @@ var CodexModelCatalog = class {
 /**
 * Codex harness instantiation of the local-agent family. Registers the
 * `codex` harness into the core registry: scoped home under the shared homes
-* root (`CODEX_HOME`), device-code login through `codex login --device-auth`
-* (prompt captured from stdout), and rollout-file session records.
+* root (`CODEX_HOME`), endpoint-key authentication (endpoint-auth.ts — no web
+* login anywhere), and rollout-file session records.
 * Delegation mounts through the `codex-local` provider (one-shot
 * `codex exec` under the scoped home); the bundle patch's
 * `tool-subagent-codex-local` row puts the tool on the profile root, so
@@ -3350,7 +3704,8 @@ var CodexModelCatalog = class {
 const name = "local-agent-codex";
 /**
 * Boot delay before the model catalog's eager warmup probe fires. The probe
-* spawns a `codex app-server` — cheap, but not free — so it waits out the
+* fetches the endpoint's served model list AND spawns a `codex app-server`
+* (the native metadata side) — cheap, but not free — so it waits out the
 * boot storm instead of competing with it, and the FIRST settings-card open
 * usually hits a warm cache. A card opened before the timer fires simply
 * triggers the probe itself (the read path's lazy kick), so the delay never
@@ -3393,6 +3748,8 @@ const Config = z.object({
 		z.const("workspace-write"),
 		z.const("danger-full-access")
 	]),
+	baseUrl: z.string(),
+	apiKey: z.string(),
 	model: volatilize(SETTINGS_FIELDS.model),
 	live: volatilize(SETTINGS_FIELDS.live),
 	liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
@@ -3449,14 +3806,22 @@ function apply(ctx, config) {
 			legacyBase,
 			read: readSettings
 		});
-		const resolveModel = () => {
+		const resolveModelKey = () => {
 			const model = face.get().model?.trim();
 			return model === void 0 || model === "" ? void 0 : model;
 		};
+		const resolveModelFor = (homeDir) => firstModelOf(readModelListSync(homeDir)) ?? resolveModelKey();
+		const resolveModel = (scope) => resolveModelFor(ctx.localAgent.homeDir("codex", scope));
 		const memberModelOverrides = /* @__PURE__ */ new Map();
+		const endpointConfig = {
+			...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl },
+			...config.apiKey === void 0 ? {} : { apiKey: config.apiKey }
+		};
+		const resolveEndpoint = (scopeHome) => resolveEndpointAuth(scopeHome, endpointConfig);
 		const modelCatalog = new CodexModelCatalog({
 			spawn: (spec) => ctx.subprocess.spawn(spec),
-			warn: (message) => ctx.logger.warn(message)
+			warn: (message) => ctx.logger.warn(message),
+			endpoint: resolveEndpoint
 		});
 		const warmup = setTimeout(() => {
 			modelCatalog.read(homeDir);
@@ -3464,12 +3829,14 @@ function apply(ctx, config) {
 		warmup.unref();
 		const liveSwitch = new LiveDriverSwitch(ctx, face, {
 			sandbox,
-			model: (childSessionId) => memberModelOverrides.get(childSessionId) ?? resolveModel(),
+			model: (childSessionId) => memberModelOverrides.get(childSessionId) ?? resolveModel((ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.scope),
+			endpoint: resolveEndpoint,
 			...config.liveIdleMs === void 0 ? {} : { liveIdleMs: config.liveIdleMs }
 		});
 		const modelBroker = new CodexModelBroker({
 			ctx,
-			settingsModel: resolveModel,
+			settingsModel: resolveModelFor,
+			modelList: (homeDir) => readModelListSync(homeDir),
 			recentModels: () => face.get().recentModels ?? [],
 			homeDir: (childSessionId) => ctx.localAgent.homeDir("codex", childSessionId === void 0 ? void 0 : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.scope),
 			cwd: (childSessionId) => childSessionId === void 0 ? void 0 : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.cwd,
@@ -3483,7 +3850,7 @@ function apply(ctx, config) {
 			catalog: (scopedHome, cwd) => modelCatalog.read(scopedHome, cwd),
 			catalogDefault: (scopedHome, cwd) => modelCatalog.readDefault(scopedHome, cwd)
 		});
-		const disposeProvider = ctx.subagents.registerProvider(new CodexCliProvider(ctx, sandbox, liveSwitch.resolve, resolveModel, (childSessionId) => memberModelOverrides.get(childSessionId)));
+		const disposeProvider = ctx.subagents.registerProvider(new CodexCliProvider(ctx, sandbox, liveSwitch.resolve, resolveModel, (childSessionId) => memberModelOverrides.get(childSessionId), resolveEndpoint));
 		const disposeHarness = ctx.localAgent.register({
 			prepareMember: async ({ binding, childSession, configuration, signal }) => {
 				const driver = liveSwitch.resolve(binding.childSessionId);
@@ -3501,23 +3868,53 @@ function apply(ctx, config) {
 			homeEnvVar: "CODEX_HOME",
 			delegationProvider: "codex-local",
 			modelBroker,
-			login: { pty: {
-				command: "codex",
-				args: ["login"]
-			} },
+			modelList: {
+				read: (home) => readModelList(home),
+				write: (home, models) => writeModelList(home, models)
+			},
 			records: { listSessions: (homeDir) => listCodexSessions(homeDir) },
 			provision: (scopedHome) => provisionCodexConfig(scopedHome).then(() => {}),
-			isAuthenticated: codexAuthenticated,
-			credentialStamp: codexCredentialStamp,
-			logout: codexLogout,
+			isAuthenticated: async (home) => hasEndpointCredential(await resolveEndpoint(home)),
+			checkEndpoint: (home) => resolveEndpoint(home).then((endpoint) => checkCodexEndpoint(endpoint)),
+			endpointAuth: {
+				read: async (home) => {
+					const endpoint = await resolveEndpoint(home);
+					return {
+						...endpoint.baseUrl === void 0 ? {} : { baseUrl: endpoint.baseUrl },
+						apiKeySet: endpoint.apiKey !== void 0,
+						authTokenSet: false
+					};
+				},
+				write: async (home, fields) => {
+					const next = { ...await readEndpointAuthFile(home) ?? {} };
+					for (const [field, value] of Object.entries(fields)) {
+						if (field !== "baseUrl" && field !== "apiKey") continue;
+						if (value === void 0) continue;
+						const trimmed = typeof value === "string" ? value.trim() : "";
+						if (value === null || trimmed === "") delete next[field];
+						else next[field] = trimmed;
+					}
+					if (Object.keys(next).length === 0) await clearEndpointAuth(home);
+					else await writeEndpointAuth(home, next);
+				}
+			},
+			credentialStamp: endpointAuthStamp,
+			logout: async (home) => {
+				if (await endpointAuthFileExists(home)) {
+					await clearEndpointAuth(home);
+					return;
+				}
+				throw new Error("codex has no scoped endpoint-auth.json to clear — the credential comes from the settings card or the profile row (baseUrl/apiKey); clear it there instead");
+			},
 			effectiveSettings: async (scopedHome) => {
-				const [reasoningEffort, baseUrl, scopedModel, cliVersion] = await Promise.all([
+				const [reasoningEffort, endpoint, scopedModel, cliVersion] = await Promise.all([
 					readCodexReasoningEffort(scopedHome).catch(() => void 0),
-					readCodexBaseUrl(scopedHome).catch(() => void 0),
+					resolveEndpoint(scopedHome).catch(() => void 0),
 					readCodexModel(scopedHome).catch(() => void 0),
 					codexCliVersion(ctx, scopedHome).catch(() => void 0)
 				]);
-				const model = resolveModel() ?? scopedModel;
+				const baseUrl = hasEndpointCredential(endpoint) ? endpoint.baseUrl : await readCodexBaseUrl(scopedHome).catch(() => void 0);
+				const model = resolveModelFor(scopedHome) ?? scopedModel;
 				const baseUrlHost = baseUrl !== void 0 ? endpointHost(baseUrl) : void 0;
 				return {
 					drive: face.get().live ? "live" : "exec",