diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 85d0a3c..cf6ec27 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,11 +25,5 @@ jobs:
       # ProxmoxSharp.Api client from the pinned schema via Kiota (Generated/ is
       # gitignored), then compiles everything; Test skips live integration tests
       # automatically without a secrets.env.
-      #
-      # GITHUB_PACKAGES_PAT authenticates the Fallout-build package feed (nuget.config)
-      # so the build/ project can restore Fallout.*. PACKAGES_PAT is a PAT with
-      # read:packages on the Fallout-build org.
       - name: Build & test (Fallout)
-        env:
-          GITHUB_PACKAGES_PAT: ${{ secrets.PACKAGES_PAT }}
         run: ./build.sh Test
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index d03ab3e..db9fc63 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -9,8 +9,7 @@ name: publish
 # stable publish. A push to main publishes a PRERELEASE (…-preview.N).
 #
 # Requires a nuget.org Trusted Publishing policy for this repo + this workflow file
-# (publish.yml), and the NUGET_USER secret (nuget.org profile name). GITHUB_PACKAGES_PAT
-# (from PACKAGES_PAT) only authenticates the Fallout-build feed for the build/ project.
+# (publish.yml), and the NUGET_USER secret (nuget.org profile name).
 on:
   push:
     branches: [main]
@@ -52,11 +51,8 @@ jobs:
         with:
           user: ${{ secrets.NUGET_USER }}
 
-      # Fallout Pack + Publish. GITHUB_PACKAGES_PAT authenticates the Fallout-build
-      # feed (build/ project restore); the push uses the short-lived nuget.org key.
+      # Fallout Pack + Publish; the push uses the short-lived nuget.org key.
       - name: Publish (Fallout → nuget.org)
-        env:
-          GITHUB_PACKAGES_PAT: ${{ secrets.PACKAGES_PAT }}
         run: |
           ARGS=(Publish --nuget-api-key "${{ steps.login.outputs.NUGET_API_KEY }}")
           if [[ -n "${{ steps.ver.outputs.suffix }}" ]]; then
diff --git a/build.sh b/build.sh
index f334ed5..955c89b 100755
--- a/build.sh
+++ b/build.sh
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # ProxmoxSharp build entrypoint (Fallout build). Requires the .NET 10 SDK on PATH
-# (see global.json) and, for restoring the Fallout.* build packages, GITHUB_PACKAGES_PAT
-# in the environment (a PAT with read:packages on the Fallout-build org; see nuget.config).
+# (see global.json). Everything, including the Fallout.* build packages, restores from
+# nuget.org with no credentials (see nuget.config).
 #
 #   ./build.sh                              # default target: Test
 #   ./build.sh Pack --version-suffix preview.42
diff --git a/build/_build.csproj b/build/_build.csproj
index 21b16fb..bc7f95c 100644
--- a/build/_build.csproj
+++ b/build/_build.csproj
@@ -4,7 +4,8 @@
        system, a NUKE successor). Restore/Compile/Test/Pack/Publish targets wrap
        the native `dotnet` toolchain; run via ./build.sh / ./build.ps1 or directly
        with `dotnet run` on this project (target as the arg). Fallout packages come
-       from the Fallout-build edge feed (see ../nuget.config); pinned for repro. -->
+       from nuget.org (10.4.0 stable; the 2026.1.0-preview edge pin was pulled from
+       the Fallout-build feed, same move as Homelab#390); pinned for repro. -->
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -20,9 +21,9 @@
 
   <ItemGroup>
     <!-- Pinned to the set used across the homelab (matches Homelab/build). Bump deliberately. -->
-    <PackageReference Include="Fallout.Build" Version="2026.1.0-preview.5.gd84fad5cd7" />
-    <PackageReference Include="Fallout.Common" Version="2026.1.0-preview.5.gd84fad5cd7" />
-    <PackageReference Include="Fallout.Components" Version="2026.1.0-preview.5.gd84fad5cd7" />
+    <PackageReference Include="Fallout.Build" Version="10.4.0" />
+    <PackageReference Include="Fallout.Common" Version="10.4.0" />
+    <PackageReference Include="Fallout.Components" Version="10.4.0" />
   </ItemGroup>
 
 </Project>
diff --git a/nuget.config b/nuget.config
index 7082505..089d507 100644
--- a/nuget.config
+++ b/nuget.config
@@ -2,28 +2,13 @@
 <configuration>
   <packageSources>
     <clear />
+    <!-- nuget.org ONLY. Fallout.* (the build system, used only by build/) is the 10.4.0
+         stable line there. It used to come from the Fallout-build GitHub Packages feed,
+         pinned to a 2026.1.0-preview edge build that has since been pulled; that feed
+         and the PACKAGES_PAT it needed are no longer in the build path. -->
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
-    <!-- Fallout (Chris's C#/.NET build system, NUKE successor) ships its edge
-         channel here — consumed ONLY by the Fallout build under build/. -->
-    <add key="fallout" value="https://nuget.pkg.github.com/Fallout-build/index.json" />
   </packageSources>
-  <packageSourceCredentials>
-    <!-- Fallout-build GitHub Packages needs auth. Token comes from the
-         GITHUB_PACKAGES_PAT env var (fine-grained PAT with read:packages);
-         never hard-coded — %VAR% is expanded by NuGet at restore. In CI it's
-         wired from the PACKAGES_PAT secret (see .github/workflows). -->
-    <fallout>
-      <add key="Username" value="ChrisonSimtian" />
-      <add key="ClearTextPassword" value="%GITHUB_PACKAGES_PAT%" />
-    </fallout>
-  </packageSourceCredentials>
-  <!-- Route Fallout.* exclusively to the Fallout-build edge feed (a more-specific
-       pattern than the nuget.org '*' catch-all, so it wins); everything else
-       (Microsoft.Kiota.Bundle, runtime deps) resolves from nuget.org. -->
   <packageSourceMapping>
-    <packageSource key="fallout">
-      <package pattern="Fallout.*" />
-    </packageSource>
     <packageSource key="nuget.org">
       <package pattern="*" />
     </packageSource>
diff --git a/src/ProxmoxSharp/ClusterSnapshot.cs b/src/ProxmoxSharp/ClusterSnapshot.cs
index 5f4e145..815b4f5 100644
--- a/src/ProxmoxSharp/ClusterSnapshot.cs
+++ b/src/ProxmoxSharp/ClusterSnapshot.cs
@@ -13,6 +13,15 @@ public sealed record NodeSnapshot
     public string? Status { get; init; }
     public long? MaxMem { get; init; }
     public long? Uptime { get; init; }
+
+    /// <summary>
+    /// False when the node could not be queried (offline, or PVE answered 595). Its
+    /// guests then come from <c>/cluster/resources</c> (status usually <c>"unknown"</c>),
+    /// and <see cref="Storage"/>/<see cref="Network"/> are empty because they were not read,
+    /// not because the node has none.
+    /// </summary>
+    public bool Reachable { get; init; } = true;
+
     public IReadOnlyList<GuestSnapshot> Lxc { get; init; } = [];
     public IReadOnlyList<GuestSnapshot> Qemu { get; init; } = [];
     public IReadOnlyList<StorageSnapshot> Storage { get; init; } = [];
diff --git a/src/ProxmoxSharp/ProxmoxDiscovery.cs b/src/ProxmoxSharp/ProxmoxDiscovery.cs
index 1a809e4..57ebcaa 100644
--- a/src/ProxmoxSharp/ProxmoxDiscovery.cs
+++ b/src/ProxmoxSharp/ProxmoxDiscovery.cs
@@ -1,4 +1,7 @@
+using Microsoft.Kiota.Abstractions;
 using ProxmoxSharp.Api;
+using ProxmoxSharp.Api.Cluster.Resources;
+using ProxmoxSharp.Api.Nodes;
 
 namespace ProxmoxSharp;
 
@@ -9,8 +12,20 @@ namespace ProxmoxSharp;
 /// for the earlier MCP-driven sweep, and the input the hub reconciles against the
 /// <c>/Infrastructure</c> shapes.
 /// </summary>
+/// <remarks>
+/// A node that is not online (powered off, asleep, partitioned) cannot answer
+/// per-node calls: PVE proxies them and returns HTTP 595 "no route to host". Such
+/// a node comes back with <see cref="NodeSnapshot.Reachable"/> = <c>false</c>, no
+/// storage/network, and its guests taken from the cluster-wide
+/// <c>/cluster/resources</c>, which still lists them from the shared config.
+/// Leaving those guests out instead would make a consumer read "absent" and plan
+/// to create them.
+/// </remarks>
 public sealed class ProxmoxDiscovery
 {
+    // PVE's proxy status when the target node is unreachable.
+    private const int NoRouteToNode = 595;
+
     private readonly ProxmoxApiClient _client;
 
     public ProxmoxDiscovery(ProxmoxApiClient client)
@@ -19,12 +34,16 @@ public ProxmoxDiscovery(ProxmoxApiClient client)
         _client = client;
     }
 
-    /// <summary>Builds a snapshot of the whole cluster (1 + 4×N read calls, N = node count).</summary>
+    /// <summary>
+    /// Builds a snapshot of the whole cluster (1 + 4×N read calls, N = online node
+    /// count, plus one <c>/cluster/resources</c> call if any node is unreachable).
+    /// </summary>
     public async Task<ClusterSnapshot> DiscoverAsync(CancellationToken cancellationToken = default)
     {
         var nodes = (await _client.Nodes.GetAsNodesGetResponseAsync(cancellationToken: cancellationToken)
             .ConfigureAwait(false))?.Data ?? [];
 
+        List<ResourcesGetResponse_data>? clusterGuests = null;
         var snapshots = new List<NodeSnapshot>(nodes.Count);
         foreach (var node in nodes)
         {
@@ -33,57 +52,114 @@ public async Task<ClusterSnapshot> DiscoverAsync(CancellationToken cancellationT
                 continue;
             }
 
-            var nodeBuilder = _client.Nodes[node.Node];
-
-            var lxc = (await nodeBuilder.Lxc.GetAsLxcGetResponseAsync(cancellationToken: cancellationToken)
-                .ConfigureAwait(false))?.Data ?? [];
-            var qemu = (await nodeBuilder.Qemu.GetAsQemuGetResponseAsync(cancellationToken: cancellationToken)
-                .ConfigureAwait(false))?.Data ?? [];
-            var storage = (await nodeBuilder.Storage.GetAsStorageGetResponseAsync(cancellationToken: cancellationToken)
-                .ConfigureAwait(false))?.Data ?? [];
-            var network = (await nodeBuilder.Network.GetAsNetworkGetResponseAsync(cancellationToken: cancellationToken)
-                .ConfigureAwait(false))?.Data ?? [];
-
-            snapshots.Add(new NodeSnapshot
+            NodeSnapshot? snapshot = null;
+            // A missing status is still tried: the 595 catch covers it if the node is down.
+            if (node.Status is not (NodesGetResponse_data_status.Offline or NodesGetResponse_data_status.Unknown))
             {
-                Node = node.Node,
-                Status = node.Status?.ToString(),
-                MaxMem = node.Maxmem,
-                Uptime = node.Uptime,
-                Lxc = lxc.Select(g => new GuestSnapshot
-                {
-                    VmId = g.Vmid,
-                    Name = g.Name,
-                    Status = g.Status?.ToString(),
-                    MaxMem = g.Maxmem,
-                    Cores = g.Cpus is { } c ? (int)c : null,
-                    Tags = g.Tags,
-                }).ToList(),
-                Qemu = qemu.Select(g => new GuestSnapshot
+                try
                 {
-                    VmId = g.Vmid,
-                    Name = g.Name,
-                    Status = g.Status?.ToString(),
-                    MaxMem = g.Maxmem,
-                    Cores = g.Cpus is { } c ? (int)c : null,
-                    Tags = g.Tags,
-                }).ToList(),
-                Storage = storage.Select(s => new StorageSnapshot
+                    snapshot = await DiscoverOnlineNodeAsync(node, cancellationToken).ConfigureAwait(false);
+                }
+                catch (ApiException ex) when (ex.ResponseStatusCode == NoRouteToNode)
                 {
-                    Storage = s.Storage,
-                    Type = s.Type,
-                    Active = s.Active,
-                    Content = s.Content,
-                }).ToList(),
-                Network = network.Select(n => new NetworkSnapshot
-                {
-                    Iface = n.Iface,
-                    Type = n.Type?.ToString(),
-                    Address = n.Address,
-                }).ToList(),
-            });
+                    // Went away between the node list and its own calls: treat as offline.
+                }
+            }
+
+            if (snapshot is null)
+            {
+                clusterGuests ??= await ClusterGuestsAsync(cancellationToken).ConfigureAwait(false);
+                snapshot = UnreachableNode(node, clusterGuests);
+            }
+
+            snapshots.Add(snapshot);
         }
 
         return new ClusterSnapshot { Nodes = snapshots };
     }
+
+    private async Task<NodeSnapshot> DiscoverOnlineNodeAsync(NodesGetResponse_data node, CancellationToken cancellationToken)
+    {
+        var nodeBuilder = _client.Nodes[node.Node];
+
+        var lxc = (await nodeBuilder.Lxc.GetAsLxcGetResponseAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false))?.Data ?? [];
+        var qemu = (await nodeBuilder.Qemu.GetAsQemuGetResponseAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false))?.Data ?? [];
+        var storage = (await nodeBuilder.Storage.GetAsStorageGetResponseAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false))?.Data ?? [];
+        var network = (await nodeBuilder.Network.GetAsNetworkGetResponseAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false))?.Data ?? [];
+
+        return new NodeSnapshot
+        {
+            Node = node.Node!,
+            Status = node.Status?.ToString(),
+            MaxMem = node.Maxmem,
+            Uptime = node.Uptime,
+            Lxc = lxc.Select(g => new GuestSnapshot
+            {
+                VmId = g.Vmid,
+                Name = g.Name,
+                Status = g.Status?.ToString(),
+                MaxMem = g.Maxmem,
+                Cores = g.Cpus is { } c ? (int)c : null,
+                Tags = g.Tags,
+            }).ToList(),
+            Qemu = qemu.Select(g => new GuestSnapshot
+            {
+                VmId = g.Vmid,
+                Name = g.Name,
+                Status = g.Status?.ToString(),
+                MaxMem = g.Maxmem,
+                Cores = g.Cpus is { } c ? (int)c : null,
+                Tags = g.Tags,
+            }).ToList(),
+            Storage = storage.Select(s => new StorageSnapshot
+            {
+                Storage = s.Storage,
+                Type = s.Type,
+                Active = s.Active,
+                Content = s.Content,
+            }).ToList(),
+            Network = network.Select(n => new NetworkSnapshot
+            {
+                Iface = n.Iface,
+                Type = n.Type?.ToString(),
+                Address = n.Address,
+            }).ToList(),
+        };
+    }
+
+    // Answered by whichever node we are talking to, from the shared cluster config,
+    // so it lists guests on offline nodes too (with status "unknown").
+    private async Task<List<ResourcesGetResponse_data>> ClusterGuestsAsync(CancellationToken cancellationToken) =>
+        (await _client.Cluster.Resources.GetAsResourcesGetResponseAsync(
+                rc => rc.QueryParameters.TypeAsGetTypeQueryParameterType = GetTypeQueryParameterType.Vm,
+                cancellationToken).ConfigureAwait(false))?.Data ?? [];
+
+    private static NodeSnapshot UnreachableNode(NodesGetResponse_data node, List<ResourcesGetResponse_data> clusterGuests)
+    {
+        var hosted = clusterGuests.Where(r => string.Equals(r.Node, node.Node, StringComparison.Ordinal)).ToList();
+        return new NodeSnapshot
+        {
+            Node = node.Node!,
+            Status = node.Status?.ToString(),
+            MaxMem = node.Maxmem,
+            Uptime = node.Uptime,
+            Reachable = false,
+            Lxc = hosted.Where(r => r.Type == ResourcesGetResponse_data_type.Lxc).Select(FromResource).ToList(),
+            Qemu = hosted.Where(r => r.Type == ResourcesGetResponse_data_type.Qemu).Select(FromResource).ToList(),
+        };
+    }
+
+    private static GuestSnapshot FromResource(ResourcesGetResponse_data r) => new()
+    {
+        VmId = r.Vmid,
+        Name = r.Name,
+        Status = r.Status,
+        MaxMem = r.Maxmem,
+        Cores = r.Maxcpu is { } c ? (int)c : null,
+        Tags = r.Tags,
+    };
 }
diff --git a/src/ProxmoxSharp/ProxmoxSharp.csproj b/src/ProxmoxSharp/ProxmoxSharp.csproj
index 8696ee7..ab66b1f 100644
--- a/src/ProxmoxSharp/ProxmoxSharp.csproj
+++ b/src/ProxmoxSharp/ProxmoxSharp.csproj
@@ -10,7 +10,7 @@
          Bumped to 0.2.0 so the active 0.2.0-preview.N line outranks the earlier
          0.1.0 stable in NuGet ordering — a `0.1.0-preview.*` float would otherwise
          resolve the stale 0.1.0 stable (prereleases sort below their release). -->
-    <VersionPrefix>0.2.1</VersionPrefix>
+    <VersionPrefix>0.2.2</VersionPrefix>
     <!-- Public nuget.org ID uses the reserved Chrison.* prefix (the bare
          'ProxmoxSharp' ID is taken on nuget.org by an unrelated project).
          AssemblyName/RootNamespace stay 'ProxmoxSharp' (project name) so
diff --git a/tests/ProxmoxSharp.Tests/DiscoveryOfflineNodeTests.cs b/tests/ProxmoxSharp.Tests/DiscoveryOfflineNodeTests.cs
new file mode 100644
index 0000000..f9df0a3
--- /dev/null
+++ b/tests/ProxmoxSharp.Tests/DiscoveryOfflineNodeTests.cs
@@ -0,0 +1,128 @@
+using System.Net;
+using System.Text;
+using Microsoft.Kiota.Abstractions.Authentication;
+using Microsoft.Kiota.Http.HttpClientLibrary;
+using ProxmoxSharp.Api;
+using Xunit;
+
+namespace ProxmoxSharp.Tests;
+
+/// <summary>
+/// Issue #24: one node of the cluster offline (the homelab's Wake-on-LAN desktop-01
+/// sleeps most of the time). PVE answers per-node calls for it with HTTP 595, which
+/// used to throw out of <see cref="ProxmoxDiscovery.DiscoverAsync"/>. Discovery must
+/// return the rest, and still list the offline node's guests (from /cluster/resources)
+/// so a consumer never reads them as absent.
+/// </summary>
+public class DiscoveryOfflineNodeTests
+{
+    private const string ClusterResources = """
+        {"data":[
+          {"type":"lxc","vmid":100,"node":"pve1","name":"forgejo","status":"running","maxmem":2147483648,"maxcpu":2},
+          {"type":"lxc","vmid":4001,"node":"pve2","name":"monitoring","status":"unknown","maxmem":4294967296,"maxcpu":4,"tags":"iac;monitoring"},
+          {"type":"qemu","vmid":1001,"node":"pve2","name":"plex-vm","status":"unknown","maxmem":8589934592,"maxcpu":4}
+        ]}
+        """;
+
+    // pve1 answers everything; pve2 answers nothing but 595, like a sleeping node.
+    // Records every path so tests can assert which calls were (not) made.
+    private sealed class StubHandler(string nodesJson) : HttpMessageHandler
+    {
+        public List<string> Paths { get; } = [];
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            var path = request.RequestUri!.AbsolutePath.TrimEnd('/');
+            Paths.Add(path + request.RequestUri.Query);
+
+            if (path.Contains("/nodes/pve2/"))
+            {
+                return Task.FromResult(new HttpResponseMessage((HttpStatusCode)595)
+                {
+                    Content = new StringContent("", Encoding.UTF8, "text/plain"),
+                    ReasonPhrase = "No route to host",
+                });
+            }
+
+            var json = path switch
+            {
+                var p when p.EndsWith("/nodes") => nodesJson,
+                var p when p.EndsWith("/cluster/resources") => ClusterResources,
+                var p when p.EndsWith("/pve1/lxc") =>
+                    """{"data":[{"vmid":100,"name":"forgejo","status":"running","maxmem":2147483648,"cpus":2}]}""",
+                _ => """{"data":[]}""",
+            };
+            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(json, Encoding.UTF8, "application/json"),
+            });
+        }
+    }
+
+    private static ProxmoxApiClient Client(HttpMessageHandler handler) =>
+        new(new HttpClientRequestAdapter(new AnonymousAuthenticationProvider(), httpClient: new HttpClient(handler))
+        {
+            BaseUrl = "https://proxmox.test/api2/json",
+        });
+
+    private static void AssertOfflineNodeFromClusterResources(ClusterSnapshot snapshot)
+    {
+        Assert.Equal(["pve1", "pve2"], snapshot.Nodes.Select(n => n.Node));
+
+        var pve1 = snapshot.Nodes[0];
+        Assert.True(pve1.Reachable);
+        Assert.Equal(100, Assert.Single(pve1.Lxc).VmId);
+
+        var pve2 = snapshot.Nodes[1];
+        Assert.False(pve2.Reachable);
+        var ct = Assert.Single(pve2.Lxc);
+        Assert.Equal(4001, ct.VmId);
+        Assert.Equal("monitoring", ct.Name);
+        Assert.Equal("unknown", ct.Status);
+        Assert.Equal(4294967296, ct.MaxMem);
+        Assert.Equal(4, ct.Cores);
+        Assert.Equal("iac;monitoring", ct.Tags);
+        Assert.Equal(1001, Assert.Single(pve2.Qemu).VmId);
+        Assert.Empty(pve2.Storage);
+        Assert.Empty(pve2.Network);
+    }
+
+    [Fact]
+    public async Task Offline_node_is_not_queried_and_its_guests_come_from_cluster_resources()
+    {
+        var handler = new StubHandler("""
+            {"data":[{"node":"pve1","status":"online","maxmem":34359738368,"uptime":12345},
+                     {"node":"pve2","status":"offline"}]}
+            """);
+
+        var snapshot = await new ProxmoxDiscovery(Client(handler)).DiscoverAsync();
+
+        AssertOfflineNodeFromClusterResources(snapshot);
+        Assert.DoesNotContain(handler.Paths, p => p.Contains("/nodes/pve2/"));
+        Assert.Contains(handler.Paths, p => p.Contains("/cluster/resources") && p.Contains("type=vm"));
+    }
+
+    [Fact]
+    public async Task Node_listed_online_that_answers_595_is_treated_as_offline()
+    {
+        // The node went to sleep between /nodes and its own calls.
+        var handler = new StubHandler("""
+            {"data":[{"node":"pve1","status":"online"},{"node":"pve2","status":"online"}]}
+            """);
+
+        var snapshot = await new ProxmoxDiscovery(Client(handler)).DiscoverAsync();
+
+        AssertOfflineNodeFromClusterResources(snapshot);
+    }
+
+    [Fact]
+    public async Task All_nodes_online_makes_no_cluster_resources_call()
+    {
+        var handler = new StubHandler("""{"data":[{"node":"pve1","status":"online"}]}""");
+
+        var snapshot = await new ProxmoxDiscovery(Client(handler)).DiscoverAsync();
+
+        Assert.True(Assert.Single(snapshot.Nodes).Reachable);
+        Assert.DoesNotContain(handler.Paths, p => p.Contains("/cluster/resources"));
+    }
+}