@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/config.js

@@ -0,0 +1,427 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolvePaseoNodeEnv } from "./paseo-env.js";
+import { z } from "zod";
+import { expandTilde } from "../utils/path.js";
+import { loadPersistedConfig, LogFormatSchema, LogLevelSchema, } from "./persisted-config.js";
+import { ProviderOverrideSchema } from "./agent/provider-launch-config.js";
+import { AgentProviderSchema } from "@hyperdrive.bot/fleet-protocol/provider-manifest";
+import { hashDaemonPassword } from "./auth.js";
+import { resolveSpeechConfig } from "./speech/speech-config-resolver.js";
+import { mergeHostnames, parseHostnamesEnv } from "./hostnames.js";
+const DEFAULT_PORT = 6767;
+const DEFAULT_RELAY_ENDPOINT = "relay.paseo.sh:443";
+const DEFAULT_APP_BASE_URL = "https://app.paseo.sh";
+const DEFAULT_TRUSTED_PROXIES = ["loopback"];
+export function resolveBundledWebUiDistDir(moduleUrl = import.meta.url) {
+    const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+    if (path.basename(moduleDir) === "server" && path.basename(path.dirname(moduleDir)) === "src") {
+        return path.resolve(moduleDir, "..", "..", "dist", "server", "web-ui");
+    }
+    if (path.basename(moduleDir) === "server" &&
+        path.basename(path.dirname(moduleDir)) === "server" &&
+        path.basename(path.dirname(path.dirname(moduleDir))) === "dist") {
+        return path.resolve(moduleDir, "..", "web-ui");
+    }
+    return path.resolve(moduleDir, "web-ui");
+}
+const BUNDLED_WEB_UI_DIST_DIR = resolveBundledWebUiDistDir();
+function parseBooleanEnv(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
+function normalizeLogEnv(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value.trim().toLowerCase();
+}
+function resolveLogConfigFromEnv(env, persisted) {
+    const envLogLevel = LogLevelSchema.safeParse(normalizeLogEnv(env.PASEO_LOG_LEVEL));
+    const envLogFormat = LogFormatSchema.safeParse(normalizeLogEnv(env.PASEO_LOG_FORMAT));
+    if (!envLogLevel.success && !envLogFormat.success) {
+        return persisted.log;
+    }
+    return {
+        ...persisted.log,
+        ...(envLogLevel.success ? { level: envLogLevel.data } : {}),
+        ...(envLogFormat.success ? { format: envLogFormat.data } : {}),
+    };
+}
+const OptionalVoiceLlmProviderSchema = z
+    .union([z.string(), z.null(), z.undefined()])
+    .transform((value) => typeof value === "string" ? value.trim().toLowerCase() : null)
+    .pipe(z.union([AgentProviderSchema, z.null()]));
+function parseOptionalVoiceLlmProvider(value) {
+    const parsed = OptionalVoiceLlmProviderSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+export function extractProviderOverrides(providers) {
+    if (!providers) {
+        return undefined;
+    }
+    const providerOverrides = Object.entries(providers).flatMap(([providerId, provider]) => {
+        const parsed = ProviderOverrideSchema.safeParse(provider);
+        return parsed.success ? [[providerId, parsed.data]] : [];
+    });
+    return providerOverrides.length > 0 ? Object.fromEntries(providerOverrides) : undefined;
+}
+export function extractAgentProviderSettings(providerOverrides) {
+    if (!providerOverrides) {
+        return undefined;
+    }
+    const runtimeSettings = Object.entries(providerOverrides).flatMap(([providerId, provider]) => {
+        const parsedProviderId = AgentProviderSchema.safeParse(providerId);
+        // transport counts as a reason to keep the entry: an override that only sets
+        // transport (no command, no env) is the normal way to opt a provider into PTY.
+        if (!parsedProviderId.success || (!provider.command && !provider.env && !provider.transport)) {
+            return [];
+        }
+        return [
+            [
+                parsedProviderId.data,
+                {
+                    command: provider.command
+                        ? {
+                            mode: "replace",
+                            argv: provider.command,
+                        }
+                        : undefined,
+                    env: provider.env,
+                    transport: provider.transport,
+                },
+            ],
+        ];
+    });
+    return runtimeSettings.length > 0
+        ? Object.fromEntries(runtimeSettings)
+        : undefined;
+}
+function resolveTlsFromEnv(envValue, persistedValue, fallback) {
+    if (envValue !== undefined) {
+        return parseBooleanEnv(envValue) ?? false;
+    }
+    return persistedValue ?? fallback;
+}
+function resolveRelayConfig(input) {
+    const enabled = input.cliRelayEnabled ??
+        parseBooleanEnv(input.env.PASEO_RELAY_ENABLED) ??
+        input.persisted.daemon?.relay?.enabled ??
+        true;
+    const endpoint = input.env.PASEO_RELAY_ENDPOINT ??
+        input.persisted.daemon?.relay?.endpoint ??
+        DEFAULT_RELAY_ENDPOINT;
+    const publicEndpoint = input.env.PASEO_RELAY_PUBLIC_ENDPOINT ??
+        input.persisted.daemon?.relay?.publicEndpoint ??
+        endpoint;
+    const useTls = input.cliRelayUseTls ??
+        resolveTlsFromEnv(input.env.PASEO_RELAY_USE_TLS, input.persisted.daemon?.relay?.useTls, endpoint === DEFAULT_RELAY_ENDPOINT);
+    const publicUseTls = resolveTlsFromEnv(input.env.PASEO_RELAY_PUBLIC_USE_TLS, input.persisted.daemon?.relay?.publicUseTls, useTls);
+    return { enabled, endpoint, publicEndpoint, useTls, publicUseTls };
+}
+function resolveServiceProxyPublicBaseUrl(value) {
+    if (value === null) {
+        return null;
+    }
+    try {
+        return new URL(value).toString().replace(/\/$/, "");
+    }
+    catch {
+        throw new Error(`Invalid PASEO_SERVICE_PROXY_PUBLIC_BASE_URL: ${value}`);
+    }
+}
+function resolveServiceProxyConfig(env, persisted) {
+    const enabledShim = parseBooleanEnv(env.PASEO_SERVICE_PROXY_ENABLED) ?? persisted.daemon?.serviceProxy?.enabled;
+    // COMPAT(serviceProxyEnabled): added 2026-06-02, remove after 2026-12-02.
+    // `enabled=false` used to disable the separate service proxy listener. Localhost
+    // service proxying is now always enabled; this only suppresses optional layers.
+    const optionalLayersEnabled = enabledShim !== false;
+    const publicBaseUrl = optionalLayersEnabled
+        ? resolveServiceProxyPublicBaseUrl(env.PASEO_SERVICE_PROXY_PUBLIC_BASE_URL ??
+            persisted.daemon?.serviceProxy?.publicBaseUrl ??
+            null)
+        : null;
+    const standaloneListen = optionalLayersEnabled
+        ? (env.PASEO_SERVICE_PROXY_LISTEN ?? persisted.daemon?.serviceProxy?.listen ?? null)
+        : null;
+    return { publicBaseUrl, standaloneListen };
+}
+function resolveWebUiConfig(paseoHome, env, cli, persisted) {
+    const enabled = cli?.webUiEnabled ??
+        parseBooleanEnv(env.PASEO_WEB_UI_ENABLED) ??
+        persisted.features?.webUi?.enabled ??
+        false;
+    const rawDistDir = env.PASEO_WEB_UI_DIST_DIR ?? persisted.features?.webUi?.distDir;
+    const trimmedDistDir = rawDistDir?.trim();
+    const distDir = trimmedDistDir
+        ? path.resolve(path.isAbsolute(trimmedDistDir) ? trimmedDistDir : paseoHome, trimmedDistDir)
+        : BUNDLED_WEB_UI_DIST_DIR;
+    return {
+        enabled,
+        distDir,
+    };
+}
+function resolveVoiceLlmConfig(env, persisted) {
+    const envVoiceLlmProvider = parseOptionalVoiceLlmProvider(env.PASEO_VOICE_LLM_PROVIDER);
+    const persistedVoiceLlmProvider = parseOptionalVoiceLlmProvider(persisted.features?.voiceMode?.llm?.provider);
+    return {
+        provider: envVoiceLlmProvider ?? persistedVoiceLlmProvider ?? null,
+        providerExplicit: envVoiceLlmProvider !== null || persistedVoiceLlmProvider !== null,
+        model: persisted.features?.voiceMode?.llm?.model ?? null,
+    };
+}
+function resolveCorsAllowedOrigins(env, persisted) {
+    const envCorsOrigins = env.PASEO_CORS_ORIGINS
+        ? env.PASEO_CORS_ORIGINS.split(",").map((s) => s.trim())
+        : [];
+    const persistedCorsOrigins = persisted.daemon?.cors?.allowedOrigins ?? [];
+    return Array.from(new Set([...persistedCorsOrigins, ...envCorsOrigins].filter((s) => s.length > 0)));
+}
+/**
+ * Anything other than the two known environments degrades to "development".
+ * A typo in PASEO_PIPEDREAM_ENVIRONMENT must not stop the daemon from booting.
+ */
+const PipedreamEnvironmentSchema = z.enum(["development", "production"]).catch("development");
+/** The Expo dev server origin the app runs on locally (`npm run dev:app`). */
+const DEV_APP_ORIGIN = "http://localhost:8081";
+/**
+ * Origins Pipedream will accept its hosted connect popup from.
+ *
+ * Computed here rather than in the gateway so the gateway stays a pure function
+ * of its config. A malformed appBaseUrl only costs that one origin: it must not
+ * throw, because loadConfig runs on the boot path.
+ */
+function resolvePipedreamAllowedOrigins(input) {
+    const origins = [];
+    try {
+        origins.push(new URL(input.appBaseUrl).origin);
+    }
+    catch {
+        // Not a URL. The popup simply loses this origin.
+    }
+    origins.push(...input.corsAllowedOrigins);
+    if (input.isDev) {
+        origins.push(DEV_APP_ORIGIN);
+    }
+    return Array.from(new Set(origins.filter((origin) => origin.length > 0)));
+}
+/**
+ * Ingestion aggregator credentials, env-only by explicit decision for this
+ * epic: writing an aggregator's platform secret into ~/.paseo/config.json is a
+ * strictly worse posture than an env var, so there is no persisted path here
+ * and persisted-config.ts stays untouched.
+ */
+function resolveIngestionConfig(input) {
+    const { env } = input;
+    return {
+        pipedream: {
+            clientId: env.PASEO_PIPEDREAM_CLIENT_ID?.trim() || undefined,
+            clientSecret: env.PASEO_PIPEDREAM_CLIENT_SECRET?.trim() || undefined,
+            projectId: env.PASEO_PIPEDREAM_PROJECT_ID?.trim() || undefined,
+            environment: PipedreamEnvironmentSchema.parse(env.PASEO_PIPEDREAM_ENVIRONMENT?.trim()),
+            allowedOrigins: resolvePipedreamAllowedOrigins(input),
+        },
+        composio: {
+            apiKey: env.PASEO_COMPOSIO_API_KEY?.trim() || undefined,
+        },
+    };
+}
+function parseTrustedProxiesEnv(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = trimmed.toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return [];
+    }
+    return trimmed
+        .split(",")
+        .map((proxy) => proxy.trim())
+        .filter((proxy) => proxy.length > 0);
+}
+function resolveTrustedProxiesConfig(env, persisted) {
+    return (parseTrustedProxiesEnv(env.PASEO_TRUSTED_PROXIES) ??
+        persisted.daemon?.trustedProxies ??
+        DEFAULT_TRUSTED_PROXIES);
+}
+// PASEO_LISTEN can be:
+// - host:port (TCP)
+// - /path/to/socket (Unix socket)
+// - unix:///path/to/socket (Unix socket)
+// Default is TCP at 127.0.0.1:6767
+function resolveListenAddress(env, cli, persisted) {
+    return (cli?.listen ??
+        env.PASEO_LISTEN ??
+        persisted.daemon?.listen ??
+        `127.0.0.1:${env.PORT ?? DEFAULT_PORT}`);
+}
+function resolveTenantAuthConfig(env, persisted) {
+    const userPoolId = env.PASEO_TENANT_USER_POOL_ID?.trim();
+    const region = env.PASEO_TENANT_REGION?.trim();
+    if (userPoolId && region) {
+        const groups = env.PASEO_TENANT_ALLOWED_GROUPS?.split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        return {
+            userPoolId,
+            region,
+            clientId: env.PASEO_TENANT_CLIENT_ID?.trim() || undefined,
+            allowedGroups: groups && groups.length > 0 ? groups : undefined,
+        };
+    }
+    return persisted.daemon?.auth?.tenant;
+}
+function resolveAuthConfig(env, persisted) {
+    const tenant = resolveTenantAuthConfig(env, persisted);
+    const envPassword = env.PASEO_PASSWORD?.trim();
+    const password = envPassword ? hashDaemonPassword(envPassword) : persisted.daemon?.auth?.password;
+    if (!password && !tenant) {
+        return undefined;
+    }
+    return { ...(password ? { password } : {}), ...(tenant ? { tenant } : {}) };
+}
+function resolveWorktreesRoot(paseoHome, persisted) {
+    const configuredRoot = persisted.worktrees?.root?.trim();
+    if (!configuredRoot) {
+        return undefined;
+    }
+    const expandedRoot = expandTilde(configuredRoot);
+    return path.isAbsolute(expandedRoot)
+        ? path.resolve(expandedRoot)
+        : path.resolve(paseoHome, expandedRoot);
+}
+function resolveAppendSystemPrompt(persisted) {
+    return persisted.daemon?.appendSystemPrompt ?? "";
+}
+function resolveBrowserToolsEnabled(persisted) {
+    return persisted.daemon?.browserTools?.enabled ?? false;
+}
+/**
+ * The kanban column registry, or undefined when this daemon has never stored one.
+ * Undefined is meaningful — it is the signal the first connecting client uses to
+ * seed the daemon from its own board — so this deliberately has no `??` default.
+ */
+function resolveKanbanBoard(persisted) {
+    return persisted.daemon?.kanbanBoard;
+}
+/**
+ * A misconfigured staleness window falls back to the default rather than taking
+ * the daemon down.
+ *
+ * Epic Compatibility Requirement: the daemon starts even when reconciliation is
+ * misconfigured. A zero, negative or fractional value would otherwise either
+ * fail the config parse or make every item stale on every call, which is a read
+ * storm dressed as a setting. Mirrors `RECONCILE_STALE_MS`; the constant itself
+ * lives in `ingestion/reconcile/constants.ts` and is duplicated here only
+ * because importing it would drag the reconcile module into daemon startup.
+ */
+function resolveIngestionReconcile(persisted) {
+    const configured = persisted.daemon?.ingestionReconcileStaleMs;
+    const valid = typeof configured === "number" && Number.isInteger(configured) && configured > 0;
+    return {
+        // Default TRUE, unlike `autoArchiveAfterMerge`: reconciliation without the
+        // Story 6.2 wiring is inert, so the switch exists to turn it OFF.
+        ingestionReconcileEnabled: persisted.daemon?.ingestionReconcileEnabled ?? true,
+        ingestionReconcileStaleMs: valid ? configured : 60000,
+    };
+}
+function resolveStaticLoadConfigSettings(env, cli, persisted) {
+    return {
+        mcpEnabled: cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true,
+        mcpInjectIntoAgents: cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? true,
+        browserToolsEnabled: resolveBrowserToolsEnabled(persisted),
+        autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
+        // Spread rather than two inline `??` expressions: this function is already
+        // at the repo's complexity ceiling, and both keys are decided by one policy.
+        ...resolveIngestionReconcile(persisted),
+        appendSystemPrompt: resolveAppendSystemPrompt(persisted),
+        terminalProfiles: persisted.daemon?.terminalProfiles,
+        kanbanBoard: resolveKanbanBoard(persisted),
+        hostnames: mergeHostnames([
+            persisted.daemon?.hostnames,
+            parseHostnamesEnv(env.PASEO_HOSTNAMES ?? env.PASEO_ALLOWED_HOSTS),
+            cli?.hostnames,
+        ]),
+        trustedProxies: resolveTrustedProxiesConfig(env, persisted),
+        appBaseUrl: env.PASEO_APP_BASE_URL ?? persisted.app?.baseUrl ?? DEFAULT_APP_BASE_URL,
+    };
+}
+export function loadConfig(paseoHome, options) {
+    const env = options?.env ?? process.env;
+    const persisted = loadPersistedConfig(paseoHome);
+    const listen = resolveListenAddress(env, options?.cli, persisted);
+    const { mcpEnabled, mcpInjectIntoAgents, browserToolsEnabled, autoArchiveAfterMerge, ingestionReconcileEnabled, ingestionReconcileStaleMs, appendSystemPrompt, terminalProfiles, kanbanBoard, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, options?.cli, persisted);
+    const relay = resolveRelayConfig({
+        env,
+        persisted,
+        cliRelayEnabled: options?.cli?.relayEnabled,
+        cliRelayUseTls: options?.cli?.relayUseTls,
+    });
+    const serviceProxy = resolveServiceProxyConfig(env, persisted);
+    const webUi = resolveWebUiConfig(paseoHome, env, options?.cli, persisted);
+    const { openai, speech } = resolveSpeechConfig({
+        paseoHome,
+        env,
+        persisted,
+    });
+    const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    const corsAllowedOrigins = resolveCorsAllowedOrigins(env, persisted);
+    const isDev = resolvePaseoNodeEnv(env) === "development";
+    return {
+        listen,
+        paseoHome,
+        worktreesRoot: resolveWorktreesRoot(paseoHome, persisted),
+        corsAllowedOrigins,
+        hostnames,
+        trustedProxies,
+        mcpEnabled,
+        mcpInjectIntoAgents,
+        browserToolsEnabled,
+        autoArchiveAfterMerge,
+        ingestionReconcileEnabled,
+        ingestionReconcileStaleMs,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt,
+        terminalProfiles,
+        kanbanBoard,
+        mcpDebug: env.MCP_DEBUG === "1",
+        isDev,
+        agentStoragePath: path.join(paseoHome, "agents"),
+        staticDir: "public",
+        agentClients: {},
+        relayEnabled: relay.enabled,
+        relayEndpoint: relay.endpoint,
+        relayPublicEndpoint: relay.publicEndpoint,
+        relayUseTls: relay.useTls,
+        relayPublicUseTls: relay.publicUseTls,
+        serviceProxy,
+        webUi,
+        appBaseUrl,
+        auth: resolveAuthConfig(env, persisted),
+        openai,
+        speech,
+        voiceLlmProvider: voiceLlm.provider,
+        voiceLlmProviderExplicit: voiceLlm.providerExplicit,
+        voiceLlmModel: voiceLlm.model,
+        agentProviderSettings: extractAgentProviderSettings(providerOverrides),
+        metadataGeneration: persisted.agents?.metadataGeneration,
+        providerOverrides,
+        log: resolveLogConfigFromEnv(env, persisted),
+        ingestion: resolveIngestionConfig({ env, appBaseUrl, corsAllowedOrigins, isDev }),
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/server/server/connection-offer.d.ts

@@ -0,0 +1,20 @@
+import { type ConnectionOffer } from "@hyperdrive.bot/fleet-protocol/connection-offer";
+interface BuildOfferEndpointsArgs {
+    listenHost: string;
+    port: number;
+}
+export declare function buildOfferEndpoints({ listenHost, port }: BuildOfferEndpointsArgs): string[];
+export declare function createConnectionOfferV2(args: {
+    serverId: string;
+    daemonPublicKeyB64: string;
+    relay: {
+        endpoint: string;
+        useTls?: boolean;
+    };
+}): Promise<ConnectionOffer>;
+export declare function encodeOfferToFragmentUrl(args: {
+    offer: ConnectionOffer;
+    appBaseUrl: string;
+}): string;
+export {};
+//# sourceMappingURL=connection-offer.d.ts.map

package/dist/server/server/connection-offer.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import { ConnectionOfferV2Schema, } from "@hyperdrive.bot/fleet-protocol/connection-offer";
+export function buildOfferEndpoints({ listenHost, port }) {
+    const endpoints = [];
+    const isLoopbackHost = listenHost === "127.0.0.1" || listenHost === "localhost";
+    const isWildcardHost = listenHost === "0.0.0.0" || listenHost === "::" || listenHost === "[::]";
+    if (isWildcardHost) {
+        const lanIp = getPrimaryLanIp();
+        if (lanIp) {
+            endpoints.push(`${lanIp}:${port}`);
+        }
+    }
+    else if (!isLoopbackHost) {
+        endpoints.push(`${listenHost}:${port}`);
+    }
+    endpoints.push(`localhost:${port}`);
+    return dedupePreserveOrder(endpoints);
+}
+export async function createConnectionOfferV2(args) {
+    return ConnectionOfferV2Schema.parse({
+        v: 2,
+        serverId: args.serverId,
+        daemonPublicKeyB64: args.daemonPublicKeyB64,
+        relay: args.relay,
+    });
+}
+export function encodeOfferToFragmentUrl(args) {
+    const json = JSON.stringify(args.offer);
+    const encoded = Buffer.from(json, "utf8").toString("base64url");
+    return `${args.appBaseUrl.replace(/\/$/, "")}/#offer=${encoded}`;
+}
+function getPrimaryLanIp() {
+    const override = process.env.PASEO_PRIMARY_LAN_IP?.trim();
+    if (override)
+        return override;
+    const nets = os.networkInterfaces();
+    const names = Object.keys(nets).sort();
+    for (const name of names) {
+        const addrs = nets[name] ?? [];
+        for (const addr of addrs) {
+            if (addr.family === "IPv4" && !addr.internal) {
+                return addr.address;
+            }
+        }
+    }
+    return null;
+}
+function dedupePreserveOrder(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+//# sourceMappingURL=connection-offer.js.map

package/dist/server/server/daemon-config-store.d.ts

@@ -0,0 +1,78 @@
+export type { MutableDaemonConfig, MutableDaemonConfigPatch, } from "@hyperdrive.bot/fleet-protocol/messages";
+type MutableDaemonConfig = import("@hyperdrive.bot/fleet-protocol/messages").MutableDaemonConfig;
+type MutableDaemonConfigPatch = import("@hyperdrive.bot/fleet-protocol/messages").MutableDaemonConfigPatch;
+type ProviderOverride = import("./agent/provider-launch-config.js").ProviderOverride;
+interface LoggerLike {
+    child(bindings: Record<string, unknown>): LoggerLike;
+    info(...args: unknown[]): void;
+}
+type ConfigListener = (config: MutableDaemonConfig) => void;
+type FieldChangeHandler = (value: unknown) => void;
+/**
+ * Layer the mutable daemon config's per-provider settings on top of the base
+ * overrides read from `config.json`.
+ *
+ * WHY THE GHOST GUARD: `MutableDaemonConfig.providers` is seeded at daemon boot
+ * from whatever `agents.providers` held THEN (see createInitialMutableDaemonConfig)
+ * and, because `DaemonConfigStore.patch` deep-merges, a key can never be deleted
+ * from it for the life of the process. Those entries are *partial* by schema:
+ * typically just `{ enabled }` or `{ additionalModels }`, never `extends`.
+ *
+ * While the provider still exists in config.json that is harmless: the partial
+ * merges onto a complete base entry. The moment the provider is REMOVED from the
+ * file, the unguarded version of this loop resurrected it from the stale in-memory
+ * map as a standalone, `extends`-less custom provider, which `addDerivedProviders`
+ * then rejected, aborting the whole registry rebuild. Every subsequent
+ * `paseo provider reload` hit the same phantom, so ONE removed provider wedged all
+ * provider changes until a daemon restart (the only thing that re-seeds this map).
+ * Worse, this same function feeds `mergeMutableConfigIntoPersistedConfig`, so the
+ * next config write would resurrect the deleted provider back INTO config.json.
+ *
+ * Seen twice, four days apart, on the same box: `tmux-probe` (2026-08-23) and
+ * `ollama38` (2026-08-27), both reported as
+ * "Custom provider 'X' requires an extends value" for an X that was provably not
+ * in config.json. Dropping the orphan here fixes the reload, the write-back, and
+ * the mutable-patch path in one place, because all three funnel through here.
+ */
+export declare function applyMutableProviderConfigToOverrides(baseOverrides: Record<string, ProviderOverride> | undefined, mutableProviders: MutableDaemonConfig["providers"] | undefined): Record<string, ProviderOverride> | undefined;
+/**
+ * Which provider ids in `mutableProviders` are orphans relative to `baseOverrides`
+ * - i.e. exactly the ones {@link applyMutableProviderConfigToOverrides} drops.
+ *
+ * Exposed so a reload can also PRUNE them from the live store: leaving them in
+ * memory is no longer fatal, but it would silently re-apply a stale `enabled:
+ * false` if the same provider id were later added back to config.json.
+ */
+export declare function findOrphanedMutableProviderIds(baseOverrides: Record<string, ProviderOverride> | undefined, mutableProviders: MutableDaemonConfig["providers"] | undefined): string[];
+export declare class DaemonConfigStore {
+    private current;
+    private readonly paseoHome;
+    private readonly logger;
+    private readonly changeListeners;
+    private readonly fieldChangeHandlers;
+    constructor(paseoHome: string, initial: MutableDaemonConfig, logger?: LoggerLike);
+    get(): MutableDaemonConfig;
+    patch(partial: MutableDaemonConfigPatch): MutableDaemonConfig;
+    /**
+     * Drop per-provider runtime settings whose provider no longer exists in the
+     * base overrides on disk. Called by `provider reload`, which is the only moment
+     * the daemon learns that a provider was deleted from config.json.
+     *
+     * `patch()` cannot express this: it deep-merges, so a key here survives for the
+     * life of the process. Without a prune, adding the same provider id back to
+     * config.json later would silently inherit the dead entry's `enabled: false`.
+     *
+     * Deliberately in-memory only, with no `persistConfig`: these entries are a
+     * bootstrap artifact, never the source of truth, and
+     * `applyMutableProviderConfigToOverrides` already refuses to write them back
+     * out. Rewriting the user's config.json as a side effect of a *read* command
+     * would be the larger risk.
+     *
+     * Returns the ids actually removed so the caller can report them.
+     */
+    pruneOrphanedProviders(baseOverrides: Record<string, ProviderOverride> | undefined): string[];
+    onFieldChange(path: string, handler: FieldChangeHandler): () => void;
+    onChange(listener: ConfigListener): () => void;
+    private persistConfig;
+}
+//# sourceMappingURL=daemon-config-store.d.ts.map