@themoltnet/agent-daemon 0.48.0 → 0.49.1

package/dist/cli.js

@@ -12,7 +12,7 @@ import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource, cre
 import { GuestEnvironmentBoundaryError, assertGuestEnvironmentBoundary, createPiRetryTriage, findMainWorktree, isResolvedPathInsideRoot, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveRuntimeProfileModel } from "@themoltnet/pi-runtime";
 import { FILE_SECRET_PROVIDER, FileSecretProvider, connect, createNodeSecretProviderRegistry } from "@themoltnet/sdk/node";
 import { execFile, execFileSync, spawn } from "node:child_process";
-import { constants, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { constants, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { AuthenticationError, MoltNetError, agentKeyKey, assertTrustedConfigApiUrl, createExecutorAttestor, deriveMcpUrl, formatSecretReferenceString, identitySeedKey, parseSecretReferenceString, readConfig, register, requireSecureCredentialApiUrl, resolveAgentKey, resolveEnvSecretReference, resolveIdentitySeed, resolveOAuth2ClientSecret } from "@themoltnet/sdk";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { once } from "node:events";
@@ -30,6 +30,8 @@ import { mkdir, open, realpath, stat } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 import cors from "@fastify/cors";
 import helmet from "@fastify/helmet";
+import { getOAuthProviders } from "@earendil-works/pi-ai/oauth";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
 import { Transform, Writable } from "node:stream";
 import { writePiConfig } from "@themoltnet/pi-runtime/pi-config";
 import { homedir } from "node:os";
@@ -4424,13 +4426,11 @@ function attestPreparedRuntime(prepared, signingPrivateKey) {
 //#endregion
 //#region src/lib/retry-triage.ts
 var RETRYABLE_CODES = new Set([
-	"checkpoint_upload_failed",
 	"complete_call_failed",
 	"daemon_abort",
 	"dispatch_expired",
 	"lease_expired",
 	"llm_api_error",
-	"runtime_session_checkpoint_failed",
 	"session_prompt_failed"
 ]);
 var NON_RETRYABLE_CODES = new Set([
@@ -4480,7 +4480,7 @@ var NON_RETRYABLE_MESSAGE_PATTERNS = [
 async function classifyAttemptFailure(input) {
 	const deterministic = classifyDeterministically(input.error);
 	if (input.remainingAttempts !== null && input.remainingAttempts !== void 0 && input.remainingAttempts <= 0) {
-		const deterministicReason = deterministic === "ambiguous" ? "" : ` Deterministic policy classified the failure as ${deterministic}.`;
+		const deterministicReason = deterministic === "ambiguous" ? "" : deterministic === "retryable" ? " The failure type is retryable, but no attempts remain." : " The failure type is non-retryable.";
 		return {
 			error: withRetryInfo(input.error, {
 				retryable: false,
@@ -4546,6 +4546,7 @@ async function classifyAttemptFailure(input) {
 function classifyDeterministically(error) {
 	const code = error.code.toLowerCase();
 	const message = error.message;
+	if (code === "runtime_session_upload_failed") return error.retryable === true ? "retryable" : "non_retryable";
 	if (NON_RETRYABLE_CODES.has(code)) return "non_retryable";
 	if (NON_RETRYABLE_MESSAGE_PATTERNS.some((pattern) => pattern.test(message))) return "non_retryable";
 	if (RETRYABLE_CODES.has(code)) return "retryable";
@@ -5539,15 +5540,29 @@ function applyRuntimeSessionUploadFailure(output, err) {
 		error: {
 			code: "runtime_session_upload_failed",
 			message: "Task completed, but durable runtime session checkpoint upload failed: " + (err instanceof Error ? err.message : String(err)),
-			retryable: true
+			retryable: isTransientUploadError(err)
 		},
 		output: null,
 		outputCid: null,
 		status: "failed"
 	};
 }
+/**
+* Transient faults worth retrying in-attempt: network-level errors
+* (no HTTP status at all) and 5xx/429 responses. A 4xx (auth,
+* validation, not-found) will not heal on retry.
+*/
+function isTransientUploadError(error) {
+	if (!(error instanceof Error)) return false;
+	const statusCode = error.statusCode;
+	if (typeof statusCode !== "number") return true;
+	return statusCode >= 500 || statusCode === 429;
+}
+var defaultSleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
 function createApiRuntimeSessionStore(args) {
-	const { agent } = args;
+	const { agent, logger, uploadRetry } = args;
 	return {
 		async findRuntimeSessionByTaskAttempt(teamId, taskId, attemptN) {
 			return agent.runtimeSessions.getForAttempt({
@@ -5568,18 +5583,40 @@ function createApiRuntimeSessionStore(args) {
 		async uploadAttemptFinal(input) {
 			const sessionPath = resolveLatestPiSessionPath(input.sessionDir);
 			if (!sessionPath) throw new Error(`Cannot upload runtime session for ${input.taskId}/${input.attemptN}: no local session file in ${input.sessionDir}`);
-			await agent.runtimeSessions.upload({
-				attemptN: input.attemptN,
-				taskId: input.taskId
-			}, createReadStream(sessionPath), {
-				parentSessionId: input.parentSessionId ?? void 0,
-				sessionKind: input.sessionKind,
-				sourceRuntimeProfileId: input.sourceRuntimeProfileId ?? void 0,
-				sourceSlotId: input.sourceSlotId ?? void 0
-			}, { teamId: input.teamId });
+			const maxTries = uploadRetry?.maxTries ?? 3;
+			const baseDelayMs = uploadRetry?.baseDelayMs ?? 750;
+			const sleep = uploadRetry?.sleep ?? defaultSleep;
+			for (let tryN = 1;; tryN += 1) try {
+				await agent.runtimeSessions.upload({
+					attemptN: input.attemptN,
+					taskId: input.taskId
+				}, createReadStream(sessionPath), {
+					parentSessionId: input.parentSessionId ?? void 0,
+					sessionKind: input.sessionKind,
+					sourceRuntimeProfileId: input.sourceRuntimeProfileId ?? void 0,
+					sourceSlotId: input.sourceSlotId ?? void 0
+				}, { teamId: input.teamId });
+				return;
+			} catch (error) {
+				if (tryN >= maxTries || !isTransientUploadError(error)) throw error;
+				const delayMs = baseDelayMs * tryN;
+				logger?.warn({
+					event: "agent-daemon.runtime_session_upload_retry",
+					attemptN: input.attemptN,
+					delayMs,
+					statusCode: uploadStatusCode(error),
+					taskId: input.taskId,
+					tryN
+				}, "Retrying durable runtime session upload");
+				await sleep(delayMs);
+			}
 		}
 	};
 }
+function uploadStatusCode(error) {
+	const statusCode = error?.statusCode;
+	return typeof statusCode === "number" ? statusCode : void 0;
+}
 function resolveContinueFrom(claimedTask) {
 	return claimedTask.task.input.continueFrom;
 }
@@ -5956,7 +5993,10 @@ async function runPolling(opts) {
 		throw new Error(`No safe runtime profiles remain. ${details}`);
 	}
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
-	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
+	const runtimeSessionStore = createApiRuntimeSessionStore({
+		agent: ctx.agent,
+		logger: { warn: (context, message) => rootLogger.warn(context, message) }
+	});
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
 	const runtimeInstanceId = createRuntimeInstanceId();
 	const runtimes = /* @__PURE__ */ new Map();
@@ -6607,7 +6647,10 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 	activatePiCodingAgentDir(piAgentDir.path);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
-	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
+	const runtimeSessionStore = createApiRuntimeSessionStore({
+		agent: ctx.agent,
+		logger: { warn: (context, message) => rootLogger.warn(context, message) }
+	});
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
 	const runtimeInstanceId = createRuntimeInstanceId();
 	const slotIdentity = {
@@ -7277,6 +7320,258 @@ function renderPairingResultPage(input) {
 </html>
 `;
 }
+//#endregion
+//#region src/lib/serve/provider-login.ts
+/**
+* Subscription-provider OAuth brokering for `serve` (#2061 slice 4).
+*
+* The console clicks "Connect"; serve runs the Pi OAuth flow host-side via
+* `AuthStorage.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-ai's own OAuth registry (`getOAuthProviders`),
+* so serve stays in lockstep with what Pi can actually authenticate
+* (anthropic, openai-codex, github-copilot, …) without hardcoding.
+*/
+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 ServeSubscriptionError = class extends Error {
+	name = "ServeSubscriptionError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+var silentLogger = {
+	info: () => void 0,
+	warn: () => void 0,
+	error: () => void 0
+};
+var ProviderLoginService = class {
+	logins = /* @__PURE__ */ new Map();
+	authStorage;
+	logger;
+	constructor(options) {
+		this.options = options;
+		this.authStorage = options.authStorage ?? AuthStorage.create(this.options.authPath);
+		this.logger = options.logger ?? silentLogger;
+	}
+	now() {
+		return this.options.now?.() ?? Date.now();
+	}
+	providers() {
+		return this.options.listProviders?.() ?? getOAuthProviders().map((provider) => ({
+			id: provider.id,
+			name: provider.name
+		}));
+	}
+	connected(providerId) {
+		if (this.options.isConnected) return this.options.isConnected(providerId);
+		try {
+			return (this.options.authStorage ? this.authStorage : AuthStorage.create(this.options.authPath)).getAuthStatus(providerId).configured;
+		} catch (error) {
+			this.logger.warn({
+				event: "serve.subscription_auth_read_failed",
+				providerId,
+				...safeLoginError(error)
+			}, "Could not read subscription authentication state");
+			return false;
+		}
+	}
+	list() {
+		this.sweep();
+		return this.providers().map((provider) => ({
+			...provider,
+			connected: this.connected(provider.id)
+		}));
+	}
+	sweep() {
+		const now = this.now();
+		for (const [id, login] of this.logins) if (login.startedAt + LOGIN_TTL_MS <= now) {
+			this.invalidate(login, "expired");
+			this.logins.delete(id);
+		}
+	}
+	restoreCredential(login) {
+		try {
+			if (login.previousCredential) this.authStorage.set(login.providerId, login.previousCredential);
+			else this.authStorage.logout(login.providerId);
+		} catch (error) {
+			this.logger.error({
+				event: "serve.subscription_login_cleanup_failed",
+				operationId: login.operationId,
+				providerId: login.providerId,
+				...safeLoginError(error)
+			}, "Could not restore subscription credentials after an invalidated login");
+		}
+	}
+	invalidate(login, transition) {
+		if (login.invalidated) return;
+		login.invalidated = true;
+		login.abort.abort(/* @__PURE__ */ new Error(`subscription login ${transition}`));
+		this.restoreCredential(login);
+		login.infoArrived();
+		this.logger.info({
+			event: "serve.subscription_login_transition",
+			operationId: login.operationId,
+			providerId: login.providerId,
+			transition
+		}, "Subscription login invalidated");
+	}
+	status(providerId) {
+		this.sweep();
+		const login = this.logins.get(providerId);
+		if (!login) throw new ServeSubscriptionError("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 ServeSubscriptionError("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: this.authStorage.get(providerId)
+		};
+		this.logins.set(providerId, login);
+		this.logger.info({
+			event: "serve.subscription_login_transition",
+			operationId: login.operationId,
+			providerId,
+			transition: "started"
+		}, "Subscription login started");
+		const callbacks = createLoginCallbacks(login, this.logger);
+		(this.options.runLogin ?? ((id, loginCallbacks) => this.authStorage.login(id, loginCallbacks)))(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: "serve.subscription_login_transition",
+					operationId: login.operationId,
+					providerId,
+					transition: "persistence_failed"
+				}, "Subscription login credentials were not persisted");
+			} else {
+				login.status = "completed";
+				this.logger.info({
+					event: "serve.subscription_login_transition",
+					operationId: login.operationId,
+					providerId,
+					transition: "completed"
+				}, "Subscription login completed");
+			}
+			login.infoArrived();
+		}, (error) => {
+			if (login.invalidated) {
+				this.restoreCredential(login);
+				return;
+			}
+			login.status = "failed";
+			login.error = publicLoginError(error);
+			this.logger.warn({
+				event: "serve.subscription_login_transition",
+				operationId: login.operationId,
+				providerId,
+				transition: "failed",
+				...safeLoginError(error)
+			}, "Subscription login failed");
+			login.infoArrived();
+		});
+		await Promise.race([infoPromise, new Promise((resolvePromise) => {
+			setTimeout(resolvePromise, START_INFO_TIMEOUT_MS).unref?.();
+		})]);
+		return snapshot(login);
+	}
+	/** Abort an in-flight login and forget it. */
+	cancel(providerId) {
+		const login = this.logins.get(providerId);
+		if (!login) throw new ServeSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
+		this.invalidate(login, "cancelled");
+		this.logins.delete(providerId);
+		return {
+			providerId,
+			status: "cancelled"
+		};
+	}
+	/** Abort every pending flow during supervisor shutdown. */
+	close() {
+		for (const login of this.logins.values()) this.invalidate(login, "shutdown");
+		this.logins.clear();
+	}
+};
+function createLoginCallbacks(login, logger) {
+	return {
+		onAuth: (info) => {
+			login.authUrl = info.url;
+			if (info.instructions) login.instructions = info.instructions;
+			logger.info({
+				event: "serve.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: "serve.subscription_login_transition",
+				operationId: login.operationId,
+				providerId: login.providerId,
+				transition: "device_code_ready"
+			}, "Subscription device code ready");
+			login.infoArrived();
+		},
+		onPrompt: () => Promise.reject(new ServeSubscriptionError("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 publicLoginError(error) {
+	if (error instanceof ServeSubscriptionError) return error.message;
+	return "Subscription sign-in failed. Start again to retry.";
+}
+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 snapshot(login) {
+	const { providerId, status, authUrl, instructions, userCode, verificationUri, error } = login;
+	return {
+		providerId,
+		status,
+		...authUrl ? { authUrl } : {},
+		...instructions ? { instructions } : {},
+		...userCode ? { userCode } : {},
+		...verificationUri ? { verificationUri } : {},
+		...error ? { error } : {}
+	};
+}
 var NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
 var PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function assertStoreName(kind, value) {
@@ -7340,11 +7635,17 @@ var ServeStore = class {
 	agentsDir;
 	runsDir;
 	secretsDir;
+	/** Shared Pi credential dir; `auth.json` inside is pi-managed (lockfiled). */
+	piDir;
 	constructor(root) {
 		this.root = root;
 		this.agentsDir = join(root, "agents");
 		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() {
@@ -7369,13 +7670,13 @@ var ServeStore = class {
 			pendingRegistrations: {},
 			activations: {}
 		};
-		if (!isRecord(state) || state.version !== 1) throw new ServeStoreError("invalid_state", `serve.json version ${String(isRecord(state) ? state.version : void 0)} is not supported`);
+		if (!isRecord$1(state) || state.version !== 1) throw new ServeStoreError("invalid_state", `serve.json version ${String(isRecord$1(state) ? state.version : void 0)} is not supported`);
 		if ("pairedOrigins" in state) throw new ServeStoreError("invalid_state", "serve.json uses the obsolete pairing format; clear the unreleased serve store and reconfigure it");
-		if (!isRecord(state.pendingRegistrations) || !isRecord(state.activations)) throw new ServeStoreError("invalid_state", "serve.json is missing the version 1 activation map; clear the unreleased serve store and reconfigure it");
+		if (!isRecord$1(state.pendingRegistrations) || !isRecord$1(state.activations)) throw new ServeStoreError("invalid_state", "serve.json is missing the version 1 activation map; clear the unreleased serve store and reconfigure it");
 		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(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new ServeStoreError("invalid_state", `pending registration "${alias}" is not valid`);
+			if (!isRecord$1(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new ServeStoreError("invalid_state", `pending registration "${alias}" is not valid`);
 		}
 		return {
 			version: 1,
@@ -7549,7 +7850,7 @@ function directoryBytes(path) {
 	for (const entry of readdirSync(path, { withFileTypes: true })) total += directoryBytes(join(path, entry.name));
 	return total;
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function storeChildPath(root, kind, value, suffix = "") {
@@ -7567,7 +7868,7 @@ function validateActivation(alias, value) {
 	const invalid = () => {
 		throw new ServeStoreError("invalid_state", `activation "${alias}" is not a valid version 1 activation`);
 	};
-	if (!isRecord(value)) invalid();
+	if (!isRecord$1(value)) invalid();
 	const activation = value;
 	if (activation.alias !== alias) invalid();
 	if (![
@@ -7612,8 +7913,9 @@ function reserveAlias(store, alias) {
 	pending.add(alias);
 	return () => pending.delete(alias);
 }
-async function createManagedAgent(store, secrets, input) {
+async function createManagedAgent(store, secrets, input, connectAgent = connect) {
 	const alias = assertStoreName("agent name", input.name);
+	if (!input.enrollmentToken.trim()) throw new ServeIdentityError("enrollment_required", "an enrollment token from the target team is required — a self-registered agent would be stranded in its own personal team");
 	const releaseAlias = reserveAlias(store, alias);
 	let registeredIdentityId;
 	try {
@@ -7627,7 +7929,7 @@ async function createManagedAgent(store, secrets, input) {
 		const result = await register({
 			credentialType: "agent_key",
 			apiUrl,
-			...input.enrollmentToken ? { enrollmentToken: input.enrollmentToken } : {},
+			enrollmentToken: input.enrollmentToken,
 			signal: boundedIdentitySignal(input.signal)
 		});
 		if (result.credentials.type !== "agent_key") throw new ServeIdentityError("unsupported_credential", `registration returned credential type "${result.credentials.type}"; serve manages agent-key credentials only`);
@@ -7656,22 +7958,34 @@ async function createManagedAgent(store, secrets, input) {
 				mcp: deriveMcpUrl(result.apiUrl)
 			}
 		};
+		store.writeAgentConfig(alias, config);
+		await secrets.write(agentKeyReference.key, result.credentials.secret);
+		await secrets.write(seedReference.key, privateKey);
+		const whoami = await callWhoami(connectAgent, {
+			agentKey: result.credentials.secret,
+			apiUrl: result.apiUrl
+		}, store.agentPath(alias), input.signal);
+		assertIdentityMatches(whoami, {
+			identityId,
+			publicKey,
+			fingerprint
+		}, "authenticated whoami", `new managed agent "${alias}"`);
+		const boundTeamId = boundTeamIdFromWhoami(whoami);
 		const activation = {
 			alias,
 			source: "managed",
 			identityId,
 			publicKey,
 			fingerprint,
+			...boundTeamId ? { boundTeamId } : {},
 			createdAt: now,
 			apiUrl: result.apiUrl
 		};
-		store.writeAgentConfig(alias, config);
-		await secrets.write(agentKeyReference.key, result.credentials.secret);
-		await secrets.write(seedReference.key, privateKey);
 		store.writeActivation(activation);
 		return {
 			activation,
-			config
+			config,
+			...boundTeamId ? { boundTeamId } : {}
 		};
 	} catch (cause) {
 		if (!registeredIdentityId && cause instanceof MoltNetError && cause.statusCode !== void 0 && cause.statusCode >= 400 && cause.statusCode < 500) {
@@ -7708,21 +8022,25 @@ async function reconcileManagedRegistration(store, secrets, aliasInput, action,
 	if (!agentKey || privateKeyState !== "present") throw new ServeIdentityError("registration_incomplete", `pending registration for "${alias}" is missing persisted secret material`);
 	const identity = identityFromConfig(config);
 	const apiUrl = requireConfigApiUrl(config, store.agentPath(alias));
-	assertIdentityMatches(await callWhoami(connectAgent, {
+	const whoami = await callWhoami(connectAgent, {
 		agentKey,
 		apiUrl
-	}, store.agentPath(alias), signal), identity, "authenticated whoami", `pending registration "${alias}" config`);
+	}, store.agentPath(alias), signal);
+	assertIdentityMatches(whoami, identity, "authenticated whoami", `pending registration "${alias}" config`);
+	const boundTeamId = boundTeamIdFromWhoami(whoami);
 	const recovered = {
 		alias,
 		source: "managed",
 		...identity,
+		...boundTeamId ? { boundTeamId } : {},
 		createdAt: config.registered_at,
 		apiUrl
 	};
 	store.writeActivation(recovered);
 	return {
 		activation: recovered,
-		config
+		config,
+		...recovered.boundTeamId ? { boundTeamId: recovered.boundTeamId } : {}
 	};
 }
 async function attachExternalAgent(store, secretProviders, input, connectAgent = connect) {
@@ -7738,10 +8056,12 @@ async function attachExternalAgent(store, secretProviders, input, connectAgent =
 		const whoami = await authenticateConfig(input.configDir, effectiveApiUrl, secretProviders, connectAgent, input.signal);
 		const identity = identityFromConfig(config);
 		assertIdentityMatches(identity, whoami, `external config ${configPath}`, "authenticated whoami");
+		const boundTeamId = boundTeamIdFromWhoami(whoami);
 		const activation = {
 			alias,
 			source: "external",
 			...identity,
+			...boundTeamId ? { boundTeamId } : {},
 			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 			configPath,
 			configApiUrl,
@@ -7750,7 +8070,8 @@ async function attachExternalAgent(store, secretProviders, input, connectAgent =
 		store.writeActivation(activation);
 		return {
 			activation,
-			config
+			config,
+			...activation.boundTeamId ? { boundTeamId: activation.boundTeamId } : {}
 		};
 	} finally {
 		releaseAlias();
@@ -7761,9 +8082,12 @@ async function verifyAgentActivation(store, alias, managedSecretProviders, exter
 	const activation = requireActivation(store, alias);
 	const verified = activation.source === "managed" ? await verifyManagedActivation(store, activation, managedSecretProviders, connectAgent, signal) : await verifyExternalActivation(activation, externalSecretProviders, connectAgent, signal);
 	assertIdentityMatches(verified.whoami, activation, "authenticated whoami", `agent "${activation.alias}" pinned activation`);
+	const boundTeamId = boundTeamIdFromWhoami(verified.whoami);
+	if (activation.boundTeamId !== boundTeamId) throw new ServeIdentityError("verification_failed", `authenticated whoami team binding does not match agent "${activation.alias}" pinned activation`);
 	return {
 		activation,
-		config: verified.config
+		config: verified.config,
+		...boundTeamId ? { boundTeamId } : {}
 	};
 }
 async function verifyManagedActivation(store, activation, secretProviders, connectAgent, signal) {
@@ -7902,6 +8226,7 @@ function publicAgentView(store, activation) {
 			agentName: activation.alias,
 			identityId: activation.identityId,
 			fingerprint: activation.fingerprint,
+			...activation.boundTeamId ? { teamId: activation.boundTeamId } : {},
 			apiUrl: activation.apiUrl,
 			createdAt: activation.createdAt,
 			hasAgentKey: Boolean(config?.agent_key_ref),
@@ -7915,9 +8240,13 @@ function publicAgentView(store, activation) {
 		...activation.apiUrl ? { apiUrl: activation.apiUrl } : {},
 		identityId: activation.identityId,
 		fingerprint: activation.fingerprint,
+		...activation.boundTeamId ? { teamId: activation.boundTeamId } : {},
 		createdAt: activation.createdAt
 	};
 }
+function boundTeamIdFromWhoami(whoami) {
+	return whoami.credentialBinding?.bindingScope === "team" ? whoami.credentialBinding.boundTeamId ?? void 0 : void 0;
+}
 function requireActivation(store, alias) {
 	const activation = store.readActivation(alias);
 	if (!activation) throw new ServeStoreError("not_found", `agent "${alias}" is not configured`);
@@ -8087,6 +8416,7 @@ var RunManager = class {
 		this.assertStartOpen(signal);
 		const agent = await (this.options.verifyActivationImpl ?? verifyAgentActivation)(this.store, spec.agent, this.options.secretProviders, this.options.externalSecretProviders, void 0, signal);
 		this.assertStartOpen(signal);
+		if (agent.boundTeamId && agent.boundTeamId !== spec.teamId) throw new ServeRunError("invalid_spec", `agent "${spec.agent}" has a key bound to team ${agent.boundTeamId}; start the run with that team, or create a new agent with an enrollment token from team ${spec.teamId}`);
 		const id = `${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
 		const runDir = this.store.runDir(id);
 		const piDir = join(runDir, "pi");
@@ -8116,6 +8446,11 @@ var RunManager = class {
 					models: provider.models
 				}]))
 			});
+			try {
+				(this.options.symlinkImpl ?? symlinkSync)(this.store.piAuthJsonPath, join(piDir, "auth.json"));
+			} catch (cause) {
+				throw new ServeStoreError("io_error", "could not link subscription credentials into the run", { cause });
+			}
 			const entry = this.entrypoint();
 			logStream = createWriteStream(logPath, {
 				fd: openSync(logPath, "a", 384),
@@ -8470,6 +8805,62 @@ async function withServeLock(root, work, options) {
 		await held.release();
 	}
 }
+var ServeModelDiscoveryError = class extends Error {
+	name = "ServeModelDiscoveryError";
+	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 ServeModelDiscoveryError("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 ServeModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must be HTTP(S) without credentials, query, or fragment`, 400);
+	return parsed;
+}
+function discoveryFailure(providerId, failures) {
+	if (failures.some((failure) => failure.kind === "http" && (failure.status === 401 || failure.status === 403))) return new ServeModelDiscoveryError("discovery_unauthorized", `provider "${providerId}" rejected model discovery; check its API key`, 502);
+	if (failures.some((failure) => failure.kind === "network")) return new ServeModelDiscoveryError("discovery_unavailable", `provider "${providerId}" could not be reached for model discovery`, 502);
+	if (failures.some((failure) => failure.kind === "invalid_response")) return new ServeModelDiscoveryError("discovery_invalid_response", `provider "${providerId}" returned an invalid model response`, 502);
+	return new ServeModelDiscoveryError("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/serve/server.ts
 /**
@@ -8562,9 +8953,9 @@ function optionalString(body, field) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new ServeHttpError(400, "invalid_body", `"${field}" must be a non-empty string when present`);
 	return value.trim();
 }
-function stringArray(body, field) {
+function stringArray(body, field, options = {}) {
 	const value = body[field];
-	if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== "string" || item.length === 0)) throw new ServeHttpError(400, "invalid_body", `"${field}" must be a non-empty string array`);
+	if (!Array.isArray(value) || !options.allowEmpty && value.length === 0 || value.some((item) => typeof item !== "string" || item.length === 0)) throw new ServeHttpError(400, "invalid_body", `"${field}" must be ${options.allowEmpty ? "a" : "a non-empty"} string array`);
 	return value;
 }
 function requestOperationSignal(request, shutdownSignal) {
@@ -8622,7 +9013,11 @@ function buildServeServer(options) {
 	registerStatusRoute(app, options, requirePairedOrigin);
 	registerAgentRoutes(app, options, requirePairedOrigin);
 	registerProviderRoutes(app, options, requirePairedOrigin);
+	registerSubscriptionRoutes(app, options, requirePairedOrigin);
 	registerRunRoutes(app, options, requirePairedOrigin);
+	app.addHook("onClose", () => {
+		options.subscriptions.close();
+	});
 	app.setNotFoundHandler(async (_request, reply) => reply.code(404).send({
 		code: "not_found",
 		message: "Route is not available"
@@ -8680,6 +9075,7 @@ function registerStatusRoute(app, options, requirePairedOrigin) {
 		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)])),
 			runs: runViews(runs)
@@ -8698,11 +9094,11 @@ function registerAgentRoutes(app, options, requirePairedOrigin) {
 		const signal = requestOperationSignal(request, options.shutdownSignal);
 		const kind = requireString(body, "kind");
 		if (kind === "managed") {
-			const enrollmentToken = optionalString(body, "enrollmentToken");
+			if (body["apiUrl"] !== void 0) throw new ServeHttpError(400, "invalid_body", "managed agent registration uses the configured MoltNet API URL; apiUrl cannot be overridden");
 			const entry = await createManagedAgent(store, options.secrets, {
 				name: requireString(body, "name"),
 				apiUrl: options.defaultApiUrl,
-				...enrollmentToken ? { enrollmentToken } : {},
+				enrollmentToken: requireString(body, "enrollmentToken"),
 				signal
 			});
 			return reply.code(201).send(publicAgentView(store, entry.activation));
@@ -8740,16 +9136,106 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 		requirePairedOrigin(request);
 		return Object.fromEntries(Object.entries(store.readProviders()).map(([id, provider]) => [id, providerView(provider)]));
 	});
+	app.post("/v1/providers/:providerId/discover-models", async (request) => {
+		requirePairedOrigin(request);
+		const { providerId: rawProviderId } = request.params;
+		const providerId = assertProviderId(rawProviderId);
+		const provider = store.readProviders()[providerId];
+		if (!provider) throw new ServeHttpError(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: "serve_provider_secret_unavailable",
+				providerId
+			}, "Provider API key could not be resolved for model discovery");
+			throw new ServeHttpError(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: "serve_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: "serve_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: "serve_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: "serve_provider_discovery_truncated",
+			discoveredCount: result.discoveredCount,
+			providerId,
+			returnedCount: 500
+		}, "Provider model discovery result was truncated");
+		request.log.info({
+			code: "serve_provider_discovery_completed",
+			modelCount: result.models.length,
+			providerId
+		}, "Provider model discovery completed");
+		return { models: result.models };
+	});
 	app.put("/v1/providers/:providerId", async (request, reply) => {
 		requirePairedOrigin(request);
 		const { providerId: rawProviderId } = request.params;
 		const providerId = assertProviderId(rawProviderId);
 		const body = requireBody(request);
+		const baseUrl = requireString(body, "baseUrl");
+		parseProviderBaseUrl(baseUrl, providerId);
 		const entry = {
 			api: requireString(body, "api"),
-			baseUrl: requireString(body, "baseUrl"),
+			baseUrl,
 			envName: assertProviderEnvName(providerId, requireString(body, "envName")),
-			models: stringArray(body, "models")
+			models: stringArray(body, "models", { allowEmpty: true })
 		};
 		const apiKey = optionalString(body, "apiKey");
 		await serialize(async () => {
@@ -8774,6 +9260,28 @@ function runViews(runs) {
 		active: runs.isActive(record.id)
 	}));
 }
+function registerSubscriptionRoutes(app, options, requirePairedOrigin) {
+	app.get("/v1/subscriptions", async (request) => {
+		requirePairedOrigin(request);
+		return options.subscriptions.list();
+	});
+	app.post("/v1/subscriptions/:providerId/login", async (request, reply) => {
+		requirePairedOrigin(request);
+		const { providerId } = request.params;
+		const login = await options.subscriptions.start(providerId);
+		return reply.code(201).send(login);
+	});
+	app.get("/v1/subscriptions/:providerId/login", async (request) => {
+		requirePairedOrigin(request);
+		const { providerId } = request.params;
+		return options.subscriptions.status(providerId);
+	});
+	app.delete("/v1/subscriptions/:providerId/login", async (request) => {
+		requirePairedOrigin(request);
+		const { providerId } = request.params;
+		return options.subscriptions.cancel(providerId);
+	});
+}
 function registerRunRoutes(app, options, requirePairedOrigin) {
 	const { runs } = options;
 	app.get("/v1/runs", async (request) => {
@@ -8944,6 +9452,16 @@ function normalizeServeError(error) {
 		code: error.code,
 		message: error.message
 	};
+	if (error instanceof ServeSubscriptionError) return {
+		statusCode: error.code === "login_not_found" ? 404 : error.code === "provider_unknown" ? 404 : 400,
+		code: error.code,
+		message: error.message
+	};
+	if (error instanceof ServeModelDiscoveryError) return {
+		statusCode: error.statusCode,
+		code: error.code,
+		message: error.message
+	};
 	if (error instanceof ServeIdentityError) return {
 		statusCode: error.code === "agent_exists" ? 409 : 400,
 		code: error.code,
@@ -8952,7 +9470,7 @@ function normalizeServeError(error) {
 	return {
 		statusCode: 500,
 		code: "internal_error",
-		message: "Request failed"
+		message: "The local supervisor could not complete the request."
 	};
 }
 //#endregion
@@ -9009,6 +9527,10 @@ async function runServe(argv) {
 				const externalSecretProviders = createNodeSecretProviderRegistry();
 				const pairing = new PairingService();
 				const shutdownController = new AbortController();
+				const subscriptions = new ProviderLoginService({
+					authPath: store.piAuthJsonPath,
+					logger
+				});
 				const runs = new RunManager({
 					store,
 					secretProviders,
@@ -9019,9 +9541,11 @@ async function runServe(argv) {
 				const app = buildServeServer({
 					store,
 					secrets,
+					secretProviders,
 					externalSecretProviders,
 					pairing,
 					runs,
+					subscriptions,
 					allowedOrigins,
 					selfOrigin: `http://127.0.0.1:${port}`,
 					defaultApiUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.48.0",
+  "version": "0.49.1",
   "license": "AGPL-3.0-only",
   "type": "module",
   "description": "Universal MoltNet agent daemon host with a built-in Pi/Gondolin runtime and support for trusted operator-owned runtime modules. CLI: moltnet-agent.",
@@ -48,7 +48,8 @@
   },
   "dependencies": {
     "@earendil-works/gondolin": "^0.12.0",
-    "@earendil-works/pi-coding-agent": "0.84.4",
+    "@earendil-works/pi-ai": "0.79.4",
+    "@earendil-works/pi-coding-agent": "0.79.4",
     "@fastify/cors": "^11.0.0",
     "@fastify/helmet": "^13.0.1",
     "@fastify/otel": "^0.18.0",
@@ -82,10 +83,10 @@
     "pino-pretty": "^13.1.3",
     "proper-lockfile": "4.1.2",
     "typebox": "^1.2.8",
+    "@themoltnet/agent-runtime": "0.45.2",
     "@themoltnet/os-keyring": "0.3.0",
-    "@themoltnet/sdk": "0.140.0",
-    "@themoltnet/pi-runtime": "0.14.0",
-    "@themoltnet/agent-runtime": "0.45.2"
+    "@themoltnet/pi-runtime": "0.14.1",
+    "@themoltnet/sdk": "0.140.0"
   },
   "devDependencies": {
     "@types/proper-lockfile": "^4.1.4",
@@ -95,15 +96,15 @@
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.0.0",
     "@moltnet/agent-eval": "0.1.0",
-    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/crypto-service": "0.1.0",
     "@moltnet/execution-integrations": "0.1.0",
     "@moltnet/execution-plan": "0.1.0",
+    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/loopback-companion": "0.1.0",
+    "@moltnet/observability": "0.1.0",
     "@moltnet/models": "0.1.0",
-    "@moltnet/tasks": "0.1.0",
     "@moltnet/runtime-profiles": "0.1.0",
-    "@moltnet/observability": "0.1.0"
+    "@moltnet/tasks": "0.1.0"
   },
   "nx": {
     "projectType": "application",