@camstack/server 1.2.543 → 1.2.545

package/dist/agent/agent-hub-registration.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentHubRegistration = createAgentHubRegistration;
+/**
+ * The agent's upward capability registration (D3), bound to the mesh join.
+ *
+ * The hub forgets an agent — its join AND its registration — on every
+ * `$node.disconnected` the HUB sees. That event is not symmetric: Moleculer
+ * marks a node offline on gossip from a third node, on a failed write, on a
+ * heartbeat timeout, and the agent, whose own view of the hub never broke,
+ * sees none of it. On 2026-10-14 (the D848 rollout) the hub flapped
+ * little-unraid and the Mac offline/online every 2–6 s for ~35 min while older
+ * agents still gossiped about them; each flap wiped the agent's capabilities
+ * on the hub, the agent re-joined (its next call came back "not
+ * authenticated") but never re-registered, and both stayed online with ZERO
+ * capabilities until a manual restart.
+ *
+ * So the registration follows the JOIN, not the agent's own `$node.connected`:
+ *  - every join that settles in a state that lets calls through re-sends the
+ *    complete manifest — a join runs exactly when the hub's view of this agent
+ *    was reset (a new connection, or the hub said it lost us);
+ *  - a registration the hub refuses as "cluster secret mismatch" while THIS
+ *    connection's join proved the secret is not a mismatch: the hub forgot the
+ *    join. The agent joins again, and that join re-registers;
+ *  - the hub may ask for it (`$agent.requestRegistration`, sent on the hub's
+ *    own `$node.connected`), which closes the window in which the agent makes
+ *    no call that could tell it the hub forgot.
+ *
+ * Each send is ONE atomic `$hub.registerNode` carrying the full set; sends are
+ * coalesced (one in flight, at most one queued, the manifest built when it
+ * goes). Nothing waits on a timer: the triggers are events, the retry is the ack.
+ */
+const system_1 = require("@camstack/system");
+/** States in which a call to the hub is refused locally — nothing to send. */
+const BLOCKING = new Set(['secret-mismatch', 'hub-unverified']);
+function createAgentHubRegistration(opts) {
+    let waiting = false;
+    let sending = false;
+    let queuedReason = null;
+    const onRefused = (err) => {
+        if (!(0, system_1.isClusterSecretMismatchError)(err))
+            return; // aborted: shutting down
+        if (opts.join.client.state === 'authenticated') {
+            // This connection's join PROVED the secret, so the hub did not refuse
+            // the secret — it forgot the join (it saw this node disconnect). Join
+            // again; the settled join re-registers.
+            opts.log('[register-node] the hub refused the registration although this connection proved the cluster secret — it has forgotten the join; joining again');
+            opts.join.rejoin();
+            return;
+        }
+        opts.onSecretRefused?.(err);
+    };
+    const send = (reason) => {
+        if (sending) {
+            queuedReason = reason;
+            return;
+        }
+        sending = true;
+        const manifest = opts.buildManifest();
+        const bindings = manifest.addons.reduce((n, a) => n + a.capabilities.length, 0);
+        // Each attempt resolves the CURRENT broker: a retry that outlives a
+        // `reconnect()` must not keep calling the stopped one.
+        const broker = {
+            call: (action, params, callOpts) => opts.broker().call(action, params, callOpts),
+        };
+        (0, system_1.callRegisterNodeWithRetry)(broker, manifest, {
+            target: 'hub',
+            ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+            log: opts.log,
+        })
+            .then(() => {
+            opts.log(`[register-node] the hub acked this node's capabilities: ${manifest.addons.length} addon(s), ${bindings} binding(s) (${reason})`);
+            opts.onAcked?.();
+        })
+            .catch(onRefused)
+            .finally(() => {
+            sending = false;
+            const next = queuedReason;
+            queuedReason = null;
+            if (next !== null)
+                trigger(next);
+        });
+    };
+    const trigger = (reason) => {
+        // A send already waiting for the join builds its manifest when it goes.
+        if (waiting)
+            return;
+        waiting = true;
+        opts.join.client.whenCallable().then(() => {
+            waiting = false;
+            send(reason);
+        }, () => {
+            // Blocked (mismatch / unverified hub) or the join is still pending:
+            // the next settled join sends it (`onJoinSettled`).
+            waiting = false;
+        });
+    };
+    return {
+        trigger,
+        onJoinSettled(state) {
+            if (BLOCKING.has(state))
+                return;
+            // Every settled join means the hub's view of this node was reset (a new
+            // connection, or the hub said it lost us): the full set goes again.
+            trigger(`join settled: ${state}`);
+        },
+    };
+}

package/dist/agent/agent-mesh-join.js

@@ -49,6 +49,14 @@ function createAgentMeshJoin(opts) {
             opts.log?.(`mesh inbound: node "${nodeId}" is calling without having authenticated — ` +
                 `tolerated while this agent has no cluster secret (first call: ${action})`);
         },
+        // D848: what the hub sent before the join settled is held, then decided — said here.
+        onHoldReport: (r) => {
+            const what = `${r.events} hub event(s) and ${r.calls} hub call(s) held ${r.heldForMs} ms before the mesh join settled`;
+            const overflow = r.overflow > 0 ? `; ${r.overflow} more refused because the hold was full` : '';
+            opts.log?.(r.outcome === 'delivered'
+                ? `[mesh-join] ${what}: delivered${overflow}`
+                : `[mesh-join] ${what}: REFUSED (join ${r.reason})${overflow}`);
+        },
     });
     const client = new system_1.MeshJoinClient({
         nodeId: opts.nodeId,
@@ -77,6 +85,10 @@ function createAgentMeshJoin(opts) {
         void runJoin();
     };
     const joinMiddleware = client.middleware(rejoin);
+    const eventScope = (0, system_1.createAgentEventScope)({
+        hubNodeId: HUB_NODE_ID,
+        ...(opts.log !== undefined ? { log: opts.log } : {}),
+    });
     const inboundMiddleware = (0, system_1.createMeshAccessMiddleware)({
         ownNodeId: opts.nodeId,
         authenticator,
@@ -95,7 +107,12 @@ function createAgentMeshJoin(opts) {
         client,
         authenticator,
         middleware: joinMiddleware,
-        middlewares: [inboundMiddleware, joinMiddleware],
+        eventScope,
+        middlewares: [inboundMiddleware, joinMiddleware, eventScope.middleware],
+        rejoin() {
+            if (connected)
+                rejoin();
+        },
         attach(broker) {
             broker.localBus.on('$node.connected', (data) => {
                 if (nodeIdOf(data) !== HUB_NODE_ID)

package/dist/agent/agent-service.js

@@ -584,6 +584,20 @@ function createAgentService(deps) {
                     return { success: true, addonId, pid: result.pid };
                 },
             },
+            /**
+             * The hub asks for this node's complete capability set (sent on the
+             * hub's `$node.connected`). Answers at once; the registration itself
+             * goes out through the atomic `$hub.registerNode` (D3), after a fresh
+             * mesh join when the hub has forgotten this node's.
+             */
+            requestRegistration: {
+                handler() {
+                    if (deps.requestRegistration === undefined)
+                        return { ok: false };
+                    deps.requestRegistration();
+                    return { ok: true };
+                },
+            },
             /**
              * D3 subtree aggregation: a forked group-runner child calls this action
              * to deliver its complete capability manifest to the agent. The agent

package/dist/agent/main.js

@@ -44,6 +44,7 @@ const package_dir_utils_js_1 = require("../core/addon/package-dir-utils.js");
 const single_copy_cleanup_runner_js_1 = require("../single-copy-cleanup-runner.js");
 const addon_scan_js_1 = require("./addon-scan.js");
 const agent_addon_updates_js_1 = require("./agent-addon-updates.js");
+const agent_hub_registration_js_1 = require("./agent-hub-registration.js");
 const agent_mesh_join_js_1 = require("./agent-mesh-join.js");
 const agent_config_js_1 = require("./agent-config.js");
 const agent_mesh_enroll_js_1 = require("./agent-mesh-enroll.js");
@@ -177,8 +178,6 @@ async function startAgent(configPath) {
     // effect through `reconnect()` below, which re-reads the file.
     let currentSecret = config.secret ?? null;
     let joinState = 'pending';
-    /** A registration waited for a join that had not settled; the join re-fires it. */
-    let registrationDeferred = false;
     const meshJoin = (0, agent_mesh_join_js_1.createAgentMeshJoin)({
         nodeId: config.nodeId,
         secret: () => currentSecret,
@@ -195,9 +194,9 @@ async function startAgent(configPath) {
             else if (hubConnectionStateOverride === 'secret-mismatch') {
                 hubConnectionStateOverride = null;
             }
-            const blocking = state === 'secret-mismatch' || state === 'hub-unverified';
-            if (!blocking && registrationDeferred)
-                triggerUpwardRegistration();
+            // Every settled join re-sends the full manifest (D3, 2026-10-14): a join
+            // runs exactly when the hub's view of this node was reset.
+            registration.onJoinSettled(state);
             if (state === 'no-secret') {
                 consoleLogger.warn("no cluster secret configured — the hub tolerates this agent only while its System → Cluster is in Transition. Copy the hub's cluster secret into this agent's setup");
             }
@@ -255,9 +254,8 @@ async function startAgent(configPath) {
             ...(currentMeshTls !== null ? { meshTls: currentMeshTls } : {}),
         });
         meshJoin.attach(broker);
-        // The boot-time `$node.connected` listeners belong to the old broker: let
-        // the next settled join on this one re-send the manifest (D802).
-        registrationDeferred = true;
+        // The new broker's hub connection runs a join, and its settle re-sends
+        // the manifest (`registration.onJoinSettled`).
         await broker.start();
         console.log('[Agent] Reconnected successfully');
     };
@@ -385,46 +383,32 @@ async function startAgent(configPath) {
             : { name: rootPackage.name, version: rootPackage.version });
     }
     /**
-     * Fire (or re-fire) the upward `$hub.registerNode` registration carrying
-     * the agent's complete subtree union. Called:
-     *   - after initial addon loading completes
-     *   - on every `$agent.registerNode` from a child
-     *   - on hub reconnect (via `$node.connected`)
+     * The upward `$hub.registerNode` registration carrying the agent's complete
+     * subtree union (`agent-hub-registration.ts`). Sent:
+     *   - once boot has loaded every addon (`registration.ready()`);
+     *   - on every `$agent.registerNode` from a child, and on `$agent.reload`;
+     *   - on every mesh join that settles — a new hub connection, or the hub
+     *     saying it lost this node — and when the hub asks for it
+     *     (`$agent.requestRegistration`, on the hub's own `$node.connected`).
+     * D802: never before the join lets calls to the hub through, and the
+     * manifest is built AFTER the join, so it carries the legacy hash only for a
+     * hub that needs it.
      */
-    function triggerUpwardRegistration() {
-        // D802: the manifest goes to the hub only once the mesh join has settled —
-        // never to a node that could not prove it is the hub — and it is built
-        // AFTER the join, so it carries the legacy hash only for a hub that needs it.
-        meshJoin.client.whenCallable().then(() => {
-            registrationDeferred = false;
-            sendUpwardRegistration();
-        }, () => {
-            // Blocked (mismatch / unverified hub) or the join is still pending:
-            // the next settled join re-fires it (`onState`).
-            registrationDeferred = true;
-        });
-    }
-    function sendUpwardRegistration() {
-        (0, system_1.callRegisterNodeWithRetry)(broker, aggregateManifest(), {
-            target: 'hub',
-            signal: registerAbortController.signal,
-            log: (msg) => console.log(`[Agent] ${msg}`),
-        })
-            .then(() => {
-            // The hub acked the manifest — the agent reached its registered state.
-            // Run the single-copy GC sweep once (first ack only; no-op after).
-            confirmAgentBootHealthy();
-        })
-            .catch((err) => {
-            if ((0, system_1.isClusterSecretMismatchError)(err)) {
-                consoleLogger.error("hub registration rejected: cluster secret mismatch — enter the hub's cluster secret (System → Cluster) in this agent's setup (agent.json) and restart the agent");
-                // Surface the mismatch in the UI status.
-                hubConnectionStateOverride = 'secret-mismatch';
-                return;
-            }
-            // abort (shutdown) — preserve prior void behaviour: ignore.
-        });
-    }
+    const registration = (0, agent_hub_registration_js_1.createAgentHubRegistration)({
+        join: meshJoin,
+        buildManifest: () => aggregateManifest(),
+        broker: () => broker,
+        signal: registerAbortController.signal,
+        log: (msg) => console.log(`[Agent] ${msg}`),
+        // The hub acked the manifest — the agent reached its registered state.
+        // Run the single-copy GC sweep once (first ack only; no-op after).
+        onAcked: () => confirmAgentBootHealthy(),
+        onSecretRefused: () => {
+            consoleLogger.error("hub registration rejected: cluster secret mismatch — enter the hub's cluster secret (System → Cluster) in this agent's setup (agent.json) and restart the agent");
+            // Surface the mismatch in the UI status.
+            hubConnectionStateOverride = 'secret-mismatch';
+        },
+    });
     const consoleLogger = {
         info: (msg) => console.log(`[Agent] ${msg}`),
         warn: (msg) => console.warn(`[Agent] ${msg}`),
@@ -543,14 +527,19 @@ async function startAgent(configPath) {
         // so the hub's `CapRouteResolver` can route to what this node now has.
         // Hung on the existing `$agent.reload` trigger; no timer (D3).
         reconcileNodeRegistration: () => {
-            triggerUpwardRegistration();
+            registration.trigger('addons reloaded');
+        },
+        // The hub saw this node (re)connect and asks for its capability set —
+        // the hub may have dropped it on a disconnect this agent never saw.
+        requestRegistration: () => {
+            registration.trigger('the hub asked');
         },
         // D3 subtree aggregation: when a group-runner child delivers its manifest
         // via `$agent.registerNode`, merge it into the local subtree registry and
         // immediately re-register the complete union with the hub.
         onChildRegistered: (params) => {
             subtree.registerNode(params);
-            triggerUpwardRegistration();
+            registration.trigger(`child ${params.nodeId} registered`);
         },
         expectedClusterSecretHash: config.secret ? (0, system_1.hashClusterSecret)(config.secret) : undefined,
         meshAuth: meshJoin.authenticator,
@@ -686,13 +675,13 @@ async function startAgent(configPath) {
             const childNodeId = `${agentNodeId}/${child.childId}`;
             const childParams = buildAgentChildUdsManifest(childNodeId, child.childId, child.caps);
             subtree.registerNode(childParams);
-            triggerUpwardRegistration();
+            registration.trigger(`child ${childNodeId} connected`);
             consoleLogger.info(`UDS child registered — subtree updated: ${childNodeId}`);
         });
         agentUdsRegistry.onChildGone((childId) => {
             const childNodeId = `${agentNodeId}/${childId}`;
             subtree.removeNode(childNodeId);
-            triggerUpwardRegistration();
+            registration.trigger(`child ${childNodeId} gone`);
             consoleLogger.info(`UDS child gone — subtree updated: ${childNodeId}`);
         });
         // B2: forward UDS child logs onward to the hub's log-receiver service so
@@ -883,8 +872,9 @@ async function startAgent(configPath) {
     // ── D3: Fire the initial upward hub registration carrying the agent's
     // complete in-process manifest (+ any children that already registered).
     // Group-runner children call `$agent.registerNode` and trigger a re-fire
-    // via `onChildRegistered`; hub reconnects re-fire via `$node.connected`.
-    triggerUpwardRegistration();
+    // via `onChildRegistered`; every settled mesh join re-fires it
+    // (`registration.onJoinSettled`), and so does the hub's ask.
+    registration.trigger('boot');
     // Fire `onHubReachable()` on every in-process addon as soon as the hub
     // node connects to our broker — this is the safe point for ctx.api.* calls
     // into hub-provided capabilities. Forked children get the same hook via
@@ -899,9 +889,8 @@ async function startAgent(configPath) {
         if (hubConnectionStateOverride === 'secret-mismatch') {
             hubConnectionStateOverride = null;
         }
-        // Re-register with the hub on reconnect — the hub may have restarted and
-        // lost the agent's manifest. D3 idempotent-replace: safe to re-fire.
-        triggerUpwardRegistration();
+        // No re-registration here: this connection runs a mesh join, and the
+        // join's settle re-sends the manifest (`registration.onJoinSettled`).
         if (hubReachableFired)
             return;
         hubReachableFired = true;

package/dist/api/core/cap-providers.js

@@ -265,15 +265,25 @@ function getLocalIps() {
     return ips;
 }
 /** {@link computeTopology}, keeping the live entries the projection consumed. */
-async function computeTopologyPass(agentRegistry, addonRegistry, getNodeRootPackage) {
-    const [nodes, liveNodes] = await computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage);
+async function computeTopologyPass(agentRegistry, addonRegistry, getNodeRootPackage, isNodeRegistered) {
+    const [nodes, liveNodes] = await computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage, isNodeRegistered);
     return { nodes, liveNodes };
 }
-async function computeTopology(agentRegistry, addonRegistry, getNodeRootPackage) {
-    const [nodes] = await computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage);
+async function computeTopology(agentRegistry, addonRegistry, getNodeRootPackage, isNodeRegistered) {
+    const [nodes] = await computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage, isNodeRegistered);
     return nodes;
 }
-async function computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage) {
+/**
+ * The `capabilitiesRegistered` field of an ONLINE agent row: whether the hub
+ * holds that agent's `registerNode` manifest. Absent for the hub, offline rows
+ * and when no lookup is wired.
+ */
+function registrationField(nodeId, isHub, isOnline, isNodeRegistered) {
+    if (isHub || !isOnline || isNodeRegistered === undefined)
+        return {};
+    return { capabilitiesRegistered: isNodeRegistered(nodeId) };
+}
+async function computeTopologyInternal(agentRegistry, addonRegistry, getNodeRootPackage, isNodeRegistered) {
     // The live cluster walk and the durable offline-node history read NOTHING
     // from each other, and the history read is one settings-store round trip —
     // measured on the live hub at 14.8–18.3 s while the store is stalled. Awaited
@@ -419,6 +429,10 @@ async function computeTopologyInternal(agentRegistry, addonRegistry, getNodeRoot
             // Mesh mTLS Release A: observed by the hub's transporter (certificate CN),
             // never self-reported by the agent. Hub row and unknown: no badge.
             ...(node.isHub ? {} : meshTransportField(node.info.id)),
+            // An agent online in the mesh whose capability registration the hub
+            // dropped (a disconnect only the hub saw) is reported, never silently
+            // capless (2026-10-14).
+            ...registrationField(node.info.id, node.isHub, node.isOnline !== false, isNodeRegistered),
         };
     });
     // A2: union in OFFLINE rows for every persisted node no longer present in the
@@ -474,7 +488,7 @@ function createNodeRootPackageLookup(moleculer, serverUpdate) {
 function buildNodesProvider(agentRegistry, moleculer, addonRegistry, getNodeRootPackage, logger) {
     const broker = moleculer.broker;
     return {
-        topology: async () => computeTopology(agentRegistry, addonRegistry, getNodeRootPackage),
+        topology: async () => computeTopology(agentRegistry, addonRegistry, getNodeRootPackage, (nodeId) => moleculer.isNodeRegistered(nodeId)),
         directory: async () => agentRegistry.listNodeDirectory(),
         deployAddon: async () => {
             // Placeholder — actual deployment orchestration TBD

package/dist/api/trpc/generated-cap-routers.js

@@ -8280,6 +8280,22 @@ function createCapRouter_pipelineOrchestrator(getProvider, _createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.setCameraStepToggle(input);
         }),
+        getCameraDetectionSource: trpc_middleware_js_1.protectedProcedure
+            .input(types_97.pipelineOrchestratorCapability.methods.getCameraDetectionSource.input.loose())
+            .output(types_97.pipelineOrchestratorCapability.methods.getCameraDetectionSource.output)
+            .query(async ({ input, ctx }) => {
+            const p = requireCapProvider('pipeline-orchestrator', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.getCameraDetectionSource(input);
+        }),
+        setCameraDetectionSource: trpc_middleware_js_1.adminProcedure
+            .input(types_97.pipelineOrchestratorCapability.methods.setCameraDetectionSource.input.loose())
+            .output(types_97.pipelineOrchestratorCapability.methods.setCameraDetectionSource.output)
+            .mutation(async ({ input, ctx }) => {
+            const p = requireCapProvider('pipeline-orchestrator', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setCameraDetectionSource(input);
+        }),
         getCameraStepOverrides: trpc_middleware_js_1.protectedProcedure
             .input(types_97.pipelineOrchestratorCapability.methods.getCameraStepOverrides.input.loose())
             .output(types_97.pipelineOrchestratorCapability.methods.getCameraStepOverrides.output)
@@ -10565,6 +10581,13 @@ function createCapRouter_streamBroker(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.listClients(methodInput);
         }),
+        getLiveViewerCounts: trpc_middleware_js_1.protectedProcedure
+            .input(zod_1.z.object({ nodeId: zod_1.z.string().optional() }).optional())
+            .output(types_121.streamBrokerCapability.methods.getLiveViewerCounts.output)
+            .query(async ({ input, ctx }) => {
+            const p = resolveProvider('stream-broker', input?.nodeId, () => getProvider(ctx), createRemoteProxy);
+            return p.getLiveViewerCounts();
+        }),
         killClient: trpc_middleware_js_1.adminProcedure
             .input(types_121.streamBrokerCapability.methods.killClient.input.loose())
             .output(types_121.streamBrokerCapability.methods.killClient.output)

package/dist/core/moleculer/agent-registration-request.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * The hub asks a (re)connected agent for its capability set.
+ *
+ * The hub drops an agent's registration — and its mesh join — on every
+ * `$node.disconnected` it sees (`removeNodeFromRegistry`, `meshGuard.forget`).
+ * Moleculer raises that event on the HUB alone when a third node gossips the
+ * agent offline, when a write to it fails, or when its heartbeat is late; the
+ * agent's own view of the hub never breaks, so nothing on the agent says "send
+ * your manifest again". When the hub then sees the agent again
+ * (`$node.connected`), it holds an online node with NO capabilities. On
+ * 2026-10-14 little-unraid and the Mac sat that way for 50 minutes.
+ *
+ * So on every `$node.connected` of an agent the hub calls
+ * `$agent.requestRegistration`: one RPC, on the event, no timer (D3). The
+ * agent answers through the one atomic `$hub.registerNode`, joining again
+ * first when the hub forgot its join. An agent that predates the action cannot
+ * be asked: that is said, with whether the hub holds its registration, so an
+ * online-but-capless node is never silent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_REQUEST_REGISTRATION_ACTION = void 0;
+exports.requestAgentRegistration = requestAgentRegistration;
+exports.AGENT_REQUEST_REGISTRATION_ACTION = '$agent.requestRegistration';
+function errorType(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const type = Reflect.get(err, 'type');
+    return typeof type === 'string' ? type : null;
+}
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Ask `nodeId` to re-send its complete capability manifest. Never throws. */
+async function requestAgentRegistration(deps, nodeId) {
+    try {
+        await deps.call(exports.AGENT_REQUEST_REGISTRATION_ACTION, {}, { nodeID: nodeId });
+        return 'requested';
+    }
+    catch (err) {
+        const type = errorType(err);
+        const unsupported = type === 'SERVICE_NOT_FOUND' || type === 'SERVICE_NOT_AVAILABLE';
+        const registered = deps.isRegistered(nodeId);
+        const meta = { registered, error: errorText(err) };
+        if (registered) {
+            deps.info(unsupported
+                ? 'agent cannot be asked for its capabilities (it predates $agent.requestRegistration) — the hub holds its registration'
+                : 'asking the agent for its capabilities failed — the hub holds its registration', nodeId, meta);
+        }
+        else {
+            deps.warn(unsupported
+                ? 'agent is online and the hub holds NO capability registration for it; it predates $agent.requestRegistration and cannot be asked — if it stays without capabilities, restart it'
+                : 'agent is online and the hub holds NO capability registration for it; asking it to re-register failed', nodeId, meta);
+        }
+        return unsupported ? 'unsupported' : 'failed';
+    }
+}

package/dist/core/moleculer/moleculer.service.js

@@ -9,6 +9,7 @@ const types_1 = require("@camstack/types");
 const cap_router_runtime_js_1 = require("../../api/trpc/cap-router-runtime.js");
 const core_cap_bridge_js_1 = require("../../api/trpc/core-cap-bridge.js");
 const agent_readiness_pull_js_1 = require("./agent-readiness-pull.js");
+const agent_registration_request_js_1 = require("./agent-registration-request.js");
 const hub_mesh_guard_js_1 = require("./hub-mesh-guard.js");
 const cap_call_fn_js_1 = require("./cap-call-fn.js");
 const cap_route_authority_js_1 = require("./cap-route-authority.js");
@@ -656,6 +657,15 @@ class MoleculerService {
             if (nodeId === this.brokerSafe.nodeID || nodeId.includes('/'))
                 return;
             void this.pullAgentReadinessSnapshot(nodeId);
+            // The hub may have dropped this agent's registration on a disconnect
+            // only the hub saw (gossip, a failed write): ask it for its full set
+            // (`agent-registration-request.ts`, 2026-10-14).
+            void (0, agent_registration_request_js_1.requestAgentRegistration)({
+                call: (action, params, opts) => this.brokerSafe.call(action, params, opts),
+                isRegistered: (id) => this.isNodeRegistered(id),
+                warn: (message, id, meta) => this.logger.warn(message, { tags: { nodeId: id }, meta }),
+                info: (message, id, meta) => this.logger.info(message, { tags: { nodeId: id }, meta }),
+            }, nodeId);
         });
         this.agentReadinessPullTimer = setInterval(() => {
             for (const nodeId of this.nodeRegistry.listNodeIds()) {
@@ -1275,6 +1285,15 @@ class MoleculerService {
     listClusterNativeCapsForDevice(deviceId) {
         return this.nodeRegistry.listNativeCapEntriesForDevice(deviceId);
     }
+    /**
+     * Does the hub hold a capability registration for `nodeId`? `false` for an
+     * agent that is online in the mesh but whose manifest was dropped (a
+     * disconnect only the hub saw) and not yet re-sent — reported as such by
+     * `nodes.topology` (`capabilitiesRegistered`), never silently capless.
+     */
+    isNodeRegistered(nodeId) {
+        return this.nodeRegistry.getNodeManifest(nodeId) !== undefined;
+    }
     /**
      * The root-package identity a node reported in its `registerNode`
      * manifest (runtime-updatable node packages: version visibility), or null

package/dist/core/topology/topology-emitter.service.js

@@ -39,17 +39,21 @@ class TopologyEmitterService {
     agentRegistry;
     addonRegistry;
     getNodeRootPackage;
+    isNodeRegistered;
     unsubscribers = [];
     debounceTimer = null;
     heartbeatTimer = null;
     emitting = false;
     constructor(eventBus, agentRegistry, addonRegistry, 
     /** Root-package identity per node (version visibility) — optional. */
-    getNodeRootPackage) {
+    getNodeRootPackage, 
+    /** Whether the hub holds each agent's capability registration — optional. */
+    isNodeRegistered) {
         this.eventBus = eventBus;
         this.agentRegistry = agentRegistry;
         this.addonRegistry = addonRegistry;
         this.getNodeRootPackage = getNodeRootPackage;
+        this.isNodeRegistered = isNodeRegistered;
     }
     onModuleInit() {
         for (const category of LIFECYCLE_CATEGORIES) {
@@ -89,7 +93,7 @@ class TopologyEmitterService {
             return;
         this.emitting = true;
         try {
-            const { nodes, liveNodes } = await (0, cap_providers_1.computeTopologyPass)(this.agentRegistry, this.addonRegistry, this.getNodeRootPackage);
+            const { nodes, liveNodes } = await (0, cap_providers_1.computeTopologyPass)(this.agentRegistry, this.addonRegistry, this.getNodeRootPackage, this.isNodeRegistered);
             this.eventBus.emit({
                 id: (0, node_crypto_1.randomUUID)(),
                 timestamp: new Date(),

package/dist/manual-boot.js

@@ -257,7 +257,7 @@ async function bootManual(opts) {
         eventBus: eventBusService,
         updateAvailabilityStore: new update_availability_store_js_1.FileUpdateAvailabilityStore(availabilityDataDir, 'server-update', loggingService.createLogger('UpdateAvailability')),
     });
-    const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService, (0, cap_providers_1.createNodeRootPackageLookup)(moleculerService, serverUpdateService));
+    const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService, (0, cap_providers_1.createNodeRootPackageLookup)(moleculerService, serverUpdateService), (nodeId) => moleculerService.isNodeRegistered(nodeId));
     const postBootService = new post_boot_service_1.PostBootService(addonRegistryService, eventBusService, loggingService);
     // ---- Update availability poller ---------------------------------------
     // "Tell me, don't install." Deliberately NOT gated on the auto-update

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.543",
+  "version": "1.2.545",
   "license": "MIT",
   "private": false,
   "files": [
@@ -38,19 +38,19 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.409",
-    "@camstack/addon-agent-ui": "1.2.224",
+    "@camstack/addon-admin-ui": "1.2.410",
+    "@camstack/addon-agent-ui": "1.2.225",
     "@camstack/addon-auth": "1.2.141",
     "@camstack/addon-decoder-nodeav": "1.2.123",
     "@camstack/addon-notifiers": "1.2.134",
-    "@camstack/addon-pipeline": "1.2.361",
-    "@camstack/addon-pipeline-orchestrator": "1.2.311",
-    "@camstack/addon-post-analysis": "1.2.360",
+    "@camstack/addon-pipeline": "1.2.362",
+    "@camstack/addon-pipeline-orchestrator": "1.2.312",
+    "@camstack/addon-post-analysis": "1.2.361",
     "@camstack/develop": "0.1.5",
     "@camstack/sdk": "1.2.131",
-    "@camstack/system": "1.2.419",
-    "@camstack/types": "1.2.357",
-    "@camstack/ui-library": "1.2.281",
+    "@camstack/system": "1.2.421",
+    "@camstack/types": "1.2.358",
+    "@camstack/ui-library": "1.2.282",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",