@themoltnet/agent-daemon 0.55.1 → 0.56.1

package/dist/cli.js

@@ -30,17 +30,18 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { mkdir, open, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
+import { ModelRuntime, readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { lock, lockSync } from "proper-lockfile";
+import { isIP } from "node:net";
 import cors from "@fastify/cors";
 import helmet from "@fastify/helmet";
-import { lock, lockSync } from "proper-lockfile";
-import { ModelRuntime, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { Transform, Writable } from "node:stream";
 import { writePiConfig } from "@themoltnet/pi-runtime/pi-config";
 import { pathToFileURL } from "node:url";
 import { StringDecoder } from "node:string_decoder";
 import rateLimit from "@fastify/rate-limit";
 import Fastify from "fastify";
-import { isIP } from "node:net";
 import "reflect-metadata";
 import { homedir, platform } from "node:os";
 import { BasicConstraintsExtension, ExtendedKeyUsage, ExtendedKeyUsageExtension, IP, KeyUsageFlags, KeyUsagesExtension, SubjectAlternativeNameExtension, X509CertificateGenerator } from "@peculiar/x509";
@@ -772,6 +773,7 @@ var CREDENTIAL_SCOPES = {
 	TaskExecute: "task:execute",
 	TaskManage: "task:manage",
 	TaskRead: "task:read",
+	TaskWrite: "task:write",
 	TeamManage: "team:manage",
 	TeamRead: "team:read"
 };
@@ -814,6 +816,7 @@ var MCP_CLIENT_SCOPES = [
 	CREDENTIAL_SCOPES.TaskExecute,
 	CREDENTIAL_SCOPES.TaskManage,
 	CREDENTIAL_SCOPES.TaskRead,
+	CREDENTIAL_SCOPES.TaskWrite,
 	CREDENTIAL_SCOPES.TeamManage,
 	CREDENTIAL_SCOPES.TeamRead
 ];
@@ -3458,6 +3461,8 @@ Commands:
             child processes. Binds 127.0.0.1 only.
   server trust
             Install the per-user macOS local-HTTPS CA after explicit consent.
+  providers Manage configured endpoints and Pi OAuth subscriptions without
+            starting the Agent Server. See \`agent-daemon providers --help\`.
   sync-sessions
             Repair durable runtime-session checkpoints from local slot files.
   update check
@@ -3624,6 +3629,24 @@ On macOS, the first interactive run asks to trust a per-user local CA in the
 login keychain and serves HTTPS. Run \`agent-daemon server trust --remove\` to
 remove that exact CA. Linux continues to use the Chromium PNA HTTP path.
 `;
+var PROVIDERS_HELP = `\
+moltnet-agent providers — manage local model providers.
+
+Usage:
+  moltnet-agent providers list [--json] [--root <path>]
+  moltnet-agent providers set <id> [--base-url <url>] [--api <pi-api-kind>]
+    [--model <id> ... | --clear-models]
+    [--api-key-stdin | --clear-api-key] [--root <path>]
+  moltnet-agent providers discover <id> [--save] [--json] [--root <path>]
+  moltnet-agent providers remove <id> [--yes] [--root <path>]
+  moltnet-agent providers login <id> [--auth-method <method-id>]
+    [--root <path>]
+  moltnet-agent providers logout <id> [--yes] [--root <path>]
+
+The default root is ~/.config/moltnet. MOLTNET_AGENT_SERVER_ROOT remains the
+environment override. API keys are accepted only from redirected stdin; they
+are stored separately and providers.json contains only a secret reference.
+`;
 //#endregion
 //#region src/lib/identity-pin.ts
 /** Compare every pinned field without choosing a caller-specific error type. */
@@ -3913,7 +3936,8 @@ function loadAgentServerEnvConfig() {
 		allowedOrigins: process.env["MOLTNET_AGENT_SERVER_ALLOWED_ORIGINS"] ?? "",
 		root: process.env["MOLTNET_AGENT_SERVER_ROOT"] ?? "",
 		apiUrl: process.env["MOLTNET_API_URL"] ?? "",
-		logLevel: process.env["LOG_LEVEL"] ?? ""
+		logLevel: process.env["LOG_LEVEL"] ?? "",
+		activeIdentity: process.env["MOLTNET_ACTIVE_IDENTITY"] ?? ""
 	};
 }
 /** Full process environment for spawned Agent Server run children. */
@@ -7108,1115 +7132,2051 @@ function runPoll(argv, runtimeAdapter) {
 		runtimeAdapter
 	});
 }
-//#endregion
-//#region ../../libs/loopback-companion/src/errors.ts
-var LoopbackViolationError = class extends Error {
-	name = "LoopbackViolationError";
-	constructor(kind, message, options) {
-		super(message, options);
-		this.kind = kind;
+var NAME_RE = IDENTITY_ALIAS_PATTERN;
+var PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function assertStoreName(kind, value) {
+	try {
+		return assertIdentityAlias(value);
+	} catch {
+		throw new AgentServerStoreError("invalid_name", `${kind} must match ${NAME_RE.source}`);
 	}
-};
-function isLoopbackViolation(error) {
-	return error instanceof LoopbackViolationError;
 }
-//#endregion
-//#region ../../libs/loopback-companion/src/origin.ts
-/** Hostnames accepted as loopback for companion servers and origins. */
-function isLoopbackHostname(hostname) {
-	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+function assertProviderId(value) {
+	if (!PROVIDER_ID_RE.test(value)) throw new AgentServerStoreError("invalid_name", `provider id must match ${PROVIDER_ID_RE.source}`);
+	return value;
 }
+var AgentServerStoreError = class extends Error {
+	name = "AgentServerStoreError";
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+	}
+};
 /**
-* Normalize and validate a browser origin. Accepts exact `https:` origins,
-* or `http:` origins whose host is loopback. Rejects values that carry a
-* path, trailing slash, credentials, or any other non-origin decoration
-* (`url.origin !== value` catches all of those).
+* `MOLTNET_AGENT_SERVER_ROOT` override, else `~/.config/moltnet`.
+*
+* Deliberately does NOT consult `XDG_CONFIG_HOME`. The Go CLI's GetConfigDir
+* and @moltnet/agent-config's getConfigDir both resolve `~/.config/moltnet`,
+* so honouring XDG here gave one application two config roots: on a machine
+* with the variable set, the daemon wrote identities the CLI and SDK could not
+* read. `MOLTNET_AGENT_SERVER_ROOT` remains the explicit escape hatch for a
+* genuinely custom location.
 */
-function normalizeOrigin(value) {
-	let url;
+function resolveAgentServerRoot(input) {
+	const override = input.root?.trim();
+	if (override) return override;
+	return getConfigDir();
+}
+function providerEnvName(providerId) {
+	return `MOLTNET_PROVIDER_${assertProviderId(providerId).replaceAll("-", "_").toUpperCase()}_API_KEY`;
+}
+function assertProviderEnvName(providerId, value) {
+	const expected = providerEnvName(providerId);
+	if (value !== expected) throw new AgentServerStoreError("invalid_state", `provider envName must be ${expected}`);
+	return value;
+}
+function readJson(path) {
+	let raw;
 	try {
-		url = new URL(value);
+		raw = readFileSync(path, "utf8");
 	} catch (cause) {
-		throw new LoopbackViolationError("origin_invalid", "Origin is not valid", { cause });
+		if (cause.code === "ENOENT") return null;
+		throw new AgentServerStoreError("io_error", `could not read state at ${path}`, { cause });
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (cause) {
+		throw new AgentServerStoreError("invalid_state", `corrupt JSON at ${path}`, { cause });
 	}
-	if (url.origin !== value || url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHostname(url.hostname))) throw new LoopbackViolationError("origin_invalid", "Origin is not valid");
-	return url.origin;
 }
-/** Parse a comma-separated origin list (config format shared by companions). */
-function parseAllowedOrigins(csv) {
-	return csv.split(",").map((origin) => origin.trim()).filter(Boolean);
+function writeJsonAtomic(path, value) {
+	const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		renameSync(temp, path);
+	} catch (cause) {
+		try {
+			rmSync(temp, { force: true });
+		} catch {}
+		throw cause;
+	}
 }
-/**
-* Exact-origin allowlist. Every configured origin is normalized eagerly so a
-* misconfigured allowlist fails at startup, not at request time.
-*/
-var OriginAllowlist = class {
-	origins;
-	constructor(allowedOrigins) {
-		if (allowedOrigins.length === 0) throw new Error("OriginAllowlist requires at least one origin");
-		this.origins = new Set(allowedOrigins.map((origin) => normalizeOrigin(origin)));
+var AgentServerStore = class {
+	root;
+	identitiesDir;
+	runsDir;
+	secretsDir;
+	/** Shared Pi credential dir; `auth.json` inside is pi-managed (lockfiled). */
+	piDir;
+	constructor(root) {
+		this.root = root;
+		this.identitiesDir = join(root, "identities");
+		this.runsDir = join(root, "runs");
+		this.secretsDir = join(root, "secrets");
+		this.piDir = join(root, "pi");
 	}
-	has(origin) {
-		try {
-			return this.origins.has(normalizeOrigin(origin));
-		} catch {
-			return false;
+	get piAuthJsonPath() {
+		return join(this.piDir, "auth.json");
+	}
+	/** Create the directory layout (0700) if missing. Idempotent. */
+	ensure() {
+		for (const dir of [
+			this.root,
+			this.identitiesDir,
+			this.runsDir,
+			this.secretsDir
+		]) mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		return this;
+	}
+	get statePath() {
+		return join(this.root, "agent-server.json");
+	}
+	readAgentServerState() {
+		const state = readJson(this.statePath);
+		if (!state) return {
+			version: 2,
+			pendingRegistrations: {},
+			activations: {}
+		};
+		if (!isRecord$1(state) || state.version !== 2) throw new AgentServerStoreError("invalid_state", `agent-server.json version ${String(isRecord$1(state) ? state.version : void 0)} is not supported; move agent-server.json aside, run \`moltnet config migrate\`, then add or attach the agents again`);
+		if ("pairedOrigins" in state) throw new AgentServerStoreError("invalid_state", "agent-server.json uses the obsolete pairing format; move agent-server.json aside and configure the agent server again");
+		if (!isRecord$1(state.pendingRegistrations) || !isRecord$1(state.activations)) throw new AgentServerStoreError("invalid_state", "agent-server.json is missing the version 2 activation map; move agent-server.json aside, run `moltnet config migrate`, then add or attach the agents again");
+		for (const [alias, activation] of Object.entries(state.activations)) validateActivation(alias, activation);
+		for (const [alias, registration] of Object.entries(state.pendingRegistrations)) {
+			assertStoreName("agent name", alias);
+			if (!isRecord$1(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new AgentServerStoreError("invalid_state", `pending registration "${alias}" is not valid`);
 		}
+		return {
+			version: 2,
+			pendingRegistrations: state.pendingRegistrations,
+			activations: state.activations
+		};
 	}
-	/** Return the normalized origin or throw `origin_not_allowed`. */
-	assert(value) {
-		let origin;
+	writeAgentServerState(state) {
+		writeJsonAtomic(this.statePath, state);
+	}
+	agentPath(name) {
+		return join(storeChildPath(this.identitiesDir, "identity alias", name), "moltnet.json");
+	}
+	/** Central identity directory, shared with the Go CLI layout. */
+	identityDir(name) {
+		return storeChildPath(this.identitiesDir, "identity alias", name);
+	}
+	get identitySelectorPath() {
+		return join(this.root, "identity-selector.json");
+	}
+	readIdentitySelector() {
+		const selector = readJson(this.identitySelectorPath);
+		if (!selector) return null;
+		if (!isRecord$1(selector) || selector.version !== 1 || selector.default_identity !== void 0 && typeof selector.default_identity !== "string") throw new AgentServerStoreError("invalid_state", "identity-selector.json is not a supported selector document");
+		if (selector.default_identity) assertStoreName("identity alias", selector.default_identity);
+		return selector;
+	}
+	writeIdentitySelector(alias) {
+		writeJsonAtomic(this.identitySelectorPath, {
+			version: 1,
+			default_identity: assertStoreName("identity alias", alias)
+		});
+	}
+	/** Identity aliases available in the shared user-level store. */
+	listIdentityAliases() {
+		return readdirSync(this.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && IDENTITY_ALIAS_PATTERN.test(entry.name)).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+	}
+	resolveIdentityAlias(explicit, active) {
+		const alias = explicit?.trim() || active?.trim() || this.readIdentitySelector()?.default_identity;
+		if (!alias) throw new AgentServerStoreError("not_found", "no active identity selected");
+		return assertStoreName("identity alias", alias);
+	}
+	readAgentConfig(alias) {
+		return readJson(this.agentPath(alias));
+	}
+	writeAgentConfig(alias, config) {
+		mkdirSync(this.identityDir(alias), {
+			recursive: true,
+			mode: 448
+		});
+		writeJsonAtomic(this.agentPath(alias), config);
+		if (!this.readIdentitySelector()?.default_identity) this.writeIdentitySelector(alias);
+	}
+	removeAgentConfig(alias) {
+		rmSync(this.agentPath(alias), { force: true });
+		this.clearIdentitySelectorIfDefault(alias);
+	}
+	/** Clears the persisted default when it names `alias`. */
+	clearIdentitySelectorIfDefault(alias) {
+		let selector = null;
 		try {
-			origin = normalizeOrigin(value);
+			selector = this.readIdentitySelector();
 		} catch {
-			throw new LoopbackViolationError("origin_not_allowed", "Origin is not allowed");
+			return;
 		}
-		if (!this.origins.has(origin)) throw new LoopbackViolationError("origin_not_allowed", "Origin is not allowed");
-		return origin;
+		if (!selector || selector.default_identity !== alias) return;
+		writeJsonAtomic(this.identitySelectorPath, { version: 1 });
 	}
-};
-/** Extract and require the `Origin` header value. */
-function requireOriginHeader(headers) {
-	const origin = headers.origin;
-	if (typeof origin !== "string" || origin.length === 0) throw new LoopbackViolationError("origin_required", "Origin is required");
-	return origin;
-}
-//#endregion
-//#region ../../libs/loopback-companion/src/fastify.ts
-var CORS_PREFLIGHT_MAX_AGE_SECONDS = 600;
-var PRIVATE_NETWORK_REQUEST_HEADER = "access-control-request-private-network";
-var PRIVATE_NETWORK_ALLOW_HEADER = "access-control-allow-private-network";
-/**
-* Enforce that the `Host` header identifies loopback. Blocks DNS-rebinding
-* setups where a public hostname resolves to 127.0.0.1: the browser then
-* sends that hostname as `Host`, and the request is refused here even
-* though the socket is loopback.
-*/
-function requireLoopbackHost(request) {
-	const host = request.headers.host;
-	if (!host) throw new LoopbackViolationError("host_required", "Host header is required");
-	let hostname;
-	try {
-		hostname = new URL(`http://${host}`).hostname;
-	} catch {
-		throw new LoopbackViolationError("host_not_loopback", "Host header must identify loopback");
+	readActivation(alias) {
+		return this.readAgentServerState().activations[assertStoreName("agent name", alias)] ?? null;
 	}
-	if (!isLoopbackHostname(hostname === "::1" ? "[::1]" : hostname)) throw new LoopbackViolationError("host_not_loopback", "Host header must identify loopback");
-}
-/**
-* Register the loopback-companion security profile on a Fastify app:
-*
-* - loopback `Host` enforcement on every request;
-* - `cache-control: no-store` on every response;
-* - strict UTF-8 JSON body parsing (invalid bodies raise a typed violation);
-* - exact-origin CORS (opaque/`null` origins get no CORS response but are
-*   not rejected here — route-level controls stay mandatory);
-* - hardened helmet defaults.
-*
-*/
-function registerLoopbackSecurity(app, options) {
-	if (!options.allowedOrigins && !options.isOriginAllowed) throw new Error("registerLoopbackSecurity requires allowedOrigins or isOriginAllowed");
-	const primaryAllowlist = options.allowedOrigins ? new OriginAllowlist(options.allowedOrigins) : null;
-	const selfAllowlist = options.selfOrigins && options.selfOrigins.length > 0 ? new OriginAllowlist(options.selfOrigins) : null;
-	const isOriginAllowed = (origin) => selfAllowlist?.has(origin) === true || primaryAllowlist?.has(origin) === true || options.isOriginAllowed?.(origin) === true;
-	app.addHook("onRequest", (request, _reply, done) => {
-		requireLoopbackHost(request);
-		done();
-	});
-	app.addHook("onSend", async (request, reply, payload) => {
-		reply.header("cache-control", "no-store");
-		if (request.method === "OPTIONS" && request.headers[PRIVATE_NETWORK_REQUEST_HEADER] === "true" && reply.getHeader("access-control-allow-origin") === request.headers.origin) reply.header(PRIVATE_NETWORK_ALLOW_HEADER, "true");
-		return payload;
-	});
-	app.removeContentTypeParser("application/json");
-	app.addContentTypeParser("application/json", { parseAs: "buffer" }, (_request, body, done) => {
-		try {
-			const json = new TextDecoder("utf-8", { fatal: true }).decode(typeof body === "string" ? Buffer.from(body) : body);
-			done(null, JSON.parse(json));
-		} catch (cause) {
-			done(new LoopbackViolationError("body_not_utf8_json", "Request body must be valid UTF-8 JSON", { cause }), void 0);
-		}
-	});
-	app.register(cors, {
-		allowedHeaders: ["content-type", ...options.allowedHeaders ?? []],
-		maxAge: CORS_PREFLIGHT_MAX_AGE_SECONDS,
-		methods: [...options.methods ?? [
-			"GET",
-			"POST",
-			"OPTIONS"
-		]],
-		origin: (origin, callback) => {
-			if (!origin || origin === "null") {
-				callback(null, false);
-				return;
-			}
-			if (isOriginAllowed(origin)) {
-				callback(null, true);
-				return;
-			}
-			callback(new LoopbackViolationError("origin_not_allowed", "Origin is not allowed"), false);
-		}
-	});
-	app.register(helmet, {
-		contentSecurityPolicy: {
-			useDefaults: false,
-			directives: options.contentSecurityPolicyDirectives ?? {
-				baseUri: ["'none'"],
-				defaultSrc: ["'none'"],
-				formAction: ["'self'"],
-				frameAncestors: ["'none'"],
-				styleSrc: ["'unsafe-inline'"]
-			}
-		},
-		crossOriginEmbedderPolicy: false,
-		crossOriginOpenerPolicy: false,
-		crossOriginResourcePolicy: { policy: "same-origin" },
-		hsts: false,
-		referrerPolicy: { policy: "no-referrer" }
-	});
-}
-//#endregion
-//#region ../../libs/loopback-companion/src/fetch-metadata.ts
-function headerValue(headers, name) {
-	const value = headers[name];
-	return typeof value === "string" ? value : void 0;
-}
-/**
-* Require that a request is a top-level browser navigation (used by local
-* approval pages that must be opened as a document, never fetched).
-*/
-function assertNavigationRequest(headers) {
-	const site = headerValue(headers, "sec-fetch-site");
-	const mode = headerValue(headers, "sec-fetch-mode");
-	const destination = headerValue(headers, "sec-fetch-dest");
-	if (site !== "cross-site" && site !== "same-origin" && site !== "none" || mode !== "navigate" || destination !== "document") throw new LoopbackViolationError("navigation_required", "Request must be opened as a browser navigation");
-}
-/**
-* Reject an explicit cross-site Fetch-Metadata signal. Only the explicit
-* `cross-site` value is rejected: Safari may omit Fetch Metadata on
-* same-origin form submissions, so the absence of the header is not treated
-* as a violation — callers keep their one-time token as the primary control.
-*/
-function rejectExplicitCrossSite(headers) {
-	if (headerValue(headers, "sec-fetch-site") === "cross-site") throw new LoopbackViolationError("cross_site_rejected", "Request must not originate cross-site");
-}
-//#endregion
-//#region src/lib/agent-server/lock.ts
-var AgentServerLockError = class extends Error {
-	name = "AgentServerLockError";
-	constructor(code, message, options) {
-		super(message, options);
-		this.code = code;
+	hasPendingRegistration(alias) {
+		return Boolean(this.readAgentServerState().pendingRegistrations[assertStoreName("agent name", alias)]);
 	}
-};
-/**
-* Acquire the per-root singleton lock. `proper-lockfile` uses an atomic lock
-* directory at exactly `<root>/agent-server.lock`, recovers stale owners, and keeps
-* the mtime fresh while the supervisor is alive.
-*/
-async function acquireAgentServerLock(root, options = {}) {
-	const path = join(root, "agent-server.lock");
-	let releaseLock;
-	try {
-		releaseLock = await lock(root, {
-			lockfilePath: path,
-			realpath: false,
-			retries: 0,
-			...options.staleMs === void 0 ? {} : { stale: options.staleMs },
-			...options.updateMs === void 0 ? {} : { update: options.updateMs },
-			onCompromised: (cause) => {
-				const error = new AgentServerLockError("compromised", `Agent Server lock ${path} was compromised: ${cause.message}`, { cause });
-				if (options.onCompromised) {
-					options.onCompromised(error);
-					return;
-				}
-				throw error;
-			}
-		});
-	} catch (cause) {
-		if (cause.code === "ELOCKED") throw new AgentServerLockError("held", `another moltnet-agent server process already owns ${path}`, { cause });
-		throw new AgentServerLockError("failed", `could not acquire Agent Server lock ${path}: ${cause.message}`, { cause });
+	reserveRegistration(alias, apiUrl) {
+		const name = assertStoreName("agent name", alias);
+		const state = this.readAgentServerState();
+		if (state.activations[name] || state.pendingRegistrations[name]) throw new AgentServerStoreError("already_exists", `agent "${name}" already exists in the agent server store`);
+		state.pendingRegistrations[name] = {
+			apiUrl,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.writeAgentServerState(state);
 	}
-	let released = false;
-	return {
-		path,
-		async release() {
-			if (released) return;
-			released = true;
-			await releaseLock();
-		}
-	};
-}
-/** Always release after normal completion or startup/runtime failure. */
-async function withAgentServerLock(root, work, options) {
-	const held = await acquireAgentServerLock(root, options);
-	try {
-		return await work();
-	} finally {
-		await held.release();
+	clearPendingRegistration(alias) {
+		const name = assertStoreName("agent name", alias);
+		const state = this.readAgentServerState();
+		delete state.pendingRegistrations[name];
+		this.writeAgentServerState(state);
 	}
-}
-//#endregion
-//#region src/lib/agent-server/pairing.ts
-/**
-* One-click pairing ceremony for the agent server, mirroring the signer's
-* session/ceremony pattern (#2062 design):
-*
-*   1. Console (allowed origin) POSTs `/v1/pairings` → pending pairing bound
-*      to that origin, with a one-time confirmation token.
-*   2. Console opens `http://127.0.0.1:<port>/pairings/<id>` in a new tab —
-*      a navigation-gated local approval page naming the origin.
-*   3. One click POSTs the confirmation form (explicit cross-site rejected;
-*      the one-time token is the primary CSRF control).
-*   4. Console claims `/v1/pairings/<id>/claim` from the same origin and
-*      receives the bearer token exactly once; only its SHA-256 remains in
-*      this supervisor process.
-*
-* The token exists for shared-machine cross-user protection and to bind
-* "this console session is the operator" — browser-vs-browser isolation is
-* already covered by the loopback-companion origin checks. Grants are
-* deliberately process-scoped: after the listening socket changes owners, a
-* token disclosed to an impostor on that port cannot authenticate to a later
-* supervisor process.
-*/
-var PENDING_TTL_MS = 600 * 1e3;
-var AgentServerPairingError = class extends Error {
-	name = "AgentServerPairingError";
-	constructor(code, message) {
-		super(message);
-		this.code = code;
+	writeActivation(activation) {
+		const alias = assertStoreName("agent name", activation.alias);
+		validateActivation(alias, activation);
+		const state = this.readAgentServerState();
+		state.activations[alias] = activation;
+		if (activation.source === "managed") delete state.pendingRegistrations[alias];
+		this.writeAgentServerState(state);
 	}
-};
-function sha256Hex(value) {
-	return createHash("sha256").update(value, "utf8").digest("hex");
-}
-function safeEqual(a, b) {
-	const left = Buffer.from(a, "utf8");
-	const right = Buffer.from(b, "utf8");
-	return left.length === right.length && timingSafeEqual(left, right);
-}
-var PairingService = class {
-	pending = /* @__PURE__ */ new Map();
-	paired = /* @__PURE__ */ new Map();
-	constructor(options = {}) {
-		this.options = options;
+	listActivations() {
+		return Object.values(this.readAgentServerState().activations).sort((a, b) => a.alias.localeCompare(b.alias));
 	}
-	now() {
-		return this.options.now?.() ?? Date.now();
+	get providersPath() {
+		return join(this.root, "providers.json");
 	}
-	token() {
-		return this.options.randomToken?.() ?? randomBytes(32).toString("base64url");
+	readProviders() {
+		const state = readJson(this.providersPath) ?? {};
+		this.validateProviders(state);
+		return state;
 	}
-	sweep() {
-		const now = this.now();
-		for (const [id, pairing] of this.pending) if (pairing.expiresAt <= now) this.pending.delete(id);
+	writeProviders(state) {
+		this.validateProviders(state);
+		writeJsonAtomic(this.providersPath, state);
 	}
-	start(origin) {
-		this.sweep();
-		const pairingId = randomBytes(12).toString("hex");
-		this.pending.set(pairingId, {
-			origin,
-			confirmToken: this.token(),
-			expiresAt: this.now() + PENDING_TTL_MS,
-			approved: false,
-			bearerToken: null
-		});
-		return {
-			pairingId,
-			approvalPath: `/pairings/${pairingId}`
-		};
+	validateProviders(state) {
+		for (const [id, provider] of Object.entries(state)) {
+			assertProviderId(id);
+			assertProviderEnvName(id, provider.envName);
+		}
 	}
-	/** Data for the local approval page. */
-	approval(pairingId) {
-		const pairing = this.require(pairingId);
-		if (pairing.approved) throw new AgentServerPairingError("pairing_invalid", "Pairing is already approved");
+	runDir(id) {
+		return storeChildPath(this.runsDir, "run id", id);
+	}
+	resolveRunLogPath(id) {
+		let root;
+		let runDir;
+		try {
+			root = realpathSync(this.runsDir);
+			runDir = realpathSync(this.runDir(id));
+		} catch (cause) {
+			throw new AgentServerStoreError("io_error", "could not resolve run directory", { cause });
+		}
+		if (!isStrictDescendant(root, runDir)) throw new AgentServerStoreError("invalid_state", "run directory escapes its store");
+		const logPath = join(runDir, "daemon.log");
+		try {
+			if (lstatSync(logPath).isSymbolicLink()) throw new AgentServerStoreError("invalid_state", "run log must not be a symbolic link");
+			const resolvedLog = realpathSync(logPath);
+			if (!isStrictDescendant(runDir, resolvedLog)) throw new AgentServerStoreError("invalid_state", "run log escapes its store");
+		} catch (cause) {
+			if (cause instanceof AgentServerStoreError) throw cause;
+			if (cause.code !== "ENOENT") throw new AgentServerStoreError("io_error", "could not resolve run log", { cause });
+		}
+		return logPath;
+	}
+	createRunDir(id) {
+		const dir = this.runDir(id);
+		const piDir = join(dir, "pi");
+		mkdirSync(piDir, {
+			recursive: true,
+			mode: 448
+		});
 		return {
-			origin: pairing.origin,
-			confirmToken: pairing.confirmToken
+			dir,
+			piDir,
+			logPath: join(dir, "daemon.log")
 		};
 	}
-	confirm(pairingId, confirmToken) {
-		const pairing = this.require(pairingId);
-		if (pairing.approved || !safeEqual(pairing.confirmToken, confirmToken)) throw new AgentServerPairingError("pairing_invalid", "Confirmation token is not valid");
-		pairing.approved = true;
-		pairing.bearerToken = this.token();
-		return { origin: pairing.origin };
+	readRun(id) {
+		return readJson(join(this.runDir(id), "run.json"));
 	}
-	claim(pairingId, origin) {
-		const pairing = this.require(pairingId);
-		if (pairing.origin !== origin) throw new AgentServerPairingError("pairing_origin_mismatch", "Pairing belongs to a different origin");
-		if (!pairing.approved || !pairing.bearerToken) throw new AgentServerPairingError("pairing_not_approved", "Pairing has not been approved yet");
-		const token = pairing.bearerToken;
-		this.pending.delete(pairingId);
-		this.paired.set(origin, sha256Hex(token));
-		return { token };
+	writeRun(record) {
+		writeJsonAtomic(join(this.runDir(record.id), "run.json"), record);
 	}
-	verify(origin, token) {
-		const tokenHash = this.paired.get(origin);
-		if (!tokenHash || !safeEqual(tokenHash, sha256Hex(token))) throw new AgentServerPairingError("pairing_token_invalid", "Pairing token is not valid for this origin");
+	listRuns(limit = Number.POSITIVE_INFINITY) {
+		let ids;
+		try {
+			ids = readdirSync(this.runsDir);
+		} catch {
+			return [];
+		}
+		const sortedIds = ids.filter((id) => NAME_RE.test(id)).sort().reverse();
+		const selectedIds = Number.isFinite(limit) ? sortedIds.slice(0, Math.max(0, limit)) : sortedIds;
+		const records = [];
+		for (const id of selectedIds) {
+			const record = this.readRun(id);
+			if (record) records.push(record);
+		}
+		return records.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 	}
-	require(pairingId) {
-		this.sweep();
-		const pairing = this.pending.get(pairingId);
-		if (!pairing) throw new AgentServerPairingError("pairing_not_found", "Pairing was not found or has expired");
-		return pairing;
+	/** Remove only completed run directories outside the configured budget. */
+	pruneCompletedRuns(options) {
+		const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+		let retainedBytes = 0;
+		let retainedCount = 0;
+		const removed = [];
+		for (const record of this.listRuns()) {
+			if (record.status === "running") continue;
+			const dir = this.runDir(record.id);
+			const bytes = directoryBytes(dir);
+			const endedAt = Date.parse(record.endedAt ?? record.startedAt);
+			const expired = !Number.isFinite(endedAt) || now - endedAt > options.maxAgeMs;
+			const overCount = retainedCount >= options.maxCount;
+			const overBytes = retainedBytes + bytes > options.maxBytes;
+			if (expired || overCount || overBytes) {
+				rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+				removed.push(record.id);
+				continue;
+			}
+			retainedCount += 1;
+			retainedBytes += bytes;
+		}
+		return removed;
 	}
 };
-function escapeHtml(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+function directoryBytes(path) {
+	let info;
+	try {
+		info = lstatSync(path);
+	} catch {
+		return 0;
+	}
+	if (info.isSymbolicLink()) return 0;
+	if (!info.isDirectory()) return info.size;
+	let total = 0;
+	for (const entry of readdirSync(path, { withFileTypes: true })) total += directoryBytes(join(path, entry.name));
+	return total;
 }
-/** Minimal, dependency-free local approval page. */
-function renderPairingApprovalPage(input) {
-	return `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>MoltNet Agent — approve connection</title>
-<style>
-  :root { color-scheme: light dark; }
-  body { margin: 0; font: 16px/1.5 system-ui, sans-serif; display: grid; place-items: center; min-height: 100vh; background: Canvas; color: CanvasText; }
-  main { max-width: 26rem; padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 20%, transparent); border-radius: 12px; }
-  h1 { font-size: 1.2rem; margin: 0 0 0.5rem; }
-  code { font-size: 0.95em; word-break: break-all; }
-  button { margin-top: 1.25rem; font: inherit; padding: 0.6rem 1.4rem; border-radius: 8px; border: 1px solid color-mix(in srgb, CanvasText 30%, transparent); cursor: pointer; }
-  p.small { font-size: 0.85rem; opacity: 0.75; }
-</style>
-</head>
-<body>
-<script>
-  // The Console must remain this popup's opener until it finishes navigating
-  // from about:blank. Safari rejects that cross-origin navigation otherwise.
-  // Once this trusted local approval document has loaded, it needs no opener.
-  window.opener = null;
-<\/script>
-<main>
-<h1>Allow this site to manage local MoltNet agents?</h1>
-<p><code>${escapeHtml(input.origin)}</code> asks to configure agents and start or stop local daemon runs on this machine.</p>
-<p class="small">Approve only if you opened that page yourself. This grant lasts until the local supervisor stops.</p>
-<form method="post" action="/pairings/${escapeHtml(input.pairingId)}/confirm">
-<input type="hidden" name="confirmToken" value="${escapeHtml(input.confirmToken)}" />
-<button type="submit">Approve</button>
-</form>
-</main>
-</body>
-</html>
-`;
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function renderPairingResultPage(input) {
-	return `<!doctype html>
-<html lang="en">
-<head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml(input.title)}</title>
-<style>:root{color-scheme:light dark}body{margin:0;font:16px/1.5 system-ui,sans-serif;display:grid;place-items:center;min-height:100vh;background:Canvas;color:CanvasText}main{max-width:26rem;padding:2rem}</style>
-</head>
-<body><main role="status"><h1>${escapeHtml(input.title)}</h1><p>${escapeHtml(input.message)}</p><p>You can close this tab.</p></main></body>
-</html>
-`;
+function storeChildPath(root, kind, value, suffix = "") {
+	const name = assertStoreName(kind, value);
+	const normalizedRoot = resolve(root);
+	const candidate = resolve(normalizedRoot, `${name}${suffix}`);
+	if (!isStrictDescendant(normalizedRoot, candidate)) throw new AgentServerStoreError("invalid_name", `${kind} escapes its store`);
+	return candidate;
+}
+function isStrictDescendant(root, candidate) {
+	const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
+	return candidate !== root && candidate.startsWith(rootPrefix);
+}
+function validateActivation(alias, value) {
+	const invalid = () => {
+		throw new AgentServerStoreError("invalid_state", `activation "${alias}" is not a valid version 2 activation`);
+	};
+	if (!isRecord$1(value)) invalid();
+	const activation = value;
+	if (activation.alias !== alias) invalid();
+	if (![
+		"subjectId",
+		"publicKey",
+		"fingerprint",
+		"createdAt"
+	].every((field) => typeof activation[field] === "string" && activation[field].length > 0)) invalid();
+	if (activation.source === "managed") {
+		if (typeof activation.apiUrl !== "string" || activation.apiUrl.length === 0 || activation.configPath !== void 0 || activation.configApiUrl !== void 0) invalid();
+		return;
+	}
+	if (activation.source !== "external" || typeof activation.configPath !== "string" || activation.configPath.length === 0 || typeof activation.configApiUrl !== "string" || activation.configApiUrl.length === 0 || activation.apiUrl !== void 0 && typeof activation.apiUrl !== "string") invalid();
 }
 //#endregion
-//#region src/lib/agent-server/provider-login.ts
+//#region src/lib/provider-lock.ts
+var DEFAULT_LOCK_TIMEOUT_MS = 3e4;
+var LOCK_WAIT_WARNING_MS = 1e3;
+var ProviderLockError = class extends Error {
+	name = "ProviderLockError";
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+	}
+};
 /**
-* Subscription-provider OAuth brokering for Agent Server (#2061 slice 4).
-*
-* The console clicks "Connect"; agent server runs the Pi OAuth flow host-side via
-* `ModelRuntime.login()` (which owns persistence into the shared
-* `pi/auth.json` and token rotation thereafter). The browser only ever sees
-* the provider's authorize URL or device code — never tokens.
-*
-* Provider ids come from Pi's model runtime, so Agent Server stays in lockstep
-* with supported subscription providers. GitHub Copilot is intentionally
-* excluded: MoltNet does not broker editor-seat subscription credentials.
+* Serialize provider state shared by the CLI and the long-running Agent Server.
+* The lock target is a stable directory because the protected JSON files may
+* not exist yet.
 */
-var LOGIN_TTL_MS = 600 * 1e3;
-/** How long `start()` waits for the flow to surface a URL / device code. */
-var START_INFO_TIMEOUT_MS = 5e3;
-var EXCLUDED_SUBSCRIPTION_PROVIDERS = new Set(["github-copilot"]);
-var AgentServerSubscriptionError = class extends Error {
-	name = "AgentServerSubscriptionError";
+async function withProviderMutationLock(root, work, options = {}) {
+	return withNamedProviderLock(root, "providers", work, options);
+}
+/** Serialize Pi credential operations for one provider across processes. */
+async function withProviderOAuthLock(root, providerId, work, options = {}) {
+	return withNamedProviderLock(root, `oauth-${encodeURIComponent(providerId)}`, work, options);
+}
+async function withNamedProviderLock(root, name, work, options) {
+	const locksDir = join(root, "locks");
+	mkdirSync(locksDir, {
+		recursive: true,
+		mode: 448
+	});
+	let compromised;
+	const startedAt = Date.now();
+	const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+	const lockfilePath = join(locksDir, `${name}.lock`);
+	let warned = false;
+	let release;
+	for (;;) {
+		if (options.signal?.aborted) throw new ProviderLockError("lock_aborted", `provider lock acquisition was cancelled for "${name}"`, { cause: options.signal.reason });
+		const elapsedMs = Date.now() - startedAt;
+		if (elapsedMs >= timeoutMs) throw new ProviderLockError("lock_timeout", `timed out waiting for provider lock "${name}"`);
+		if (!warned && elapsedMs >= LOCK_WAIT_WARNING_MS) {
+			warned = true;
+			options.logger?.warn({
+				code: "provider_lock_contended",
+				elapsedMs,
+				lockName: name
+			}, "Provider operation is waiting for another process");
+		}
+		try {
+			release = await lock(locksDir, {
+				lockfilePath,
+				onCompromised: (error) => {
+					compromised = error;
+				},
+				realpath: false,
+				retries: 0
+			});
+			break;
+		} catch (error) {
+			if (error.code !== "ELOCKED") throw error;
+			const remainingMs = timeoutMs - elapsedMs;
+			try {
+				await setTimeout$1(Math.min(100, remainingMs), void 0, { ...options.signal ? { signal: options.signal } : {} });
+			} catch (cause) {
+				throw new ProviderLockError("lock_aborted", `provider lock acquisition was cancelled for "${name}"`, { cause });
+			}
+		}
+	}
+	let outcome;
+	try {
+		outcome = {
+			ok: true,
+			value: await work()
+		};
+	} catch (error) {
+		outcome = {
+			ok: false,
+			error
+		};
+	}
+	try {
+		await release();
+	} catch (error) {
+		if (!compromised && outcome.ok) outcome = {
+			ok: false,
+			error
+		};
+	}
+	if (!outcome.ok) throw outcome.error;
+	if (compromised) throw compromised;
+	return outcome.value;
+}
+//#endregion
+//#region src/lib/oauth-provider.ts
+var EXCLUDED_OAUTH_PROVIDERS = new Set(["github-copilot"]);
+function isOAuthProviderEligible(provider) {
+	return provider.auth.oauth !== void 0 && isOAuthProviderIdEligible(provider.id);
+}
+function isOAuthProviderIdEligible(providerId) {
+	return !EXCLUDED_OAUTH_PROVIDERS.has(providerId);
+}
+var silentLogger$2 = { warn: () => void 0 };
+var OAuthProviderError = class extends Error {
+	name = "OAuthProviderError";
 	constructor(code, message) {
 		super(message);
 		this.code = code;
 	}
 };
-var silentLogger = {
-	info: () => void 0,
-	warn: () => void 0,
-	error: () => void 0
-};
-var ProviderLoginService = class ProviderLoginService {
-	logins = /* @__PURE__ */ new Map();
-	logger;
-	constructor(options) {
-		this.options = options;
-		this.logger = options.logger ?? silentLogger;
+var OAuthProviderService = class OAuthProviderService {
+	constructor(authPath, runtime, logger) {
+		this.authPath = authPath;
+		this.runtime = runtime;
+		this.logger = logger;
 	}
 	static async create(options) {
-		const modelRuntime = await ModelRuntime.create({
+		const runtime = options.modelRuntime ?? await ModelRuntime.create({
 			authPath: options.authPath,
 			refreshOnCreate: false
 		});
-		return new ProviderLoginService({
-			...options,
-			modelRuntime
+		return new OAuthProviderService(options.authPath, runtime, options.logger ?? silentLogger$2);
+	}
+	list() {
+		const providers = this.oauthProviders();
+		const connected = this.connectedProviderIds(providers);
+		return providers.map((provider) => ({
+			id: provider.id,
+			name: provider.name,
+			connected: connected.has(provider.id)
+		}));
+	}
+	async login(providerId, interaction, options = {}) {
+		this.assertProvider(providerId);
+		await withProviderOAuthLock(dirname(this.authPath), providerId, async () => {
+			try {
+				await this.runtime.login(providerId, "oauth", interaction);
+			} finally {
+				await options.onSettledUnderLock?.();
+			}
+		}, {
+			signal: options.signal,
+			logger: this.logger
 		});
 	}
-	now() {
-		return this.options.now?.() ?? Date.now();
+	async logout(providerId, signal) {
+		this.assertProvider(providerId);
+		await withProviderOAuthLock(dirname(this.authPath), providerId, () => this.runtime.logout(providerId), {
+			signal,
+			logger: this.logger
+		});
 	}
-	providers() {
-		return (this.options.listProviders ? this.options.listProviders() : this.runtime().getProviders().filter((provider) => provider.auth.oauth !== void 0).map((provider) => ({
-			id: provider.id,
-			name: provider.name
-		}))).filter((provider) => !EXCLUDED_SUBSCRIPTION_PROVIDERS.has(provider.id));
+	assertProvider(providerId) {
+		if (!this.oauthProviders().some((provider) => provider.id === providerId)) throw new OAuthProviderError("provider_unknown", `"${providerId}" is not a known OAuth provider`);
 	}
-	connected(providerId) {
-		if (this.options.isConnected) return this.options.isConnected(providerId);
+	oauthProviders() {
+		return this.runtime.getProviders().filter(isOAuthProviderEligible).map(({ id, name }) => ({
+			id,
+			name
+		}));
+	}
+	connectedProviderIds(providers) {
 		try {
-			return readStoredCredential(providerId, this.options.authPath) !== void 0;
+			const content = readFileSync(this.authPath, "utf8").replace(/^\uFEFF/u, "");
+			const parsed = JSON.parse(content);
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("Invalid auth.json: expected an object");
+			return new Set(Object.keys(parsed));
 		} catch (error) {
-			this.logger.warn({
+			if (error.code !== "ENOENT") for (const provider of providers) this.logger.warn({
 				event: "agent-server.subscription_auth_read_failed",
-				providerId,
-				...safeLoginError(error)
+				providerId: provider.id,
+				...safeOAuthError(error)
 			}, "Could not read subscription authentication state");
-			return false;
+			return /* @__PURE__ */ new Set();
 		}
 	}
-	runtime() {
-		if (!this.options.modelRuntime) throw new Error("ProviderLoginService requires a model runtime when production adapters are not overridden");
-		return this.options.modelRuntime;
+};
+function safeOAuthError(error) {
+	const result = { errorType: error instanceof Error ? error.name : typeof error };
+	const code = error?.code;
+	if (typeof code === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(code)) result["applicationCode"] = code;
+	return result;
+}
+var AgentServerModelDiscoveryError = class extends Error {
+	name = "AgentServerModelDiscoveryError";
+	constructor(code, message, statusCode, options) {
+		super(message, options);
+		this.code = code;
+		this.statusCode = statusCode;
 	}
-	list() {
-		this.sweep();
-		return this.providers().map((provider) => ({
-			...provider,
-			connected: this.connected(provider.id)
-		}));
+};
+var ModelDiscoveryCollector = class {
+	models = /* @__PURE__ */ new Set();
+	addOpenAiResponse(value) {
+		if (!isRecord(value) || !Array.isArray(value["data"])) return;
+		for (const candidate of value["data"]) {
+			if (!isRecord(candidate)) continue;
+			const id = candidate["id"];
+			if (typeof id === "string" && id.length > 0) this.models.add(id);
+		}
 	}
-	sweep() {
-		const now = this.now();
-		for (const [id, login] of this.logins) if (login.startedAt + LOGIN_TTL_MS <= now) {
-			if (login.status === "pending") this.invalidate(login, "expired");
-			this.logins.delete(id);
+	addOllamaResponse(value) {
+		if (!isRecord(value) || !Array.isArray(value["models"])) return;
+		for (const candidate of value["models"]) {
+			if (!isRecord(candidate)) continue;
+			const name = candidate["name"];
+			if (typeof name === "string" && name.length > 0) this.models.add(name);
 		}
 	}
-	restoreCredential(login) {
+	get size() {
+		return this.models.size;
+	}
+	result(providerId, failures) {
+		if (this.models.size === 0) throw discoveryFailure(providerId, failures);
+		return {
+			models: [...this.models].sort().slice(0, 500),
+			discoveredCount: this.models.size
+		};
+	}
+};
+function parseProviderBaseUrl(value, providerId) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch (cause) {
+		throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" has an invalid base URL`, 400, { cause });
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must be HTTP(S) without credentials, query, or fragment`, 400);
+	if (isNonLoopbackPrivateAddress(parsed.hostname)) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must not target a private network address`, 400);
+	return parsed;
+}
+function isNonLoopbackPrivateAddress(hostname) {
+	if (isIP(hostname) !== 4) return false;
+	const [first, second] = hostname.split(".").map(Number);
+	if (first === 127) return false;
+	return first === 10 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 169 && second === 254;
+}
+function discoveryFailure(providerId, failures) {
+	if (failures.some((failure) => failure.kind === "http" && (failure.status === 401 || failure.status === 403))) return new AgentServerModelDiscoveryError("discovery_unauthorized", `provider "${providerId}" rejected model discovery; check its API key`, 502);
+	if (failures.some((failure) => failure.kind === "network")) return new AgentServerModelDiscoveryError("discovery_unavailable", `provider "${providerId}" could not be reached for model discovery`, 502);
+	if (failures.some((failure) => failure.kind === "invalid_response")) return new AgentServerModelDiscoveryError("discovery_invalid_response", `provider "${providerId}" returned an invalid model response`, 502);
+	return new AgentServerModelDiscoveryError("discovery_failed", `no models discovered for provider "${providerId}"`, 502);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/lib/safe-error-context.ts
+function safeErrorContext(error) {
+	const context = { errorType: error instanceof Error ? error.name : typeof error };
+	const applicationCode = safeErrorToken(error?.code);
+	if (applicationCode) context["applicationCode"] = applicationCode;
+	const cause = error instanceof Error ? error.cause : void 0;
+	if (cause instanceof Error) {
+		context["causeType"] = cause.name;
+		const causeMessage = safeLogMessage(cause.message);
+		if (causeMessage) context["causeMessage"] = causeMessage;
+	}
+	const fsCode = safeErrorToken(cause?.code);
+	const syscall = safeErrorToken(cause?.syscall);
+	if (fsCode) context["fsCode"] = fsCode;
+	if (syscall) context["syscall"] = syscall;
+	const causeStatus = cause?.statusCode;
+	if (typeof causeStatus === "number") context["causeStatusCode"] = causeStatus;
+	return context;
+}
+function safeLogMessage(value) {
+	const normalized = value.replace(/[\r\n\t]/gu, " ").trim();
+	return normalized ? normalized.slice(0, 500) : void 0;
+}
+function safeErrorToken(value) {
+	return typeof value === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(value) ? value : void 0;
+}
+//#endregion
+//#region src/lib/provider-configuration.ts
+var DEFAULT_PROVIDER_API = "openai-completions";
+var ProviderConfigurationError = class extends Error {
+	name = "ProviderConfigurationError";
+	constructor(code, message, statusCode, options) {
+		super(message, options);
+		this.code = code;
+		this.statusCode = statusCode;
+	}
+};
+var silentLogger$1 = {
+	info: () => void 0,
+	warn: () => void 0
+};
+var ProviderConfigurationService = class {
+	fetchImpl;
+	logger;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.logger = options.logger ?? silentLogger$1;
+	}
+	list() {
+		return Object.fromEntries(Object.entries(this.options.store.readProviders()).map(([id, provider]) => [id, providerView(provider)]));
+	}
+	async set(providerIdInput, input, options = {}) {
+		const providerId = assertProviderId(providerIdInput);
+		if (input.apiKey !== void 0 && input.clearApiKey) throw new ProviderConfigurationError("invalid_provider", "apiKey and clearApiKey cannot be used together", 400);
+		if (input.apiKey !== void 0 && input.apiKey.length === 0) throw new ProviderConfigurationError("invalid_provider", "provider API key must not be empty", 400);
+		return withProviderMutationLock(this.options.store.root, async () => {
+			const providers = this.options.store.readProviders();
+			const previous = providers[providerId];
+			const baseUrl = input.baseUrl ?? previous?.baseUrl;
+			if (!baseUrl) throw new ProviderConfigurationError("invalid_provider", `base URL is required when creating provider "${providerId}"`, 400);
+			parseProviderBaseUrl(baseUrl, providerId);
+			const entry = {
+				api: input.api ?? previous?.api ?? DEFAULT_PROVIDER_API,
+				baseUrl,
+				envName: assertProviderEnvName(providerId, input.envName ?? previous?.envName ?? providerEnvName(providerId)),
+				models: [...input.models ?? previous?.models ?? []],
+				...!input.clearApiKey && previous?.apiKeyRef ? { apiKeyRef: previous.apiKeyRef } : {}
+			};
+			const key = `pi-provider/${providerId}`;
+			let previousSecret;
+			const previousKey = managedSecretKey(previous?.apiKeyRef);
+			if ((input.apiKey !== void 0 || input.clearApiKey) && previous?.apiKeyRef) try {
+				previousSecret = await this.options.secretProviders.resolve(parseSecretReferenceString(previous.apiKeyRef));
+			} catch (error) {
+				if (input.clearApiKey) throw new ProviderConfigurationError("provider_secret_unavailable", `provider "${providerId}" API key could not be prepared for removal`, 400, { cause: error });
+			}
+			if (input.apiKey !== void 0) {
+				await this.options.secrets.write(key, input.apiKey);
+				entry.apiKeyRef = formatSecretReferenceString({
+					provider: FILE_SECRET_PROVIDER,
+					key
+				});
+			}
+			if (input.clearApiKey && previousKey) await this.options.secrets.delete(previousKey);
+			try {
+				providers[providerId] = entry;
+				this.options.store.writeProviders(providers);
+			} catch (error) {
+				try {
+					if (input.apiKey !== void 0) if (previousKey === key && previousSecret !== void 0) await this.options.secrets.write(key, previousSecret);
+					else await this.options.secrets.delete(key);
+					else if (input.clearApiKey && previousKey && previousSecret !== void 0) await this.options.secrets.write(previousKey, previousSecret);
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], "provider update failed and secret rollback was unsuccessful");
+				}
+				throw error;
+			}
+			return providerView(entry);
+		}, {
+			signal: options.signal,
+			logger: this.logger
+		});
+	}
+	async remove(providerIdInput, options = {}) {
+		const providerId = assertProviderId(providerIdInput);
+		await withProviderMutationLock(this.options.store.root, async () => {
+			const providers = this.options.store.readProviders();
+			const provider = providers[providerId];
+			if (!provider) throw new ProviderConfigurationError("provider_not_found", `Provider ${providerId} was not found`, 404);
+			const key = managedSecretKey(provider.apiKeyRef);
+			let previousSecret;
+			if (provider.apiKeyRef) try {
+				previousSecret = await this.options.secretProviders.resolve(parseSecretReferenceString(provider.apiKeyRef));
+			} catch (error) {
+				throw new ProviderConfigurationError("provider_secret_unavailable", `provider "${providerId}" API key could not be prepared for removal`, 400, { cause: error });
+			}
+			if (key) await this.options.secrets.delete(key);
+			delete providers[providerId];
+			try {
+				this.options.store.writeProviders(providers);
+			} catch (error) {
+				if (key && previousSecret !== void 0) try {
+					await this.options.secrets.write(key, previousSecret);
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], "provider removal failed and secret rollback was unsuccessful");
+				}
+				throw error;
+			}
+		}, {
+			signal: options.signal,
+			logger: this.logger
+		});
+	}
+	async discover(providerIdInput, options = {}) {
+		const providerId = assertProviderId(providerIdInput);
+		const provider = this.options.store.readProviders()[providerId];
+		if (!provider) throw new ProviderConfigurationError("provider_not_found", `provider "${providerId}" was not found`, 404);
+		const parsed = parseProviderBaseUrl(provider.baseUrl, providerId);
+		const baseUrl = parsed.href.replace(/\/$/u, "");
+		const apiKey = await this.resolveApiKey(providerId, provider);
+		const headers = apiKey ? { authorization: `Bearer ${apiKey}` } : {};
+		const failures = [];
+		const collector = new ModelDiscoveryCollector();
+		collector.addOpenAiResponse(await this.requestDiscoveryEndpoint({
+			endpoint: "openai_models",
+			failures,
+			headers,
+			providerId,
+			signal: options.signal,
+			url: `${baseUrl}/models`
+		}));
+		if (isOllamaProvider(providerId, parsed)) collector.addOllamaResponse(await this.requestDiscoveryEndpoint({
+			endpoint: "ollama_tags",
+			failures,
+			headers,
+			providerId,
+			signal: options.signal,
+			url: `${parsed.origin}/api/tags`
+		}));
+		const result = collector.result(providerId, failures);
+		if (result.discoveredCount > result.models.length) this.logger.warn({
+			code: "agent_server_provider_discovery_truncated",
+			discoveredCount: result.discoveredCount,
+			providerId,
+			returnedCount: 500
+		}, "Provider model discovery result was truncated");
+		if (options.save) await this.set(providerId, { models: result.models }, options);
+		this.logger.info({
+			code: "agent_server_provider_discovery_completed",
+			modelCount: result.models.length,
+			providerId
+		}, "Provider model discovery completed");
+		return { models: result.models };
+	}
+	async resolveApiKey(providerId, provider) {
+		if (!provider.apiKeyRef) return void 0;
 		try {
-			restoreStoredCredential(this.options.authPath, login.providerId, login.previousCredential);
-			return true;
+			return await this.options.secretProviders.resolve(parseSecretReferenceString(provider.apiKeyRef));
 		} catch (error) {
-			this.logger.error({
-				event: "agent-server.subscription_login_cleanup_failed",
-				operationId: login.operationId,
-				providerId: login.providerId,
-				...safeLoginError(error)
-			}, "Could not restore subscription credentials after an invalidated login");
-			return false;
+			this.logger.warn({
+				...safeErrorContext(error),
+				code: "agent_server_provider_secret_unavailable",
+				providerId
+			}, "Provider API key could not be resolved for model discovery");
+			throw new ProviderConfigurationError("provider_secret_unavailable", `provider "${providerId}" API key could not be resolved`, 400, { cause: error });
 		}
 	}
-	invalidate(login, transition) {
-		if (login.invalidated) return true;
-		login.invalidated = true;
-		login.abort.abort(/* @__PURE__ */ new Error(`subscription login ${transition}`));
-		const restored = this.restoreCredential(login);
-		login.infoArrived();
-		this.logger.info({
-			event: "agent-server.subscription_login_transition",
-			operationId: login.operationId,
-			providerId: login.providerId,
-			transition
-		}, "Subscription login invalidated");
-		return restored;
-	}
-	status(providerId) {
-		this.sweep();
-		const login = this.logins.get(providerId);
-		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
-		return snapshot(login);
-	}
-	/**
-	* Start (or return the in-flight) login for a provider. Resolves once the
-	* flow has surfaced an authorize URL / device code, completed, or the
-	* start window elapsed — whichever comes first.
-	*/
-	async start(providerId) {
-		this.sweep();
-		if (!this.providers().some((provider) => provider.id === providerId)) throw new AgentServerSubscriptionError("provider_unknown", `"${providerId}" is not a known subscription provider`);
-		const existing = this.logins.get(providerId);
-		if (existing && existing.status === "pending") return snapshot(existing);
-		let infoArrived = () => void 0;
-		const infoPromise = new Promise((resolvePromise) => {
-			infoArrived = () => resolvePromise();
-		});
-		const abort = new AbortController();
-		const login = {
-			providerId,
-			status: "pending",
-			operationId: randomUUID(),
-			startedAt: this.now(),
-			infoArrived,
-			abort,
-			invalidated: false,
-			previousCredential: readStoredCredential(providerId, this.options.authPath)
-		};
-		this.logins.set(providerId, login);
-		this.logger.info({
-			event: "agent-server.subscription_login_transition",
-			operationId: login.operationId,
-			providerId,
-			transition: "started"
-		}, "Subscription login started");
-		const callbacks = createLoginCallbacks(login, this.logger);
-		(this.options.runLogin ?? ((id, loginCallbacks) => this.runtime().login(id, "oauth", toAuthInteraction(loginCallbacks)).then(() => void 0)))(providerId, callbacks).then(() => {
-			if (login.invalidated) {
-				this.restoreCredential(login);
-				return;
-			}
-			if (!this.options.runLogin && !this.connected(providerId)) {
-				login.status = "failed";
-				login.error = "Subscription sign-in completed, but credentials were not persisted. Start again to retry.";
-				this.logger.error({
-					event: "agent-server.subscription_login_transition",
-					operationId: login.operationId,
-					providerId,
-					transition: "persistence_failed"
-				}, "Subscription login credentials were not persisted");
-			} else {
-				login.status = "completed";
+	async requestDiscoveryEndpoint(input) {
+		const startedAt = Date.now();
+		const timeout = AbortSignal.timeout(this.options.requestTimeoutMs ?? 1e4);
+		let response;
+		try {
+			response = await this.fetchImpl(input.url, {
+				headers: input.headers,
+				redirect: "error",
+				signal: input.signal ? AbortSignal.any([input.signal, timeout]) : timeout
+			});
+		} catch (error) {
+			const elapsedMs = Date.now() - startedAt;
+			if (input.signal?.aborted) {
+				const abortSource = providerAbortSource(input.signal.reason);
 				this.logger.info({
-					event: "agent-server.subscription_login_transition",
-					operationId: login.operationId,
-					providerId,
-					transition: "completed"
-				}, "Subscription login completed");
-			}
-			login.infoArrived();
-		}, (error) => {
-			if (login.invalidated) {
-				this.restoreCredential(login);
-				return;
+					abortSource,
+					code: "agent_server_provider_discovery_cancelled",
+					elapsedMs,
+					endpoint: input.endpoint,
+					providerId: input.providerId
+				}, "Provider model discovery was cancelled");
+				throw new ProviderConfigurationError("operation_aborted", `provider "${input.providerId}" discovery was cancelled`, 408, { cause: error });
 			}
-			login.status = "failed";
-			login.error = publicLoginError(error);
+			const errorType = error instanceof Error ? error.name : typeof error;
+			input.failures.push({
+				kind: "network",
+				errorType
+			});
 			this.logger.warn({
-				event: "agent-server.subscription_login_transition",
-				operationId: login.operationId,
-				providerId,
-				transition: "failed",
-				...safeLoginError(error)
-			}, "Subscription login failed");
-			login.infoArrived();
-		});
-		if (!await Promise.race([infoPromise, new Promise((resolvePromise) => {
-			setTimeout(() => resolvePromise(), START_INFO_TIMEOUT_MS).unref?.();
-		})]).then(() => login.authUrl !== void 0 || login.userCode !== void 0 || login.status !== "pending")) {
-			login.waitingForAuthorization = true;
+				abortSource: timeout.aborted ? "timeout" : void 0,
+				code: timeout.aborted ? "agent_server_provider_discovery_timeout" : "agent_server_provider_discovery_request_failed",
+				elapsedMs,
+				endpoint: input.endpoint,
+				errorType,
+				providerId: input.providerId
+			}, timeout.aborted ? "Provider model discovery request timed out" : "Provider model discovery request failed");
+			return null;
+		}
+		if (!response.ok) {
+			input.failures.push({
+				kind: "http",
+				status: response.status
+			});
+			const context = {
+				code: "agent_server_provider_discovery_upstream_error",
+				elapsedMs: Date.now() - startedAt,
+				endpoint: input.endpoint,
+				providerId: input.providerId,
+				statusCode: response.status
+			};
+			if (response.status >= 500 || response.status === 401 || response.status === 403) this.logger.warn(context, "Provider model discovery was rejected");
+			else this.logger.info(context, "Provider model discovery endpoint unavailable");
+			return null;
+		}
+		try {
+			return await response.json();
+		} catch {
+			input.failures.push({ kind: "invalid_response" });
 			this.logger.warn({
-				event: "serve.subscription_login_start_info_timeout",
-				operationId: login.operationId,
-				providerId,
-				timeoutMs: START_INFO_TIMEOUT_MS
-			}, "Subscription login is still waiting for authorization information");
+				code: "agent_server_provider_discovery_invalid_json",
+				elapsedMs: Date.now() - startedAt,
+				endpoint: input.endpoint,
+				providerId: input.providerId
+			}, "Provider model discovery returned invalid JSON");
+			return null;
 		}
-		return snapshot(login);
 	}
-	/** Abort an in-flight login and forget it. */
-	cancel(providerId) {
-		const login = this.logins.get(providerId);
-		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
-		if (!this.invalidate(login, "cancelled")) throw new AgentServerSubscriptionError("login_cleanup_failed", `could not safely cancel login for "${providerId}"; credential cleanup requires intervention`);
-		this.logins.delete(providerId);
-		return {
-			providerId,
-			status: "cancelled"
-		};
+};
+function providerView(provider) {
+	return {
+		api: provider.api,
+		baseUrl: provider.baseUrl,
+		envName: provider.envName,
+		models: [...provider.models],
+		hasApiKey: Boolean(provider.apiKeyRef)
+	};
+}
+function isOllamaProvider(providerId, baseUrl) {
+	return providerId === "ollama" || providerId.startsWith("ollama-") || baseUrl.hostname === "ollama.com" || baseUrl.port === "11434";
+}
+function managedSecretKey(reference) {
+	if (!reference) return void 0;
+	try {
+		const parsed = parseSecretReferenceString(reference);
+		return parsed.provider === FILE_SECRET_PROVIDER ? parsed.key : void 0;
+	} catch {
+		return;
 	}
-	/** Abort every pending flow during supervisor shutdown. */
-	close() {
-		for (const login of this.logins.values()) if (login.status === "pending") this.invalidate(login, "shutdown");
-		this.logins.clear();
+}
+function providerAbortSource(reason) {
+	if (typeof reason === "object" && reason !== null && "source" in reason && reason.source === "shutdown") return "shutdown";
+	return "caller";
+}
+//#endregion
+//#region src/cli/providers.ts
+async function runProviders(argv, dependencies = {}) {
+	if (isHelpFlag(argv) || argv.length === 0) {
+		(dependencies.stdout ?? console.log)(PROVIDERS_HELP);
+		return argv.length === 0 ? 1 : 0;
+	}
+	let context;
+	try {
+		const [command, ...args] = argv;
+		const parsed = parseProviderArgsSafely(command, args);
+		context = await createContext(parsed.root, dependencies, parsed.command !== "list");
+		switch (parsed.command) {
+			case "list": return listProviders(context, parsed.json);
+			case "set": return await setProvider(context, parsed);
+			case "discover": return await discoverProvider(context, parsed);
+			case "remove": return await removeProvider(context, parsed);
+			case "login": return await loginProvider(context, parsed);
+			case "logout": return await logoutProvider(context, parsed);
+			default: throw new ProviderCliError("invalid_arguments", `Unknown providers command "${String(command)}"`);
+		}
+	} catch (error) {
+		(context?.stderr ?? dependencies.stderr ?? console.error)(publicCliError(error, context?.signal));
+		return 1;
+	} finally {
+		context?.close();
+	}
+}
+var ProviderCliError = class extends Error {
+	name = "ProviderCliError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
 	}
 };
-function toAuthInteraction(callbacks) {
+function parseProviderArgsSafely(command, args) {
+	try {
+		return parseProviderArgs(command, args);
+	} catch (error) {
+		if (error instanceof ProviderCliError) throw error;
+		if (error instanceof Error && error.name === "ParseArgsError") throw new ProviderCliError("invalid_arguments", error.message);
+		throw error;
+	}
+}
+function parseProviderArgs(command, args) {
+	const common = { root: { type: "string" } };
+	switch (command) {
+		case "list": {
+			const { values, positionals } = parseArgs({
+				args,
+				options: {
+					...common,
+					json: { type: "boolean" }
+				},
+				allowPositionals: true,
+				strict: true
+			});
+			requirePositionals(positionals, 0, "providers list");
+			return {
+				command,
+				root: values.root,
+				json: values.json ?? false
+			};
+		}
+		case "set": {
+			const { values, positionals } = parseArgs({
+				args,
+				options: {
+					...common,
+					"base-url": { type: "string" },
+					api: { type: "string" },
+					model: {
+						type: "string",
+						multiple: true
+					},
+					"clear-models": { type: "boolean" },
+					"api-key-stdin": { type: "boolean" },
+					"clear-api-key": { type: "boolean" }
+				},
+				allowPositionals: true,
+				strict: true
+			});
+			requirePositionals(positionals, 1, "providers set <id>");
+			if (values.model && values["clear-models"]) throw new ProviderCliError("invalid_arguments", "--model and --clear-models cannot be used together");
+			if (values["api-key-stdin"] && values["clear-api-key"]) throw new ProviderCliError("invalid_arguments", "--api-key-stdin and --clear-api-key cannot be used together");
+			return {
+				command,
+				root: values.root,
+				providerId: positionals[0],
+				baseUrl: values["base-url"],
+				api: values.api,
+				models: values["clear-models"] ? [] : values.model,
+				apiKeyStdin: values["api-key-stdin"] ?? false,
+				clearApiKey: values["clear-api-key"] ?? false
+			};
+		}
+		case "discover": {
+			const { values, positionals } = parseArgs({
+				args,
+				options: {
+					...common,
+					save: { type: "boolean" },
+					json: { type: "boolean" }
+				},
+				allowPositionals: true,
+				strict: true
+			});
+			requirePositionals(positionals, 1, "providers discover <id>");
+			return {
+				command,
+				root: values.root,
+				providerId: positionals[0],
+				save: values.save ?? false,
+				json: values.json ?? false
+			};
+		}
+		case "remove":
+		case "logout": {
+			const { values, positionals } = parseArgs({
+				args,
+				options: {
+					...common,
+					yes: { type: "boolean" }
+				},
+				allowPositionals: true,
+				strict: true
+			});
+			requirePositionals(positionals, 1, `providers ${command} <id>`);
+			return {
+				command,
+				root: values.root,
+				providerId: positionals[0],
+				yes: values.yes ?? false
+			};
+		}
+		case "login": {
+			const { values, positionals } = parseArgs({
+				args,
+				options: {
+					...common,
+					"auth-method": { type: "string" }
+				},
+				allowPositionals: true,
+				strict: true
+			});
+			requirePositionals(positionals, 1, "providers login <id>");
+			return {
+				command,
+				root: values.root,
+				providerId: positionals[0],
+				authMethod: values["auth-method"]
+			};
+		}
+		default: throw new ProviderCliError("invalid_arguments", `Unknown providers command "${String(command)}"`);
+	}
+}
+async function createContext(rootFlag, dependencies, installInterruptHandler) {
+	const store = new AgentServerStore(resolveAgentServerRoot({ root: rootFlag ?? dependencies.envRoot ?? loadAgentServerEnvConfig().root })).ensure();
+	const secrets = new FileSecretProvider({
+		root: store.secretsDir,
+		writable: true
+	});
+	const secretProviders = createNodeSecretProviderRegistry().register(secrets);
+	const stderr = dependencies.stderr ?? console.error;
+	const logger = createCliLogger(stderr);
+	const configuration = dependencies.configuration ?? new ProviderConfigurationService({
+		store,
+		secrets,
+		secretProviders,
+		logger
+	});
+	const oauth = dependencies.oauth ?? await OAuthProviderService.create({
+		authPath: store.piAuthJsonPath,
+		logger
+	});
+	const controller = new AbortController();
+	const onInterrupt = () => controller.abort(/* @__PURE__ */ new Error("Interrupted"));
+	if (installInterruptHandler) process.once("SIGINT", onInterrupt);
+	const signal = dependencies.signal ? AbortSignal.any([dependencies.signal, controller.signal]) : controller.signal;
+	const question = dependencies.question ?? defaultQuestion;
+	const stdinIsTTY = dependencies.stdinIsTTY ?? dependencies.interactive ?? Boolean(process.stdin.isTTY);
+	const stdoutIsTTY = dependencies.stdoutIsTTY ?? dependencies.interactive ?? Boolean(process.stdout.isTTY);
 	return {
-		...callbacks.signal ? { signal: callbacks.signal } : {},
+		configuration,
+		oauth,
+		stdout: dependencies.stdout ?? console.log,
+		stderr,
+		readStdin: () => raceWithSignal(dependencies.readStdin?.() ?? defaultReadStdin(signal), signal),
+		question: (prompt) => question(prompt, signal),
+		openUrl: async (url) => {
+			if (dependencies.openUrl) await dependencies.openUrl(url);
+			else await defaultOpenUrl(url);
+		},
+		interactive: dependencies.interactive ?? (stdinIsTTY && stdoutIsTTY),
+		stdinIsTTY,
+		signal,
+		close: () => {
+			if (installInterruptHandler) process.removeListener("SIGINT", onInterrupt);
+		}
+	};
+}
+function listProviders(context, json) {
+	const configuredProviders = context.configuration.list();
+	const oauthProviders = context.oauth.list();
+	if (json) {
+		context.stdout(JSON.stringify({
+			configuredProviders,
+			oauthProviders
+		}));
+		return 0;
+	}
+	const configured = Object.entries(configuredProviders);
+	context.stdout("Configured providers:");
+	if (configured.length === 0) context.stdout("  (none)");
+	for (const [id, provider] of configured) context.stdout(`  ${id}  ${provider.baseUrl}  ${provider.models.length} model(s)${provider.hasApiKey ? "  API key configured" : ""}`);
+	context.stdout("OAuth providers:");
+	if (oauthProviders.length === 0) context.stdout("  (none)");
+	for (const provider of oauthProviders) context.stdout(`  ${provider.id}  ${provider.name}  ${provider.connected ? "connected" : "not connected"}`);
+	return 0;
+}
+async function setProvider(context, parsed) {
+	let apiKey;
+	if (parsed.apiKeyStdin) {
+		if (context.stdinIsTTY) throw new ProviderCliError("invalid_input", "--api-key-stdin requires redirected stdin; pipe the API key into this command");
+		apiKey = (await context.readStdin()).replace(/[\r\n]+$/u, "");
+		if (!apiKey) throw new ProviderCliError("invalid_input", "No API key was received on stdin");
+	}
+	const provider = await context.configuration.set(parsed.providerId, {
+		...parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {},
+		...parsed.api ? { api: parsed.api } : {},
+		...parsed.models ? { models: parsed.models } : {},
+		...apiKey ? { apiKey } : {},
+		...parsed.clearApiKey ? { clearApiKey: true } : {}
+	}, { signal: context.signal });
+	context.stdout(JSON.stringify({
+		id: parsed.providerId,
+		...provider
+	}));
+	return 0;
+}
+async function discoverProvider(context, parsed) {
+	const result = await context.configuration.discover(parsed.providerId, {
+		save: parsed.save,
+		signal: context.signal
+	});
+	if (parsed.json) context.stdout(JSON.stringify(result));
+	else for (const model of result.models) context.stdout(model);
+	return 0;
+}
+async function removeProvider(context, parsed) {
+	if (!await confirmDestructive(context, parsed.yes, `Remove configured provider "${parsed.providerId}"? [y/N] `)) {
+		context.stderr("Provider removal cancelled.");
+		return 1;
+	}
+	await context.configuration.remove(parsed.providerId, { signal: context.signal });
+	context.stdout(`Removed configured provider "${parsed.providerId}".`);
+	return 0;
+}
+async function loginProvider(context, parsed) {
+	if (!context.interactive) throw new ProviderCliError("non_interactive", "Provider login requires an interactive terminal");
+	await context.oauth.login(parsed.providerId, {
+		signal: context.signal,
 		notify: (event) => {
 			switch (event.type) {
 				case "auth_url":
-					callbacks.onAuth({
-						url: event.url,
-						...event.instructions ? { instructions: event.instructions } : {}
+					context.stderr(event.instructions ?? "Authorize in your browser:");
+					context.stderr(event.url);
+					context.openUrl(event.url).catch(() => {
+						context.stderr("Could not open the browser automatically; open the authorization URL above manually.");
 					});
 					break;
 				case "device_code":
-					callbacks.onDeviceCode({
-						userCode: event.userCode,
-						verificationUri: event.verificationUri
-					});
-					break;
-				case "info":
-				case "progress":
-					callbacks.onProgress?.(event.message);
+					context.stderr(`Open ${event.verificationUri}`);
+					context.stderr(`Enter code: ${event.userCode}`);
 					break;
-			}
-		},
-		prompt: async (prompt) => {
-			if (prompt.type !== "select") return callbacks.onPrompt({ message: prompt.message });
-			const selected = await callbacks.onSelect({
-				message: prompt.message,
-				options: prompt.options.map(({ id, label }) => ({
-					id,
-					label
-				}))
-			});
-			if (!selected) throw new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow did not offer a supported sign-in method");
-			return selected;
+				case "info":
+				case "progress":
+					context.stderr(event.message);
+					break;
+			}
+		},
+		prompt: async (prompt) => {
+			if (prompt.type === "select") {
+				if (parsed.authMethod) {
+					if (!prompt.options.some((option) => option.id === parsed.authMethod)) throw new ProviderCliError("unsupported_auth_method", `OAuth auth method "${parsed.authMethod}" is not available`);
+					return parsed.authMethod;
+				}
+				context.stderr(prompt.message);
+				for (const option of prompt.options) context.stderr(`  ${option.id}: ${option.label}`);
+			}
+			return context.question(`${prompt.message} `);
 		}
-	};
+	}, { signal: context.signal });
+	context.stdout(`Connected OAuth provider "${parsed.providerId}".`);
+	return 0;
 }
-function restoreStoredCredential(authPath, providerId, credential) {
-	mkdirSync(dirname(authPath), {
-		recursive: true,
-		mode: 448
-	});
-	try {
-		writeFileSync(authPath, "{}\n", {
-			flag: "wx",
-			mode: 384
-		});
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
+async function logoutProvider(context, parsed) {
+	if (!await confirmDestructive(context, parsed.yes, `Log out OAuth provider "${parsed.providerId}"? [y/N] `)) {
+		context.stderr("Provider logout cancelled.");
+		return 1;
 	}
-	const release = lockSync(authPath, { realpath: false });
-	const temp = `${authPath}.${randomBytes(6).toString("hex")}.tmp`;
+	await context.oauth.logout(parsed.providerId, context.signal);
+	context.stdout(`Logged out OAuth provider "${parsed.providerId}".`);
+	return 0;
+}
+async function confirmDestructive(context, yes, message) {
+	if (yes) return true;
+	if (!context.interactive) throw new ProviderCliError("non_interactive", "--yes is required outside an interactive terminal");
+	return /^y(es)?$/iu.test((await context.question(message)).trim());
+}
+function requirePositionals(positionals, expected, usage) {
+	if (positionals.length !== expected) throw new ProviderCliError("invalid_arguments", `Usage: ${usage}`);
+}
+function publicCliError(error, signal) {
+	if (signal?.aborted) return "Provider operation interrupted.";
+	if (error instanceof ProviderCliError || error instanceof ProviderConfigurationError || error instanceof OAuthProviderError || error instanceof ProviderLockError) return error.message;
+	return "Provider operation failed.";
+}
+async function defaultReadStdin(signal) {
+	let value = "";
+	process.stdin.setEncoding("utf8");
+	for await (const chunk of process.stdin) {
+		if (signal.aborted) throw new Error("Interrupted");
+		value += chunk;
+	}
+	return value;
+}
+function raceWithSignal(work, signal) {
+	if (signal.aborted) return Promise.reject(/* @__PURE__ */ new Error("Interrupted"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(/* @__PURE__ */ new Error("Interrupted"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		work.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+	});
+}
+async function defaultQuestion(prompt, signal) {
+	const readline = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
 	try {
-		const parsed = JSON.parse(readFileSync(authPath, "utf8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Pi credential store is not an object: ${authPath}`);
-		const credentials = parsed;
-		if (credential) credentials[providerId] = credential;
-		else delete credentials[providerId];
-		writeFileSync(temp, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 384 });
-		renameSync(temp, authPath);
+		return await readline.question(prompt, { signal });
 	} finally {
-		rmSync(temp, { force: true });
-		release();
+		readline.close();
 	}
 }
-function createLoginCallbacks(login, logger) {
+function browserLaunchCommand(platform, url) {
+	if (platform === "darwin") return {
+		executable: "open",
+		args: [url]
+	};
+	if (platform === "win32") return {
+		executable: "explorer.exe",
+		args: [url]
+	};
 	return {
-		onAuth: (info) => {
-			login.authUrl = info.url;
-			if (info.instructions) login.instructions = info.instructions;
-			logger.info({
-				event: "agent-server.subscription_login_transition",
-				operationId: login.operationId,
-				providerId: login.providerId,
-				transition: "authorization_ready"
-			}, "Subscription authorization URL ready");
-			login.infoArrived();
-		},
-		onDeviceCode: (info) => {
-			login.userCode = info.userCode;
-			login.verificationUri = info.verificationUri;
-			logger.info({
-				event: "agent-server.subscription_login_transition",
-				operationId: login.operationId,
-				providerId: login.providerId,
-				transition: "device_code_ready"
-			}, "Subscription device code ready");
-			login.infoArrived();
-		},
-		onPrompt: () => Promise.reject(new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow needs an interactive prompt; run `pi /login` in a terminal instead")),
-		onSelect: (prompt) => Promise.resolve((prompt.options.find((option) => /device/i.test(option.id)) ?? prompt.options[0])?.id),
-		signal: login.abort.signal
+		executable: "xdg-open",
+		args: [url]
 	};
 }
-function publicLoginError(error) {
-	if (error instanceof AgentServerSubscriptionError) return error.message;
-	return "Subscription sign-in failed. Start again to retry.";
+function defaultOpenUrl(url, spawnProcess = spawn) {
+	const { executable, args } = browserLaunchCommand(process.platform, url);
+	return new Promise((resolve, reject) => {
+		const child = spawnProcess(executable, args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
 }
-function safeLoginError(error) {
-	const result = { errorType: error instanceof Error ? error.name : typeof error };
-	const code = error?.code;
-	if (typeof code === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(code)) result["applicationCode"] = code;
-	return result;
+function createCliLogger(stderr) {
+	const write = (level, context, message) => {
+		const safeContext = Object.fromEntries(Object.entries(context).filter(([key, value]) => !/(?:credential|message|secret|token|url)/iu.test(key) && [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof value)));
+		stderr(JSON.stringify({
+			level,
+			message,
+			...safeContext
+		}));
+	};
+	return {
+		info: (context, message) => write("info", context, message),
+		warn: (context, message) => write("warn", context, message)
+	};
+}
+//#endregion
+//#region ../../libs/loopback-companion/src/errors.ts
+var LoopbackViolationError = class extends Error {
+	name = "LoopbackViolationError";
+	constructor(kind, message, options) {
+		super(message, options);
+		this.kind = kind;
+	}
+};
+function isLoopbackViolation(error) {
+	return error instanceof LoopbackViolationError;
+}
+//#endregion
+//#region ../../libs/loopback-companion/src/origin.ts
+/** Hostnames accepted as loopback for companion servers and origins. */
+function isLoopbackHostname(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+/**
+* Normalize and validate a browser origin. Accepts exact `https:` origins,
+* or `http:` origins whose host is loopback. Rejects values that carry a
+* path, trailing slash, credentials, or any other non-origin decoration
+* (`url.origin !== value` catches all of those).
+*/
+function normalizeOrigin(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch (cause) {
+		throw new LoopbackViolationError("origin_invalid", "Origin is not valid", { cause });
+	}
+	if (url.origin !== value || url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHostname(url.hostname))) throw new LoopbackViolationError("origin_invalid", "Origin is not valid");
+	return url.origin;
+}
+/** Parse a comma-separated origin list (config format shared by companions). */
+function parseAllowedOrigins(csv) {
+	return csv.split(",").map((origin) => origin.trim()).filter(Boolean);
+}
+/**
+* Exact-origin allowlist. Every configured origin is normalized eagerly so a
+* misconfigured allowlist fails at startup, not at request time.
+*/
+var OriginAllowlist = class {
+	origins;
+	constructor(allowedOrigins) {
+		if (allowedOrigins.length === 0) throw new Error("OriginAllowlist requires at least one origin");
+		this.origins = new Set(allowedOrigins.map((origin) => normalizeOrigin(origin)));
+	}
+	has(origin) {
+		try {
+			return this.origins.has(normalizeOrigin(origin));
+		} catch {
+			return false;
+		}
+	}
+	/** Return the normalized origin or throw `origin_not_allowed`. */
+	assert(value) {
+		let origin;
+		try {
+			origin = normalizeOrigin(value);
+		} catch {
+			throw new LoopbackViolationError("origin_not_allowed", "Origin is not allowed");
+		}
+		if (!this.origins.has(origin)) throw new LoopbackViolationError("origin_not_allowed", "Origin is not allowed");
+		return origin;
+	}
+};
+/** Extract and require the `Origin` header value. */
+function requireOriginHeader(headers) {
+	const origin = headers.origin;
+	if (typeof origin !== "string" || origin.length === 0) throw new LoopbackViolationError("origin_required", "Origin is required");
+	return origin;
+}
+//#endregion
+//#region ../../libs/loopback-companion/src/fastify.ts
+var CORS_PREFLIGHT_MAX_AGE_SECONDS = 600;
+var PRIVATE_NETWORK_REQUEST_HEADER = "access-control-request-private-network";
+var PRIVATE_NETWORK_ALLOW_HEADER = "access-control-allow-private-network";
+/**
+* Enforce that the `Host` header identifies loopback. Blocks DNS-rebinding
+* setups where a public hostname resolves to 127.0.0.1: the browser then
+* sends that hostname as `Host`, and the request is refused here even
+* though the socket is loopback.
+*/
+function requireLoopbackHost(request) {
+	const host = request.headers.host;
+	if (!host) throw new LoopbackViolationError("host_required", "Host header is required");
+	let hostname;
+	try {
+		hostname = new URL(`http://${host}`).hostname;
+	} catch {
+		throw new LoopbackViolationError("host_not_loopback", "Host header must identify loopback");
+	}
+	if (!isLoopbackHostname(hostname === "::1" ? "[::1]" : hostname)) throw new LoopbackViolationError("host_not_loopback", "Host header must identify loopback");
+}
+/**
+* Register the loopback-companion security profile on a Fastify app:
+*
+* - loopback `Host` enforcement on every request;
+* - `cache-control: no-store` on every response;
+* - strict UTF-8 JSON body parsing (invalid bodies raise a typed violation);
+* - exact-origin CORS (opaque/`null` origins get no CORS response but are
+*   not rejected here — route-level controls stay mandatory);
+* - hardened helmet defaults.
+*
+*/
+function registerLoopbackSecurity(app, options) {
+	if (!options.allowedOrigins && !options.isOriginAllowed) throw new Error("registerLoopbackSecurity requires allowedOrigins or isOriginAllowed");
+	const primaryAllowlist = options.allowedOrigins ? new OriginAllowlist(options.allowedOrigins) : null;
+	const selfAllowlist = options.selfOrigins && options.selfOrigins.length > 0 ? new OriginAllowlist(options.selfOrigins) : null;
+	const isOriginAllowed = (origin) => selfAllowlist?.has(origin) === true || primaryAllowlist?.has(origin) === true || options.isOriginAllowed?.(origin) === true;
+	app.addHook("onRequest", (request, _reply, done) => {
+		requireLoopbackHost(request);
+		done();
+	});
+	app.addHook("onSend", async (request, reply, payload) => {
+		reply.header("cache-control", "no-store");
+		if (request.method === "OPTIONS" && request.headers[PRIVATE_NETWORK_REQUEST_HEADER] === "true" && reply.getHeader("access-control-allow-origin") === request.headers.origin) reply.header(PRIVATE_NETWORK_ALLOW_HEADER, "true");
+		return payload;
+	});
+	app.removeContentTypeParser("application/json");
+	app.addContentTypeParser("application/json", { parseAs: "buffer" }, (_request, body, done) => {
+		try {
+			const json = new TextDecoder("utf-8", { fatal: true }).decode(typeof body === "string" ? Buffer.from(body) : body);
+			done(null, JSON.parse(json));
+		} catch (cause) {
+			done(new LoopbackViolationError("body_not_utf8_json", "Request body must be valid UTF-8 JSON", { cause }), void 0);
+		}
+	});
+	app.register(cors, {
+		allowedHeaders: ["content-type", ...options.allowedHeaders ?? []],
+		maxAge: CORS_PREFLIGHT_MAX_AGE_SECONDS,
+		methods: [...options.methods ?? [
+			"GET",
+			"POST",
+			"OPTIONS"
+		]],
+		origin: (origin, callback) => {
+			if (!origin || origin === "null") {
+				callback(null, false);
+				return;
+			}
+			if (isOriginAllowed(origin)) {
+				callback(null, true);
+				return;
+			}
+			callback(new LoopbackViolationError("origin_not_allowed", "Origin is not allowed"), false);
+		}
+	});
+	app.register(helmet, {
+		contentSecurityPolicy: {
+			useDefaults: false,
+			directives: options.contentSecurityPolicyDirectives ?? {
+				baseUri: ["'none'"],
+				defaultSrc: ["'none'"],
+				formAction: ["'self'"],
+				frameAncestors: ["'none'"],
+				styleSrc: ["'unsafe-inline'"]
+			}
+		},
+		crossOriginEmbedderPolicy: false,
+		crossOriginOpenerPolicy: false,
+		crossOriginResourcePolicy: { policy: "same-origin" },
+		hsts: false,
+		referrerPolicy: { policy: "no-referrer" }
+	});
 }
-function snapshot(login) {
-	const { providerId, status, authUrl, instructions, userCode, verificationUri, error, waitingForAuthorization } = login;
-	return {
-		providerId,
-		status,
-		...authUrl ? { authUrl } : {},
-		...instructions ? { instructions } : {},
-		...userCode ? { userCode } : {},
-		...verificationUri ? { verificationUri } : {},
-		...error ? { error } : {},
-		...waitingForAuthorization ? { waitingForAuthorization } : {}
-	};
+//#endregion
+//#region ../../libs/loopback-companion/src/fetch-metadata.ts
+function headerValue(headers, name) {
+	const value = headers[name];
+	return typeof value === "string" ? value : void 0;
 }
-var NAME_RE = IDENTITY_ALIAS_PATTERN;
-var PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
-function assertStoreName(kind, value) {
-	try {
-		return assertIdentityAlias(value);
-	} catch {
-		throw new AgentServerStoreError("invalid_name", `${kind} must match ${NAME_RE.source}`);
-	}
+/**
+* Require that a request is a top-level browser navigation (used by local
+* approval pages that must be opened as a document, never fetched).
+*/
+function assertNavigationRequest(headers) {
+	const site = headerValue(headers, "sec-fetch-site");
+	const mode = headerValue(headers, "sec-fetch-mode");
+	const destination = headerValue(headers, "sec-fetch-dest");
+	if (site !== "cross-site" && site !== "same-origin" && site !== "none" || mode !== "navigate" || destination !== "document") throw new LoopbackViolationError("navigation_required", "Request must be opened as a browser navigation");
 }
-function assertProviderId(value) {
-	if (!PROVIDER_ID_RE.test(value)) throw new AgentServerStoreError("invalid_name", `provider id must match ${PROVIDER_ID_RE.source}`);
-	return value;
+/**
+* Reject an explicit cross-site Fetch-Metadata signal. Only the explicit
+* `cross-site` value is rejected: Safari may omit Fetch Metadata on
+* same-origin form submissions, so the absence of the header is not treated
+* as a violation — callers keep their one-time token as the primary control.
+*/
+function rejectExplicitCrossSite(headers) {
+	if (headerValue(headers, "sec-fetch-site") === "cross-site") throw new LoopbackViolationError("cross_site_rejected", "Request must not originate cross-site");
 }
-var AgentServerStoreError = class extends Error {
-	name = "AgentServerStoreError";
+//#endregion
+//#region src/lib/agent-server/lock.ts
+var AgentServerLockError = class extends Error {
+	name = "AgentServerLockError";
 	constructor(code, message, options) {
 		super(message, options);
 		this.code = code;
 	}
 };
 /**
-* `MOLTNET_AGENT_SERVER_ROOT` override, else `~/.config/moltnet`.
-*
-* Deliberately does NOT consult `XDG_CONFIG_HOME`. The Go CLI's GetConfigDir
-* and @moltnet/agent-config's getConfigDir both resolve `~/.config/moltnet`,
-* so honouring XDG here gave one application two config roots: on a machine
-* with the variable set, the daemon wrote identities the CLI and SDK could not
-* read. `MOLTNET_AGENT_SERVER_ROOT` remains the explicit escape hatch for a
-* genuinely custom location.
+* Acquire the per-root singleton lock. `proper-lockfile` uses an atomic lock
+* directory at exactly `<root>/agent-server.lock`, recovers stale owners, and keeps
+* the mtime fresh while the supervisor is alive.
 */
-function resolveAgentServerRoot(input) {
-	const override = input.root?.trim();
-	if (override) return override;
-	return getConfigDir();
-}
-function providerEnvName(providerId) {
-	return `MOLTNET_PROVIDER_${assertProviderId(providerId).replaceAll("-", "_").toUpperCase()}_API_KEY`;
-}
-function assertProviderEnvName(providerId, value) {
-	const expected = providerEnvName(providerId);
-	if (value !== expected) throw new AgentServerStoreError("invalid_state", `provider envName must be ${expected}`);
-	return value;
-}
-function readJson(path) {
-	let raw;
-	try {
-		raw = readFileSync(path, "utf8");
-	} catch (cause) {
-		if (cause.code === "ENOENT") return null;
-		throw new AgentServerStoreError("io_error", `could not read state at ${path}`, { cause });
-	}
+async function acquireAgentServerLock(root, options = {}) {
+	const path = join(root, "agent-server.lock");
+	let releaseLock;
 	try {
-		return JSON.parse(raw);
+		releaseLock = await lock(root, {
+			lockfilePath: path,
+			realpath: false,
+			retries: 0,
+			...options.staleMs === void 0 ? {} : { stale: options.staleMs },
+			...options.updateMs === void 0 ? {} : { update: options.updateMs },
+			onCompromised: (cause) => {
+				const error = new AgentServerLockError("compromised", `Agent Server lock ${path} was compromised: ${cause.message}`, { cause });
+				if (options.onCompromised) {
+					options.onCompromised(error);
+					return;
+				}
+				throw error;
+			}
+		});
 	} catch (cause) {
-		throw new AgentServerStoreError("invalid_state", `corrupt JSON at ${path}`, { cause });
+		if (cause.code === "ELOCKED") throw new AgentServerLockError("held", `another moltnet-agent server process already owns ${path}`, { cause });
+		throw new AgentServerLockError("failed", `could not acquire Agent Server lock ${path}: ${cause.message}`, { cause });
 	}
+	let released = false;
+	return {
+		path,
+		async release() {
+			if (released) return;
+			released = true;
+			await releaseLock();
+		}
+	};
 }
-function writeJsonAtomic(path, value) {
-	const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+/** Always release after normal completion or startup/runtime failure. */
+async function withAgentServerLock(root, work, options) {
+	const held = await acquireAgentServerLock(root, options);
 	try {
-		writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
-		renameSync(temp, path);
-	} catch (cause) {
-		try {
-			rmSync(temp, { force: true });
-		} catch {}
-		throw cause;
+		return await work();
+	} finally {
+		await held.release();
 	}
 }
-var AgentServerStore = class {
-	root;
-	identitiesDir;
-	runsDir;
-	secretsDir;
-	/** Shared Pi credential dir; `auth.json` inside is pi-managed (lockfiled). */
-	piDir;
-	constructor(root) {
-		this.root = root;
-		this.identitiesDir = join(root, "identities");
-		this.runsDir = join(root, "runs");
-		this.secretsDir = join(root, "secrets");
-		this.piDir = join(root, "pi");
-	}
-	get piAuthJsonPath() {
-		return join(this.piDir, "auth.json");
-	}
-	/** Create the directory layout (0700) if missing. Idempotent. */
-	ensure() {
-		for (const dir of [
-			this.root,
-			this.identitiesDir,
-			this.runsDir,
-			this.secretsDir
-		]) mkdirSync(dir, {
-			recursive: true,
-			mode: 448
-		});
-		return this;
-	}
-	get statePath() {
-		return join(this.root, "agent-server.json");
-	}
-	readAgentServerState() {
-		const state = readJson(this.statePath);
-		if (!state) return {
-			version: 2,
-			pendingRegistrations: {},
-			activations: {}
-		};
-		if (!isRecord$1(state) || state.version !== 2) throw new AgentServerStoreError("invalid_state", `agent-server.json version ${String(isRecord$1(state) ? state.version : void 0)} is not supported; move agent-server.json aside, run \`moltnet config migrate\`, then add or attach the agents again`);
-		if ("pairedOrigins" in state) throw new AgentServerStoreError("invalid_state", "agent-server.json uses the obsolete pairing format; move agent-server.json aside and configure the agent server again");
-		if (!isRecord$1(state.pendingRegistrations) || !isRecord$1(state.activations)) throw new AgentServerStoreError("invalid_state", "agent-server.json is missing the version 2 activation map; move agent-server.json aside, run `moltnet config migrate`, then add or attach the agents again");
-		for (const [alias, activation] of Object.entries(state.activations)) validateActivation(alias, activation);
-		for (const [alias, registration] of Object.entries(state.pendingRegistrations)) {
-			assertStoreName("agent name", alias);
-			if (!isRecord$1(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new AgentServerStoreError("invalid_state", `pending registration "${alias}" is not valid`);
-		}
-		return {
-			version: 2,
-			pendingRegistrations: state.pendingRegistrations,
-			activations: state.activations
-		};
-	}
-	writeAgentServerState(state) {
-		writeJsonAtomic(this.statePath, state);
-	}
-	agentPath(name) {
-		return join(storeChildPath(this.identitiesDir, "identity alias", name), "moltnet.json");
-	}
-	/** Central identity directory, shared with the Go CLI layout. */
-	identityDir(name) {
-		return storeChildPath(this.identitiesDir, "identity alias", name);
-	}
-	get identitySelectorPath() {
-		return join(this.root, "identity-selector.json");
-	}
-	readIdentitySelector() {
-		const selector = readJson(this.identitySelectorPath);
-		if (!selector) return null;
-		if (!isRecord$1(selector) || selector.version !== 1 || selector.default_identity !== void 0 && typeof selector.default_identity !== "string") throw new AgentServerStoreError("invalid_state", "identity-selector.json is not a supported selector document");
-		if (selector.default_identity) assertStoreName("identity alias", selector.default_identity);
-		return selector;
-	}
-	writeIdentitySelector(alias) {
-		writeJsonAtomic(this.identitySelectorPath, {
-			version: 1,
-			default_identity: assertStoreName("identity alias", alias)
-		});
-	}
-	resolveIdentityAlias(explicit, active) {
-		const alias = explicit?.trim() || active?.trim() || this.readIdentitySelector()?.default_identity;
-		if (!alias) throw new AgentServerStoreError("not_found", "no active identity selected");
-		return assertStoreName("identity alias", alias);
-	}
-	readAgentConfig(alias) {
-		return readJson(this.agentPath(alias));
+//#endregion
+//#region src/lib/agent-server/pairing.ts
+/**
+* One-click pairing ceremony for the agent server, mirroring the signer's
+* session/ceremony pattern (#2062 design):
+*
+*   1. Console (allowed origin) POSTs `/v1/pairings` → pending pairing bound
+*      to that origin, with a one-time confirmation token.
+*   2. Console opens `http://127.0.0.1:<port>/pairings/<id>` in a new tab —
+*      a navigation-gated local approval page naming the origin.
+*   3. One click POSTs the confirmation form (explicit cross-site rejected;
+*      the one-time token is the primary CSRF control).
+*   4. Console claims `/v1/pairings/<id>/claim` from the same origin and
+*      receives the bearer token exactly once; only its SHA-256 remains in
+*      this supervisor process.
+*
+* The token exists for shared-machine cross-user protection and to bind
+* "this console session is the operator" — browser-vs-browser isolation is
+* already covered by the loopback-companion origin checks. Grants are
+* deliberately process-scoped: after the listening socket changes owners, a
+* token disclosed to an impostor on that port cannot authenticate to a later
+* supervisor process.
+*/
+var PENDING_TTL_MS = 600 * 1e3;
+var AgentServerPairingError = class extends Error {
+	name = "AgentServerPairingError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
 	}
-	writeAgentConfig(alias, config) {
-		mkdirSync(this.identityDir(alias), {
-			recursive: true,
-			mode: 448
-		});
-		writeJsonAtomic(this.agentPath(alias), config);
-		if (!this.readIdentitySelector()?.default_identity) this.writeIdentitySelector(alias);
+};
+function sha256Hex(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function safeEqual(a, b) {
+	const left = Buffer.from(a, "utf8");
+	const right = Buffer.from(b, "utf8");
+	return left.length === right.length && timingSafeEqual(left, right);
+}
+var PairingService = class {
+	pending = /* @__PURE__ */ new Map();
+	paired = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.options = options;
 	}
-	removeAgentConfig(alias) {
-		rmSync(this.agentPath(alias), { force: true });
-		this.clearIdentitySelectorIfDefault(alias);
+	now() {
+		return this.options.now?.() ?? Date.now();
 	}
-	/** Clears the persisted default when it names `alias`. */
-	clearIdentitySelectorIfDefault(alias) {
-		let selector = null;
-		try {
-			selector = this.readIdentitySelector();
-		} catch {
-			return;
-		}
-		if (!selector || selector.default_identity !== alias) return;
-		writeJsonAtomic(this.identitySelectorPath, { version: 1 });
+	token() {
+		return this.options.randomToken?.() ?? randomBytes(32).toString("base64url");
 	}
-	readActivation(alias) {
-		return this.readAgentServerState().activations[assertStoreName("agent name", alias)] ?? null;
+	sweep() {
+		const now = this.now();
+		for (const [id, pairing] of this.pending) if (pairing.expiresAt <= now) this.pending.delete(id);
 	}
-	hasPendingRegistration(alias) {
-		return Boolean(this.readAgentServerState().pendingRegistrations[assertStoreName("agent name", alias)]);
+	start(origin) {
+		this.sweep();
+		const pairingId = randomBytes(12).toString("hex");
+		this.pending.set(pairingId, {
+			origin,
+			confirmToken: this.token(),
+			expiresAt: this.now() + PENDING_TTL_MS,
+			approved: false,
+			bearerToken: null
+		});
+		return {
+			pairingId,
+			approvalPath: `/pairings/${pairingId}`
+		};
 	}
-	reserveRegistration(alias, apiUrl) {
-		const name = assertStoreName("agent name", alias);
-		const state = this.readAgentServerState();
-		if (state.activations[name] || state.pendingRegistrations[name]) throw new AgentServerStoreError("already_exists", `agent "${name}" already exists in the agent server store`);
-		state.pendingRegistrations[name] = {
-			apiUrl,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	/** Data for the local approval page. */
+	approval(pairingId) {
+		const pairing = this.require(pairingId);
+		if (pairing.approved) throw new AgentServerPairingError("pairing_invalid", "Pairing is already approved");
+		return {
+			origin: pairing.origin,
+			confirmToken: pairing.confirmToken
 		};
-		this.writeAgentServerState(state);
 	}
-	clearPendingRegistration(alias) {
-		const name = assertStoreName("agent name", alias);
-		const state = this.readAgentServerState();
-		delete state.pendingRegistrations[name];
-		this.writeAgentServerState(state);
+	confirm(pairingId, confirmToken) {
+		const pairing = this.require(pairingId);
+		if (pairing.approved || !safeEqual(pairing.confirmToken, confirmToken)) throw new AgentServerPairingError("pairing_invalid", "Confirmation token is not valid");
+		pairing.approved = true;
+		pairing.bearerToken = this.token();
+		return { origin: pairing.origin };
 	}
-	writeActivation(activation) {
-		const alias = assertStoreName("agent name", activation.alias);
-		validateActivation(alias, activation);
-		const state = this.readAgentServerState();
-		state.activations[alias] = activation;
-		if (activation.source === "managed") delete state.pendingRegistrations[alias];
-		this.writeAgentServerState(state);
+	claim(pairingId, origin) {
+		const pairing = this.require(pairingId);
+		if (pairing.origin !== origin) throw new AgentServerPairingError("pairing_origin_mismatch", "Pairing belongs to a different origin");
+		if (!pairing.approved || !pairing.bearerToken) throw new AgentServerPairingError("pairing_not_approved", "Pairing has not been approved yet");
+		const token = pairing.bearerToken;
+		this.pending.delete(pairingId);
+		this.paired.set(origin, sha256Hex(token));
+		return { token };
 	}
-	listActivations() {
-		return Object.values(this.readAgentServerState().activations).sort((a, b) => a.alias.localeCompare(b.alias));
+	verify(origin, token) {
+		const tokenHash = this.paired.get(origin);
+		if (!tokenHash || !safeEqual(tokenHash, sha256Hex(token))) throw new AgentServerPairingError("pairing_token_invalid", "Pairing token is not valid for this origin");
 	}
-	get providersPath() {
-		return join(this.root, "providers.json");
+	require(pairingId) {
+		this.sweep();
+		const pairing = this.pending.get(pairingId);
+		if (!pairing) throw new AgentServerPairingError("pairing_not_found", "Pairing was not found or has expired");
+		return pairing;
 	}
-	readProviders() {
-		const state = readJson(this.providersPath) ?? {};
-		this.validateProviders(state);
-		return state;
+};
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+/** Minimal, dependency-free local approval page. */
+function renderPairingApprovalPage(input) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>MoltNet Agent — approve connection</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { margin: 0; font: 16px/1.5 system-ui, sans-serif; display: grid; place-items: center; min-height: 100vh; background: Canvas; color: CanvasText; }
+  main { max-width: 26rem; padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 20%, transparent); border-radius: 12px; }
+  h1 { font-size: 1.2rem; margin: 0 0 0.5rem; }
+  code { font-size: 0.95em; word-break: break-all; }
+  button { margin-top: 1.25rem; font: inherit; padding: 0.6rem 1.4rem; border-radius: 8px; border: 1px solid color-mix(in srgb, CanvasText 30%, transparent); cursor: pointer; }
+  p.small { font-size: 0.85rem; opacity: 0.75; }
+</style>
+</head>
+<body>
+<script>
+  // The Console must remain this popup's opener until it finishes navigating
+  // from about:blank. Safari rejects that cross-origin navigation otherwise.
+  // Once this trusted local approval document has loaded, it needs no opener.
+  window.opener = null;
+<\/script>
+<main>
+<h1>Allow this site to manage local MoltNet agents?</h1>
+<p><code>${escapeHtml(input.origin)}</code> asks to configure agents and start or stop local daemon runs on this machine.</p>
+<p class="small">Approve only if you opened that page yourself. This grant lasts until the local supervisor stops.</p>
+<form method="post" action="/pairings/${escapeHtml(input.pairingId)}/confirm">
+<input type="hidden" name="confirmToken" value="${escapeHtml(input.confirmToken)}" />
+<button type="submit">Approve</button>
+</form>
+</main>
+</body>
+</html>
+`;
+}
+function renderPairingResultPage(input) {
+	return `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml(input.title)}</title>
+<style>:root{color-scheme:light dark}body{margin:0;font:16px/1.5 system-ui,sans-serif;display:grid;place-items:center;min-height:100vh;background:Canvas;color:CanvasText}main{max-width:26rem;padding:2rem}</style>
+</head>
+<body><main role="status"><h1>${escapeHtml(input.title)}</h1><p>${escapeHtml(input.message)}</p><p>You can close this tab.</p></main></body>
+</html>
+`;
+}
+//#endregion
+//#region src/lib/agent-server/provider-login.ts
+/**
+* Subscription-provider OAuth brokering for Agent Server (#2061 slice 4).
+*
+* The console clicks "Connect"; agent server runs the Pi OAuth flow host-side via
+* `ModelRuntime.login()` (which owns persistence into the shared
+* `pi/auth.json` and token rotation thereafter). The browser only ever sees
+* the provider's authorize URL or device code — never tokens.
+*
+* Provider ids come from Pi's model runtime, so Agent Server stays in lockstep
+* with supported subscription providers. GitHub Copilot is intentionally
+* excluded: MoltNet does not broker editor-seat subscription credentials.
+*/
+var LOGIN_TTL_MS = 600 * 1e3;
+/** How long `start()` waits for the flow to surface a URL / device code. */
+var START_INFO_TIMEOUT_MS = 5e3;
+var AgentServerSubscriptionError = class extends Error {
+	name = "AgentServerSubscriptionError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
 	}
-	writeProviders(state) {
-		this.validateProviders(state);
-		writeJsonAtomic(this.providersPath, state);
+};
+var silentLogger = {
+	info: () => void 0,
+	warn: () => void 0,
+	error: () => void 0
+};
+var ProviderLoginService = class ProviderLoginService {
+	logins = /* @__PURE__ */ new Map();
+	logger;
+	constructor(options) {
+		this.options = options;
+		this.logger = options.logger ?? silentLogger;
 	}
-	validateProviders(state) {
-		for (const [id, provider] of Object.entries(state)) {
-			assertProviderId(id);
-			assertProviderEnvName(id, provider.envName);
-		}
+	static async create(options) {
+		const oauthProviders = await OAuthProviderService.create({
+			authPath: options.authPath,
+			logger: options.logger
+		});
+		return new ProviderLoginService({
+			...options,
+			oauthProviders
+		});
 	}
-	runDir(id) {
-		return storeChildPath(this.runsDir, "run id", id);
+	now() {
+		return this.options.now?.() ?? Date.now();
 	}
-	resolveRunLogPath(id) {
-		let root;
-		let runDir;
-		try {
-			root = realpathSync(this.runsDir);
-			runDir = realpathSync(this.runDir(id));
-		} catch (cause) {
-			throw new AgentServerStoreError("io_error", "could not resolve run directory", { cause });
-		}
-		if (!isStrictDescendant(root, runDir)) throw new AgentServerStoreError("invalid_state", "run directory escapes its store");
-		const logPath = join(runDir, "daemon.log");
-		try {
-			if (lstatSync(logPath).isSymbolicLink()) throw new AgentServerStoreError("invalid_state", "run log must not be a symbolic link");
-			const resolvedLog = realpathSync(logPath);
-			if (!isStrictDescendant(runDir, resolvedLog)) throw new AgentServerStoreError("invalid_state", "run log escapes its store");
-		} catch (cause) {
-			if (cause instanceof AgentServerStoreError) throw cause;
-			if (cause.code !== "ENOENT") throw new AgentServerStoreError("io_error", "could not resolve run log", { cause });
-		}
-		return logPath;
+	providers() {
+		return (this.options.listProviders ? this.options.listProviders() : this.options.oauthProviders ? this.options.oauthProviders.list() : this.runtime().getProviders().filter(isOAuthProviderEligible).map((provider) => ({
+			id: provider.id,
+			name: provider.name
+		}))).filter((provider) => isOAuthProviderIdEligible(provider.id));
 	}
-	createRunDir(id) {
-		const dir = this.runDir(id);
-		const piDir = join(dir, "pi");
-		mkdirSync(piDir, {
-			recursive: true,
-			mode: 448
-		});
-		return {
-			dir,
-			piDir,
-			logPath: join(dir, "daemon.log")
-		};
+	connected(providerId) {
+		if (this.options.isConnected) return this.options.isConnected(providerId);
+		if (this.options.oauthProviders) return this.options.oauthProviders.list().find((provider) => provider.id === providerId)?.connected ?? false;
+		try {
+			return readStoredCredential(providerId, this.options.authPath) !== void 0;
+		} catch (error) {
+			this.logger.warn({
+				event: "agent-server.subscription_auth_read_failed",
+				providerId,
+				...safeLoginError(error)
+			}, "Could not read subscription authentication state");
+			return false;
+		}
 	}
-	readRun(id) {
-		return readJson(join(this.runDir(id), "run.json"));
+	runtime() {
+		if (!this.options.modelRuntime) throw new Error("ProviderLoginService requires a model runtime when production adapters are not overridden");
+		return this.options.modelRuntime;
 	}
-	writeRun(record) {
-		writeJsonAtomic(join(this.runDir(record.id), "run.json"), record);
+	list() {
+		this.sweep();
+		if (this.options.oauthProviders && !this.options.listProviders && !this.options.isConnected) return this.options.oauthProviders.list();
+		return this.providers().map((provider) => ({
+			...provider,
+			connected: this.connected(provider.id)
+		}));
 	}
-	listRuns(limit = Number.POSITIVE_INFINITY) {
-		let ids;
-		try {
-			ids = readdirSync(this.runsDir);
-		} catch {
-			return [];
+	sweep() {
+		const now = this.now();
+		for (const [id, login] of this.logins) if (login.startedAt + LOGIN_TTL_MS <= now) {
+			if (login.status === "pending") this.invalidate(login, "expired");
+			this.logins.delete(id);
 		}
-		const sortedIds = ids.filter((id) => NAME_RE.test(id)).sort().reverse();
-		const selectedIds = Number.isFinite(limit) ? sortedIds.slice(0, Math.max(0, limit)) : sortedIds;
-		const records = [];
-		for (const id of selectedIds) {
-			const record = this.readRun(id);
-			if (record) records.push(record);
+	}
+	restoreCredential(login) {
+		try {
+			restoreStoredCredential(this.options.authPath, login.providerId, login.previousCredential);
+			return true;
+		} catch (error) {
+			this.logger.error({
+				event: "agent-server.subscription_login_cleanup_failed",
+				operationId: login.operationId,
+				providerId: login.providerId,
+				...safeLoginError(error)
+			}, "Could not restore subscription credentials after an invalidated login");
+			return false;
 		}
-		return records.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 	}
-	/** Remove only completed run directories outside the configured budget. */
-	pruneCompletedRuns(options) {
-		const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
-		let retainedBytes = 0;
-		let retainedCount = 0;
-		const removed = [];
-		for (const record of this.listRuns()) {
-			if (record.status === "running") continue;
-			const dir = this.runDir(record.id);
-			const bytes = directoryBytes(dir);
-			const endedAt = Date.parse(record.endedAt ?? record.startedAt);
-			const expired = !Number.isFinite(endedAt) || now - endedAt > options.maxAgeMs;
-			const overCount = retainedCount >= options.maxCount;
-			const overBytes = retainedBytes + bytes > options.maxBytes;
-			if (expired || overCount || overBytes) {
-				rmSync(dir, {
-					recursive: true,
-					force: true
-				});
-				removed.push(record.id);
-				continue;
+	invalidate(login, transition) {
+		if (login.invalidated) return true;
+		login.invalidated = true;
+		login.abort.abort(/* @__PURE__ */ new Error(`subscription login ${transition}`));
+		const restored = this.restoreCredential(login);
+		login.cleanupSucceeded = restored;
+		login.infoArrived();
+		this.logger.info({
+			event: "agent-server.subscription_login_transition",
+			operationId: login.operationId,
+			providerId: login.providerId,
+			transition
+		}, "Subscription login invalidated");
+		return restored;
+	}
+	status(providerId) {
+		this.sweep();
+		const login = this.logins.get(providerId);
+		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
+		return snapshot(login);
+	}
+	/**
+	* Start (or return the in-flight) login for a provider. Resolves once the
+	* flow has surfaced an authorize URL / device code, completed, or the
+	* start window elapsed — whichever comes first.
+	*/
+	async start(providerId) {
+		this.sweep();
+		if (!this.providers().some((provider) => provider.id === providerId)) throw new AgentServerSubscriptionError("provider_unknown", `"${providerId}" is not a known subscription provider`);
+		const existing = this.logins.get(providerId);
+		if (existing && existing.status === "pending") return snapshot(existing);
+		let infoArrived = () => void 0;
+		const infoPromise = new Promise((resolvePromise) => {
+			infoArrived = () => resolvePromise();
+		});
+		const abort = new AbortController();
+		const login = {
+			providerId,
+			status: "pending",
+			operationId: randomUUID(),
+			startedAt: this.now(),
+			infoArrived,
+			abort,
+			invalidated: false,
+			cleanupUnderProviderLock: !this.options.runLogin && Boolean(this.options.oauthProviders),
+			cleanupSucceeded: true,
+			previousCredential: readStoredCredential(providerId, this.options.authPath)
+		};
+		this.logins.set(providerId, login);
+		this.logger.info({
+			event: "agent-server.subscription_login_transition",
+			operationId: login.operationId,
+			providerId,
+			transition: "started"
+		}, "Subscription login started");
+		const callbacks = createLoginCallbacks(login, this.logger);
+		(this.options.runLogin ?? ((id, loginCallbacks) => {
+			if (this.options.oauthProviders) return this.options.oauthProviders.login(id, toAuthInteraction(loginCallbacks), {
+				signal: login.abort.signal,
+				onSettledUnderLock: () => {
+					if (login.invalidated) login.cleanupSucceeded = this.restoreCredential(login);
+				}
+			});
+			return this.runtime().login(id, "oauth", toAuthInteraction(loginCallbacks)).then(() => void 0);
+		}))(providerId, callbacks).then(() => {
+			if (login.invalidated) {
+				if (!login.cleanupUnderProviderLock) this.restoreCredential(login);
+				return;
 			}
-			retainedCount += 1;
-			retainedBytes += bytes;
+			if (!this.options.runLogin && !this.connected(providerId)) {
+				login.status = "failed";
+				login.error = "Subscription sign-in completed, but credentials were not persisted. Start again to retry.";
+				this.logger.error({
+					event: "agent-server.subscription_login_transition",
+					operationId: login.operationId,
+					providerId,
+					transition: "persistence_failed"
+				}, "Subscription login credentials were not persisted");
+			} else {
+				login.status = "completed";
+				this.logger.info({
+					event: "agent-server.subscription_login_transition",
+					operationId: login.operationId,
+					providerId,
+					transition: "completed"
+				}, "Subscription login completed");
+			}
+			login.infoArrived();
+		}, (error) => {
+			if (login.invalidated) {
+				if (!login.cleanupUnderProviderLock) this.restoreCredential(login);
+				return;
+			}
+			login.status = "failed";
+			login.error = publicLoginError(error);
+			this.logger.warn({
+				event: "agent-server.subscription_login_transition",
+				operationId: login.operationId,
+				providerId,
+				transition: "failed",
+				...safeLoginError(error)
+			}, "Subscription login failed");
+			login.infoArrived();
+		});
+		if (!await Promise.race([infoPromise, new Promise((resolvePromise) => {
+			setTimeout(() => resolvePromise(), START_INFO_TIMEOUT_MS).unref?.();
+		})]).then(() => login.authUrl !== void 0 || login.userCode !== void 0 || login.status !== "pending")) {
+			login.waitingForAuthorization = true;
+			this.logger.warn({
+				event: "serve.subscription_login_start_info_timeout",
+				operationId: login.operationId,
+				providerId,
+				timeoutMs: START_INFO_TIMEOUT_MS
+			}, "Subscription login is still waiting for authorization information");
 		}
-		return removed;
+		return snapshot(login);
+	}
+	/** Abort an in-flight login and forget it. */
+	cancel(providerId) {
+		const login = this.logins.get(providerId);
+		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
+		if (!this.invalidate(login, "cancelled")) throw new AgentServerSubscriptionError("login_cleanup_failed", `could not safely cancel login for "${providerId}"; credential cleanup requires intervention`);
+		this.logins.delete(providerId);
+		return {
+			providerId,
+			status: "cancelled"
+		};
+	}
+	/** Abort every pending flow during supervisor shutdown. */
+	close() {
+		for (const login of this.logins.values()) if (login.status === "pending") this.invalidate(login, "shutdown");
+		this.logins.clear();
 	}
 };
-function directoryBytes(path) {
-	let info;
+function toAuthInteraction(callbacks) {
+	return {
+		...callbacks.signal ? { signal: callbacks.signal } : {},
+		notify: (event) => {
+			switch (event.type) {
+				case "auth_url":
+					callbacks.onAuth({
+						url: event.url,
+						...event.instructions ? { instructions: event.instructions } : {}
+					});
+					break;
+				case "device_code":
+					callbacks.onDeviceCode({
+						userCode: event.userCode,
+						verificationUri: event.verificationUri
+					});
+					break;
+				case "info":
+				case "progress":
+					callbacks.onProgress?.(event.message);
+					break;
+			}
+		},
+		prompt: async (prompt) => {
+			if (prompt.type !== "select") return callbacks.onPrompt({ message: prompt.message });
+			const selected = await callbacks.onSelect({
+				message: prompt.message,
+				options: prompt.options.map(({ id, label }) => ({
+					id,
+					label
+				}))
+			});
+			if (!selected) throw new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow did not offer a supported sign-in method");
+			return selected;
+		}
+	};
+}
+function restoreStoredCredential(authPath, providerId, credential) {
+	mkdirSync(dirname(authPath), {
+		recursive: true,
+		mode: 448
+	});
 	try {
-		info = lstatSync(path);
-	} catch {
-		return 0;
+		writeFileSync(authPath, "{}\n", {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+	const release = lockSync(authPath, { realpath: false });
+	const temp = `${authPath}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		const parsed = JSON.parse(readFileSync(authPath, "utf8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Pi credential store is not an object: ${authPath}`);
+		const credentials = parsed;
+		if (credential) credentials[providerId] = credential;
+		else delete credentials[providerId];
+		writeFileSync(temp, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 384 });
+		renameSync(temp, authPath);
+	} finally {
+		rmSync(temp, { force: true });
+		release();
 	}
-	if (info.isSymbolicLink()) return 0;
-	if (!info.isDirectory()) return info.size;
-	let total = 0;
-	for (const entry of readdirSync(path, { withFileTypes: true })) total += directoryBytes(join(path, entry.name));
-	return total;
 }
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+function createLoginCallbacks(login, logger) {
+	return {
+		onAuth: (info) => {
+			login.authUrl = info.url;
+			if (info.instructions) login.instructions = info.instructions;
+			logger.info({
+				event: "agent-server.subscription_login_transition",
+				operationId: login.operationId,
+				providerId: login.providerId,
+				transition: "authorization_ready"
+			}, "Subscription authorization URL ready");
+			login.infoArrived();
+		},
+		onDeviceCode: (info) => {
+			login.userCode = info.userCode;
+			login.verificationUri = info.verificationUri;
+			logger.info({
+				event: "agent-server.subscription_login_transition",
+				operationId: login.operationId,
+				providerId: login.providerId,
+				transition: "device_code_ready"
+			}, "Subscription device code ready");
+			login.infoArrived();
+		},
+		onPrompt: () => Promise.reject(new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow needs an interactive prompt; run `pi /login` in a terminal instead")),
+		onSelect: (prompt) => Promise.resolve((prompt.options.find((option) => /device/i.test(option.id)) ?? prompt.options[0])?.id),
+		signal: login.abort.signal
+	};
 }
-function storeChildPath(root, kind, value, suffix = "") {
-	const name = assertStoreName(kind, value);
-	const normalizedRoot = resolve(root);
-	const candidate = resolve(normalizedRoot, `${name}${suffix}`);
-	if (!isStrictDescendant(normalizedRoot, candidate)) throw new AgentServerStoreError("invalid_name", `${kind} escapes its store`);
-	return candidate;
+function publicLoginError(error) {
+	if (error instanceof AgentServerSubscriptionError) return error.message;
+	return "Subscription sign-in failed. Start again to retry.";
 }
-function isStrictDescendant(root, candidate) {
-	const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
-	return candidate !== root && candidate.startsWith(rootPrefix);
+function safeLoginError(error) {
+	const result = { errorType: error instanceof Error ? error.name : typeof error };
+	const code = error?.code;
+	if (typeof code === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(code)) result["applicationCode"] = code;
+	return result;
 }
-function validateActivation(alias, value) {
-	const invalid = () => {
-		throw new AgentServerStoreError("invalid_state", `activation "${alias}" is not a valid version 2 activation`);
+function snapshot(login) {
+	const { providerId, status, authUrl, instructions, userCode, verificationUri, error, waitingForAuthorization } = login;
+	return {
+		providerId,
+		status,
+		...authUrl ? { authUrl } : {},
+		...instructions ? { instructions } : {},
+		...userCode ? { userCode } : {},
+		...verificationUri ? { verificationUri } : {},
+		...error ? { error } : {},
+		...waitingForAuthorization ? { waitingForAuthorization } : {}
 	};
-	if (!isRecord$1(value)) invalid();
-	const activation = value;
-	if (activation.alias !== alias) invalid();
-	if (![
-		"subjectId",
-		"publicKey",
-		"fingerprint",
-		"createdAt"
-	].every((field) => typeof activation[field] === "string" && activation[field].length > 0)) invalid();
-	if (activation.source === "managed") {
-		if (typeof activation.apiUrl !== "string" || activation.apiUrl.length === 0 || activation.configPath !== void 0 || activation.configApiUrl !== void 0) invalid();
-		return;
-	}
-	if (activation.source !== "external" || typeof activation.configPath !== "string" || activation.configPath.length === 0 || typeof activation.configApiUrl !== "string" || activation.configApiUrl.length === 0 || activation.apiUrl !== void 0 && typeof activation.apiUrl !== "string") invalid();
 }
 //#endregion
 //#region src/lib/agent-server/identity.ts
@@ -8238,13 +9198,13 @@ var AgentServerIdentityError = class extends Error {
 		this.code = code;
 	}
 };
-function reserveAlias(store, alias) {
+function reserveAlias(store, alias, allowExistingConfig = false) {
 	let pending = pendingAliases.get(store);
 	if (!pending) {
 		pending = /* @__PURE__ */ new Set();
 		pendingAliases.set(store, pending);
 	}
-	if (pending.has(alias) || store.hasPendingRegistration(alias) || store.readActivation(alias) || store.readAgentConfig(alias)) throw new AgentServerIdentityError("agent_exists", `agent "${alias}" already exists in the agent server store`);
+	if (pending.has(alias) || store.hasPendingRegistration(alias) || store.readActivation(alias) || !allowExistingConfig && store.readAgentConfig(alias)) throw new AgentServerIdentityError("agent_exists", `agent "${alias}" already exists in the agent server store`);
 	pending.add(alias);
 	return () => pending.delete(alias);
 }
@@ -8386,12 +9346,14 @@ async function reconcileManagedRegistration(store, secrets, aliasInput, action,
 }
 async function attachExternalAgent(store, secretProviders, input, connectAgent = connect) {
 	const alias = assertStoreName("agent name", input.name);
-	const releaseAlias = reserveAlias(store, alias);
+	if (!isAbsolute(input.configDir)) throw new AgentServerIdentityError("config_not_found", "external configDir must be an absolute path");
+	const configPath = join(input.configDir, "moltnet.json");
+	const central = configPath === store.agentPath(alias);
+	const releaseAlias = reserveAlias(store, alias, central);
 	try {
-		if (!isAbsolute(input.configDir)) throw new AgentServerIdentityError("config_not_found", "external configDir must be an absolute path");
-		const configPath = join(input.configDir, "moltnet.json");
-		externalAgentLocation(configPath);
+		if (!central) externalAgentLocation(configPath);
 		const config = await readCurrentConfig(configPath);
+		if (central && !config.agent_key_ref) throw new AgentServerIdentityError("unsupported_credential", `central identity "${alias}" needs a stored agent key before the Agent Server can run it`);
 		const configApiUrl = requireTrustedConfigApiUrl(config, configPath);
 		const whoami = await authenticateConfig(config, configPath, requireTrustedApiOverride(input.apiUrl, configApiUrl, configPath), secretProviders, connectAgent, input.signal);
 		const identity = identityFromConfig(config);
@@ -8422,7 +9384,7 @@ async function attachExternalAgent(store, secretProviders, input, connectAgent =
 /** Load and authenticate the current config, then refresh its derived pin. */
 async function verifyAgentActivation(store, alias, managedSecretProviders, externalSecretProviders, connectAgent = connect, signal) {
 	const activation = requireActivation(store, alias);
-	const verified = activation.source === "managed" ? await verifyManagedActivation(store, activation, managedSecretProviders, connectAgent, signal) : await verifyExternalActivation(activation, externalSecretProviders, connectAgent, signal);
+	const verified = activation.source === "managed" ? await verifyManagedActivation(store, activation, managedSecretProviders, connectAgent, signal) : await verifyExternalActivation(store, activation, externalSecretProviders, connectAgent, signal);
 	assertSubjectMatches(verified.whoami, verified.config, "authenticated whoami", `agent "${activation.alias}" config`);
 	if (verified.whoami.subjectId !== activation.subjectId) throw new AgentServerIdentityError("verification_failed", `authenticated whoami subject does not match agent "${activation.alias}" pinned activation`);
 	const identity = identityFromConfig(verified.config);
@@ -8462,10 +9424,12 @@ async function verifyManagedActivation(store, activation, secretProviders, conne
 		}, configPath, signal)
 	};
 }
-async function verifyExternalActivation(activation, secretProviders, connectAgent, signal) {
-	externalAgentLocation(activation.configPath);
+async function verifyExternalActivation(store, activation, secretProviders, connectAgent, signal) {
+	const central = activation.configPath === store.agentPath(activation.alias);
+	if (!central) externalAgentLocation(activation.configPath);
 	assertTrustedConfigApiUrl(activation.configApiUrl);
 	const config = await readCurrentConfig(activation.configPath);
+	if (central && !config.agent_key_ref) throw new AgentServerIdentityError("unsupported_credential", `central identity "${activation.alias}" needs a stored agent key before the Agent Server can run it`);
 	assertActivatedConfig(config, activation, activation.configPath, requireTrustedConfigApiUrl(config, activation.configPath), activation.configApiUrl);
 	const effectiveApiUrl = requireTrustedApiOverride(activation.apiUrl, activation.configApiUrl, activation.configPath);
 	return {
@@ -8576,7 +9540,7 @@ function assertIdentityMatches(current, expected, currentLabel, expectedLabel) {
 	if (!assessment.ok) throw new AgentServerIdentityError("verification_failed", `${currentLabel} ${assessment.label} does not match ${expectedLabel}`);
 }
 function verificationError(message, cause) {
-	return new AgentServerIdentityError("verification_failed", message, { cause });
+	return new AgentServerIdentityError("verification_failed", cause instanceof AuthenticationError ? cause.message : message, { cause });
 }
 /** Non-secret projection preserving the existing `/v1` response shape. */
 function publicAgentView(store, activation) {
@@ -8666,6 +9630,8 @@ function validateRunSpec(spec) {
 	if (!spec.teamId) throw new AgentServerRunError("invalid_spec", "teamId is required");
 	if (!Array.isArray(spec.profiles) || spec.profiles.length === 0) throw new AgentServerRunError("invalid_spec", "at least one profile is required");
 	if (!Array.isArray(spec.taskTypes) || spec.taskTypes.length === 0) throw new AgentServerRunError("invalid_spec", "at least one task type is required");
+	const unknownTaskType = spec.taskTypes.find((taskType) => !Object.prototype.hasOwnProperty.call(BUILT_IN_TASK_TYPES, taskType));
+	if (unknownTaskType) throw new AgentServerRunError("invalid_spec", `unknown task type "${unknownTaskType}"`);
 }
 var RunManager = class {
 	active = /* @__PURE__ */ new Map();
@@ -8703,6 +9669,10 @@ var RunManager = class {
 			agentName: activation.alias,
 			cwd: dirname(piDir),
 			extraArgs: []
+		} : activation.configPath === this.store.agentPath(activation.alias) ? {
+			agentName: activation.alias,
+			cwd: dirname(piDir),
+			extraArgs: []
 		} : (() => {
 			const { agentName, agentRoot } = externalAgentLocation(activation.configPath);
 			return {
@@ -9319,69 +10289,6 @@ function writeRegistry(path, entries) {
 	writeFileSync(temp, `${JSON.stringify(entries, null, 2)}\n`, { mode: 384 });
 	renameSync(temp, path);
 }
-var AgentServerModelDiscoveryError = class extends Error {
-	name = "AgentServerModelDiscoveryError";
-	constructor(code, message, statusCode, options) {
-		super(message, options);
-		this.code = code;
-		this.statusCode = statusCode;
-	}
-};
-var ModelDiscoveryCollector = class {
-	models = /* @__PURE__ */ new Set();
-	addOpenAiResponse(value) {
-		if (!isRecord(value) || !Array.isArray(value["data"])) return;
-		for (const candidate of value["data"]) {
-			if (!isRecord(candidate)) continue;
-			const id = candidate["id"];
-			if (typeof id === "string" && id.length > 0) this.models.add(id);
-		}
-	}
-	addOllamaResponse(value) {
-		if (!isRecord(value) || !Array.isArray(value["models"])) return;
-		for (const candidate of value["models"]) {
-			if (!isRecord(candidate)) continue;
-			const name = candidate["name"];
-			if (typeof name === "string" && name.length > 0) this.models.add(name);
-		}
-	}
-	get size() {
-		return this.models.size;
-	}
-	result(providerId, failures) {
-		if (this.models.size === 0) throw discoveryFailure(providerId, failures);
-		return {
-			models: [...this.models].sort().slice(0, 500),
-			discoveredCount: this.models.size
-		};
-	}
-};
-function parseProviderBaseUrl(value, providerId) {
-	let parsed;
-	try {
-		parsed = new URL(value);
-	} catch (cause) {
-		throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" has an invalid base URL`, 400, { cause });
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must be HTTP(S) without credentials, query, or fragment`, 400);
-	if (isNonLoopbackPrivateAddress(parsed.hostname)) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must not target a private network address`, 400);
-	return parsed;
-}
-function isNonLoopbackPrivateAddress(hostname) {
-	if (isIP(hostname) !== 4) return false;
-	const [first, second] = hostname.split(".").map(Number);
-	if (first === 127) return false;
-	return first === 10 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 169 && second === 254;
-}
-function discoveryFailure(providerId, failures) {
-	if (failures.some((failure) => failure.kind === "http" && (failure.status === 401 || failure.status === 403))) return new AgentServerModelDiscoveryError("discovery_unauthorized", `provider "${providerId}" rejected model discovery; check its API key`, 502);
-	if (failures.some((failure) => failure.kind === "network")) return new AgentServerModelDiscoveryError("discovery_unavailable", `provider "${providerId}" could not be reached for model discovery`, 502);
-	if (failures.some((failure) => failure.kind === "invalid_response")) return new AgentServerModelDiscoveryError("discovery_invalid_response", `provider "${providerId}" returned an invalid model response`, 502);
-	return new AgentServerModelDiscoveryError("discovery_failed", `no models discovered for provider "${providerId}"`, 502);
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 //#endregion
 //#region src/lib/agent-server/protocol.ts
 var DateTime = Type.String({ format: "date-time" });
@@ -9408,6 +10315,12 @@ var AgentServerAgentSchema = Type.Object({
 	hasAgentKey: Type.Optional(Type.Boolean()),
 	hasPrivateKey: Type.Optional(Type.Boolean())
 }, { $id: "AgentServerAgent" });
+var AgentServerIdentitySchema = Type.Object({
+	alias: Type.String(),
+	activated: Type.Boolean(),
+	hasAgentKey: Type.Boolean()
+}, { $id: "AgentServerIdentity" });
+var AgentServerTaskTypeSchema = Type.Union(REGISTERED_TASK_TYPES.map((taskType) => Type.Literal(taskType)), { $id: "AgentServerTaskType" });
 var AgentServerProviderSchema = Type.Object({
 	api: Type.String(),
 	baseUrl: Type.String({ format: "uri" }),
@@ -9457,6 +10370,8 @@ var AgentServerStatusSchema = Type.Object({
 	platform: Type.String(),
 	subscriptions: Type.Array(schemaRef(AgentServerSubscriptionSchema)),
 	agents: Type.Array(schemaRef(AgentServerAgentSchema)),
+	identities: Type.Array(schemaRef(AgentServerIdentitySchema)),
+	selectedIdentity: Type.Optional(Type.String()),
 	providers: Type.Record(Type.String(), schemaRef(AgentServerProviderSchema)),
 	runs: Type.Array(schemaRef(AgentServerRunSchema))
 }, { $id: "AgentServerStatus" });
@@ -9469,17 +10384,14 @@ var PairingParamsSchema = Type.Object({ pairingId: Type.String() });
 var ProviderParamsSchema = Type.Object({ providerId: Type.String() });
 var AgentParamsSchema = Type.Object({ agentName: Type.String() });
 var RunParamsSchema = Type.Object({ runId: Type.String() });
-var CreateAgentSchema = Type.Object({
-	kind: Type.Union([Type.Literal("managed"), Type.Literal("external")]),
-	name: Type.String()
-}, { anyOf: [Type.Object({
+var CreateAgentSchema = Type.Union([Type.Object({
 	kind: Type.Literal("managed"),
+	name: Type.String(),
 	enrollmentToken: Type.String()
 }), Type.Object({
 	kind: Type.Literal("external"),
-	configDir: Type.String(),
-	apiUrl: Type.Optional(Type.String({ format: "uri" }))
-})] });
+	identityAlias: Type.String()
+})]);
 var ReconcileAgentSchema = Type.Object({ action: Type.Union([Type.Literal("resume"), Type.Literal("abandon")]) });
 var ReconcileAgentResultSchema = Type.Union([schemaRef(AgentServerAgentSchema), Type.Object({ abandoned: Type.Literal(true) })], { $id: "ReconcileAgentResult" });
 var PutProviderSchema = Type.Object({
@@ -9494,7 +10406,7 @@ var StartRunSchema = Type.Object({
 	agent: Type.String(),
 	teamId: Type.String(),
 	profiles: StringList,
-	taskTypes: StringList,
+	taskTypes: Type.Array(AgentServerTaskTypeSchema),
 	mode: Type.Union([Type.Literal("poll"), Type.Literal("drain")])
 });
 var CancelledSubscriptionSchema = Type.Object({
@@ -9509,6 +10421,8 @@ var AGENT_SERVER_SCHEMAS = [
 	AgentServerHealthSchema,
 	AgentServerProblemSchema,
 	AgentServerAgentSchema,
+	AgentServerIdentitySchema,
+	AgentServerTaskTypeSchema,
 	AgentServerProviderSchema,
 	AgentServerRunRecordSchema,
 	AgentServerRunSchema,
@@ -9804,8 +10718,8 @@ function stringArray(body, field, options = {}) {
 }
 function requestOperationSignal(request, shutdownSignal) {
 	const disconnected = new AbortController();
-	if (request.raw.aborted) disconnected.abort();
-	else request.raw.once("aborted", () => disconnected.abort());
+	if (request.raw.aborted) disconnected.abort({ source: "request" });
+	else request.raw.once("aborted", () => disconnected.abort({ source: "request" }));
 	return shutdownSignal ? AbortSignal.any([disconnected.signal, shutdownSignal]) : disconnected.signal;
 }
 function buildAgentServer(options) {
@@ -9924,12 +10838,15 @@ function registerStatusRoute(app, options, requirePairedOrigin) {
 	const { store, runs } = options;
 	app.get("/v1/status", { schema: AgentServerRouteSchemas.status }, async (request) => {
 		requirePairedOrigin(request);
+		const selected = selectedIdentity(store, options.activeIdentity);
 		return {
 			version: options.version,
 			platform: process.platform,
 			subscriptions: options.subscriptions.list(),
 			agents: store.listActivations().map((activation) => publicAgentView(store, activation)),
-			providers: Object.fromEntries(Object.entries(store.readProviders()).map(([id, provider]) => [id, providerView(provider)])),
+			identities: identityViews(store),
+			...selected ? { selectedIdentity: selected } : {},
+			providers: options.providers.list(),
 			runs: runViews(runs)
 		};
 	});
@@ -9959,11 +10876,10 @@ function registerAgentRoutes(app, options, requirePairedOrigin) {
 			return reply.code(201).send(publicAgentView(store, entry.activation));
 		}
 		if (kind === "external") {
-			const apiUrl = optionalString(body, "apiUrl");
+			const identityAlias = requireString(body, "identityAlias");
 			const entry = await attachExternalAgent(store, options.externalSecretProviders, {
-				name: requireString(body, "name"),
-				configDir: requireString(body, "configDir"),
-				...apiUrl ? { apiUrl } : {},
+				name: identityAlias,
+				configDir: store.identityDir(identityAlias),
 				signal
 			});
 			return reply.code(201).send(publicAgentView(store, entry.activation));
@@ -9982,153 +10898,60 @@ function registerAgentRoutes(app, options, requirePairedOrigin) {
 		return reconciled ? publicAgentView(store, reconciled.activation) : { abandoned: true };
 	});
 }
+function selectedIdentity(store, activeIdentity) {
+	try {
+		return store.resolveIdentityAlias(void 0, activeIdentity);
+	} catch (error) {
+		if (error instanceof AgentServerStoreError && error.code === "not_found") return;
+		throw error;
+	}
+}
+function identityViews(store) {
+	const activated = new Set(store.listActivations().map((activation) => activation.alias));
+	return store.listIdentityAliases().map((alias) => ({
+		alias,
+		activated: activated.has(alias),
+		hasAgentKey: Boolean(store.readAgentConfig(alias)?.agent_key_ref)
+	}));
+}
 function registerProviderRoutes(app, options, requirePairedOrigin) {
-	const { store } = options;
-	let mutationQueue = Promise.resolve();
-	const serialize = (mutation) => {
-		const result = mutationQueue.then(mutation, mutation);
-		mutationQueue = result.then(() => void 0, () => void 0);
-		return result;
-	};
 	app.get("/v1/providers", { schema: AgentServerRouteSchemas.listProviders }, async (request) => {
 		requirePairedOrigin(request);
-		return Object.fromEntries(Object.entries(store.readProviders()).map(([id, provider]) => [id, providerView(provider)]));
+		return options.providers.list();
 	});
 	app.post("/v1/providers/:providerId/discover-models", { schema: AgentServerRouteSchemas.discoverModels }, async (request) => {
 		requirePairedOrigin(request);
-		const { providerId: rawProviderId } = request.params;
-		const providerId = assertProviderId(rawProviderId);
-		const provider = store.readProviders()[providerId];
-		if (!provider) throw new AgentServerHttpError(404, "provider_not_found", `provider "${providerId}" was not found`);
-		const parsed = parseProviderBaseUrl(provider.baseUrl, providerId);
-		const baseUrl = parsed.href.replace(/\/$/u, "");
-		let apiKey;
-		if (provider.apiKeyRef) try {
-			apiKey = await options.secretProviders.resolve(parseSecretReferenceString(provider.apiKeyRef));
-		} catch (error) {
-			request.log.warn({
-				...safeErrorContext(error),
-				code: "agent_server_provider_secret_unavailable",
-				providerId
-			}, "Provider API key could not be resolved for model discovery");
-			throw new AgentServerHttpError(400, "provider_secret_unavailable", `provider "${providerId}" API key could not be resolved`);
-		}
-		const headers = apiKey ? { authorization: `Bearer ${apiKey}` } : {};
-		const fetchImpl = options.discoverFetch ?? fetch;
-		const failures = [];
-		const collector = new ModelDiscoveryCollector();
-		const tryJson = async (endpoint, url) => {
-			let response;
-			try {
-				response = await fetchImpl(url, {
-					headers,
-					redirect: "error",
-					signal: AbortSignal.timeout(1e4)
-				});
-			} catch (error) {
-				const errorType = error instanceof Error ? error.name : typeof error;
-				failures.push({
-					kind: "network",
-					errorType
-				});
-				request.log.warn({
-					code: "agent_server_provider_discovery_request_failed",
-					endpoint,
-					errorType,
-					providerId
-				}, "Provider model discovery request failed");
-				return null;
-			}
-			if (!response.ok) {
-				failures.push({
-					kind: "http",
-					status: response.status
-				});
-				const context = {
-					code: "agent_server_provider_discovery_upstream_error",
-					endpoint,
-					providerId,
-					statusCode: response.status
-				};
-				if (response.status >= 500 || response.status === 401 || response.status === 403) request.log.warn(context, "Provider model discovery was rejected");
-				else request.log.info(context, "Provider model discovery endpoint unavailable");
-				return null;
-			}
-			try {
-				return await response.json();
-			} catch {
-				failures.push({ kind: "invalid_response" });
-				request.log.warn({
-					code: "agent_server_provider_discovery_invalid_json",
-					endpoint,
-					providerId
-				}, "Provider model discovery returned invalid JSON");
-				return null;
-			}
-		};
-		collector.addOpenAiResponse(await tryJson("openai_models", `${baseUrl}/models`));
-		if (collector.size === 0) collector.addOllamaResponse(await tryJson("ollama_tags", `${parsed.origin}/api/tags`));
-		const result = collector.result(providerId, failures);
-		if (result.discoveredCount > result.models.length) request.log.warn({
-			code: "agent_server_provider_discovery_truncated",
-			discoveredCount: result.discoveredCount,
-			providerId,
-			returnedCount: 500
-		}, "Provider model discovery result was truncated");
-		request.log.info({
-			code: "agent_server_provider_discovery_completed",
-			modelCount: result.models.length,
-			providerId
-		}, "Provider model discovery completed");
-		return { models: result.models };
+		const { providerId } = request.params;
+		return options.providers.discover(providerId, { signal: requestOperationSignal(request, options.shutdownSignal) });
 	});
 	app.put("/v1/providers/:providerId", {
 		schema: AgentServerRouteSchemas.putProvider,
 		attachValidation: true
 	}, async (request, reply) => {
 		requirePairedOrigin(request);
-		const { providerId: rawProviderId } = request.params;
-		const providerId = assertProviderId(rawProviderId);
+		const { providerId } = request.params;
 		const body = requireBody(request);
-		const baseUrl = requireString(body, "baseUrl");
-		parseProviderBaseUrl(baseUrl, providerId);
-		const entry = {
+		const entry = await options.providers.set(providerId, {
 			api: requireString(body, "api"),
-			baseUrl,
-			envName: assertProviderEnvName(providerId, requireString(body, "envName")),
-			models: stringArray(body, "models", { allowEmpty: true })
-		};
-		const apiKey = optionalString(body, "apiKey");
-		await serialize(async () => {
-			const providers = store.readProviders();
-			if (apiKey) {
-				const key = `pi-provider/${providerId}`;
-				await options.secrets.write(key, apiKey);
-				entry.apiKeyRef = formatSecretReferenceString({
-					provider: FILE_SECRET_PROVIDER,
-					key
-				});
-			} else if (providers[providerId]?.apiKeyRef) entry.apiKeyRef = providers[providerId].apiKeyRef;
-			providers[providerId] = entry;
-			store.writeProviders(providers);
+			baseUrl: requireString(body, "baseUrl"),
+			envName: requireString(body, "envName"),
+			models: stringArray(body, "models", { allowEmpty: true }),
+			...optionalString(body, "apiKey") ? { apiKey: optionalString(body, "apiKey") } : {}
 		});
-		return reply.code(200).send(providerView(entry));
+		return reply.code(200).send(entry);
 	});
 	app.delete("/v1/providers/:providerId", {
 		schema: AgentServerRouteSchemas.deleteProvider,
 		attachValidation: true
 	}, async (request, reply) => {
 		requirePairedOrigin(request);
-		const { providerId: rawProviderId } = request.params;
-		const providerId = assertProviderId(rawProviderId);
-		await serialize(async () => {
-			const providers = store.readProviders();
-			const provider = providers[providerId];
-			if (!provider) throw new AgentServerHttpError(404, "agent_server_provider_not_found", `Provider ${providerId} was not found`);
-			if (provider.apiKeyRef) await options.secrets.delete(`pi-provider/${providerId}`);
-			delete providers[providerId];
-			store.writeProviders(providers);
-		});
+		const { providerId } = request.params;
+		try {
+			await options.providers.remove(providerId);
+		} catch (error) {
+			if (error instanceof ProviderConfigurationError && error.code === "provider_not_found") throw new AgentServerHttpError(404, "agent_server_provider_not_found", error.message);
+			throw error;
+		}
 		return reply.code(204).send(null);
 	});
 }
@@ -10277,40 +11100,6 @@ function registerRunLogRoute(app, options, requirePairedOrigin) {
 		return reply;
 	});
 }
-function safeErrorContext(error) {
-	const context = { errorType: error instanceof Error ? error.name : typeof error };
-	const applicationCode = safeErrorToken(error?.code);
-	if (applicationCode) context["applicationCode"] = applicationCode;
-	const cause = error instanceof Error ? error.cause : void 0;
-	if (cause instanceof Error) {
-		context["causeType"] = cause.name;
-		const causeMessage = safeLogMessage(cause.message);
-		if (causeMessage) context["causeMessage"] = causeMessage;
-	}
-	const fsCode = safeErrorToken(cause?.code);
-	const syscall = safeErrorToken(cause?.syscall);
-	if (fsCode) context["fsCode"] = fsCode;
-	if (syscall) context["syscall"] = syscall;
-	const causeStatus = cause?.statusCode;
-	if (typeof causeStatus === "number") context["causeStatusCode"] = causeStatus;
-	return context;
-}
-function safeLogMessage(value) {
-	const normalized = value.replace(/[\r\n\t]/gu, " ").trim();
-	return normalized ? normalized.slice(0, 500) : void 0;
-}
-function safeErrorToken(value) {
-	return typeof value === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(value) ? value : void 0;
-}
-function providerView(provider) {
-	return {
-		api: provider.api,
-		baseUrl: provider.baseUrl,
-		envName: provider.envName,
-		models: provider.models,
-		hasApiKey: Boolean(provider.apiKeyRef)
-	};
-}
 function corsHeadersFor(request, options) {
 	const origin = request.headers.origin;
 	if (isConfiguredOrigin(origin, options)) return {
@@ -10358,6 +11147,11 @@ function normalizeAgentServerError(error) {
 		code: error.code,
 		message: error.message
 	};
+	if (error instanceof ProviderConfigurationError) return {
+		statusCode: error.statusCode,
+		code: error.code,
+		message: error.message
+	};
 	if (error instanceof AgentServerIdentityError) return {
 		statusCode: error.code === "agent_exists" ? 409 : 400,
 		code: error.code,
@@ -10585,6 +11379,12 @@ async function runAgentServer(argv) {
 					authPath: store.piAuthJsonPath,
 					logger
 				});
+				const providers = new ProviderConfigurationService({
+					store,
+					secrets,
+					secretProviders,
+					logger
+				});
 				const runs = new RunManager({
 					store,
 					secretProviders,
@@ -10602,6 +11402,7 @@ async function runAgentServer(argv) {
 					pairing,
 					runs,
 					subscriptions,
+					providers,
 					allowedOrigins,
 					selfOrigin: `${tls ? "https" : "http"}://127.0.0.1:${port}`,
 					...tls ? { tls: {
@@ -10609,6 +11410,7 @@ async function runAgentServer(argv) {
 						cert: tls.cert
 					} } : {},
 					defaultApiUrl,
+					...envConfig.activeIdentity ? { activeIdentity: envConfig.activeIdentity } : {},
 					version: "dev",
 					logger,
 					shutdownSignal: shutdownController.signal
@@ -10680,7 +11482,7 @@ function waitForAgentServerShutdown(runs, app, shutdownController) {
 		const shutdown = () => {
 			if (shuttingDown) return;
 			shuttingDown = true;
-			shutdownController.abort();
+			shutdownController.abort({ source: "shutdown" });
 			(async () => {
 				app.server.closeAllConnections();
 				const cleanupPromise = Promise.allSettled([runs.stopAll(), app.close()]);
@@ -11052,7 +11854,7 @@ async function writeCache(cache) {
 }
 //#endregion
 //#region src/version.ts
-var DAEMON_VERSION = "0.55.1";
+var DAEMON_VERSION = "0.56.1";
 //#endregion
 //#region src/cli.ts
 async function runAgentDaemonCli(options) {
@@ -11072,6 +11874,7 @@ async function runAgentDaemonCli(options) {
 		case "once": return runOnce(rest, options.runtime);
 		case "drain": return runDrain(rest, options.runtime);
 		case "server": return runAgentServer(rest);
+		case "providers": return runProviders(rest);
 		case "sync-sessions": return runSyncSessions(rest);
 		case "update": return runUpdate(rest);
 		case "runtime": return runRuntime(rest);