@naisys/hub 3.0.0-beta.37 → 3.0.0-beta.39

package/dist/handlers/hubAgentService.js

@@ -1,6 +1,29 @@
-import { AgentPeekRequestSchema, AgentRunCommandRequestSchema, AgentRunPauseRequestSchema, AgentStartRequestSchema, AgentStopRequestSchema, HubEvents, } from "@naisys/hub-protocol";
+import { hashToken } from "@naisys/common-node";
+import { AgentPeekRequestSchema, AgentRunCommandRequestSchema, AgentRunPauseRequestSchema, AgentStartInboundSchema, AgentStopRequestSchema, HubEvents, } from "@naisys/hub-protocol";
+import { randomBytes } from "crypto";
 /** Handles agent_start requests by routing them to the least-loaded eligible host */
 export function createHubAgentService(naisysServer, { hubDb }, logService, heartbeatService, sendMailService, hostRegistrar) {
+    /**
+     * Mint a fresh runtime API key for a user, rotating any prior key. Plaintext
+     * is returned only here and travels once over the AGENT_START message; the
+     * DB only stores the hash. Keys persist across hub restarts/crashes/updates;
+     * revocation lives on the user disable/archive/delete paths and on graceful
+     * AGENT_STOP.
+     */
+    async function issueRuntimeApiKey(userId) {
+        const token = randomBytes(32).toString("hex");
+        await hubDb.users.update({
+            where: { id: userId },
+            data: { api_key_hash: hashToken(token) },
+        });
+        return token;
+    }
+    async function revokeRuntimeApiKey(userId) {
+        await hubDb.users.update({
+            where: { id: userId },
+            data: { api_key_hash: null },
+        });
+    }
     /** Find the least-loaded eligible host for a given user */
     async function findBestHost(startUserId) {
         // Look up which hosts this user is assigned to
@@ -52,30 +75,61 @@ export function createHubAgentService(naisysServer, { hubDb }, logService, heart
         });
         return !!user?.enabled && !user?.archived;
     }
+    /** Run the start preconditions and pick a host. */
+    async function decideStartAgent(userId) {
+        if (!(await isAgentEnabled(userId))) {
+            return { kind: "fail", error: `Agent ${userId} is disabled` };
+        }
+        if (heartbeatService.findHostsForAgent(userId).length > 0) {
+            return { kind: "fail", error: `Agent ${userId} is already running` };
+        }
+        const bestHostId = await findBestHost(userId);
+        if (bestHostId === null) {
+            return {
+                kind: "fail",
+                error: `No eligible hosts are online for user ${userId}`,
+            };
+        }
+        return { kind: "go", bestHostId };
+    }
+    /**
+     * Issue a runtime key and send AGENT_START. Stranded keys from a failed
+     * send or failed response stay in the DB until the next AGENT_START for
+     * that user rotates them, or the user is disabled/archived/deleted — the
+     * agent process that would have used the key never started, so there's
+     * nobody to authenticate with it in the meantime.
+     */
+    async function dispatchAgentStart(args) {
+        const { bestHostId, payload, onResponse } = args;
+        const startUserId = payload.startUserId;
+        const runtimeApiKey = await issueRuntimeApiKey(startUserId);
+        const sent = naisysServer.sendMessage(bestHostId, HubEvents.AGENT_START, { ...payload, runtimeApiKey }, (response) => {
+            if (response.success) {
+                heartbeatService.addStartedAgent(bestHostId, startUserId);
+            }
+            onResponse(response);
+        });
+        return { sent };
+    }
     /** Try to start an agent on the best available host (fire-and-forget) */
     async function tryStartAgent(startUserId) {
         try {
-            if (!(await isAgentEnabled(startUserId))) {
-                logService.log(`[Hub:Agents] Auto-start: agent ${startUserId} is disabled or archived`);
-                return false;
-            }
-            const bestHostId = await findBestHost(startUserId);
-            if (bestHostId === null) {
-                logService.log(`[Hub:Agents] Auto-start: no eligible host for user ${startUserId}`);
+            const decision = await decideStartAgent(startUserId);
+            if (decision.kind === "fail") {
+                logService.log(`[Hub:Agents] Auto-start: ${decision.error}`);
                 return false;
             }
-            const sent = naisysServer.sendMessage(bestHostId, HubEvents.AGENT_START, {
-                startUserId,
-            }, (response) => {
-                if (response.success) {
-                    heartbeatService.addStartedAgent(bestHostId, startUserId);
-                }
-                else {
-                    logService.error(`[Hub:Agents] Auto-start failed for user ${startUserId}: ${response.error}`);
-                }
+            const { sent } = await dispatchAgentStart({
+                bestHostId: decision.bestHostId,
+                payload: { startUserId },
+                onResponse: (response) => {
+                    if (!response.success) {
+                        logService.error(`[Hub:Agents] Auto-start failed for user ${startUserId}: ${response.error}`);
+                    }
+                },
             });
             if (sent) {
-                logService.log(`[Hub:Agents] Auto-start: sent start for user ${startUserId} to host ${bestHostId}`);
+                logService.log(`[Hub:Agents] Auto-start: sent start for user ${startUserId} to host ${decision.bestHostId}`);
             }
             return sent;
         }
@@ -86,51 +140,33 @@ export function createHubAgentService(naisysServer, { hubDb }, logService, heart
     }
     naisysServer.registerEvent(HubEvents.AGENT_START, async (hostId, data, ack) => {
         try {
-            const parsed = AgentStartRequestSchema.parse(data);
-            const requesterUserId = parsed.requesterUserId;
-            if (!(await isAgentEnabled(parsed.startUserId))) {
-                ack({
-                    success: false,
-                    error: `Agent ${parsed.startUserId} is disabled`,
-                });
-                return;
-            }
-            const bestHostId = await findBestHost(parsed.startUserId);
-            if (bestHostId === null) {
-                ack({
-                    success: false,
-                    error: `No eligible hosts are online for user ${parsed.startUserId}`,
-                });
+            const parsed = AgentStartInboundSchema.parse(data);
+            const decision = await decideStartAgent(parsed.startUserId);
+            if (decision.kind === "fail") {
+                ack({ success: false, error: decision.error });
                 return;
             }
-            if (!requesterUserId) {
-                ack({
-                    success: false,
-                    error: `Missing requesterUserId in agent_start request for user ${parsed.startUserId}`,
-                });
-                return;
-            }
-            // Forward the start request to the selected host
-            const sent = naisysServer.sendMessage(bestHostId, HubEvents.AGENT_START, {
-                startUserId: parsed.startUserId,
-                taskDescription: parsed.taskDescription,
-                sourceHostId: hostId,
-            }, (response) => {
-                if (response.success) {
-                    heartbeatService.addStartedAgent(bestHostId, parsed.startUserId);
-                }
-                // Reverse-ack with the response from the host (including success status and any error message) back to the original requester
-                ack(response);
-                // Send task description mail after successful start to avoid
-                // orphaned mails from failed start attempts
-                if (response.success && parsed.taskDescription) {
-                    void sendTaskMail(parsed.startUserId, requesterUserId, parsed.taskDescription);
-                }
+            const { sent } = await dispatchAgentStart({
+                bestHostId: decision.bestHostId,
+                payload: {
+                    startUserId: parsed.startUserId,
+                    taskDescription: parsed.taskDescription,
+                    sourceHostId: hostId,
+                },
+                onResponse: (response) => {
+                    // Reverse-ack with the response from the host (including success status and any error message) back to the original requester
+                    ack(response);
+                    // Send task description mail after successful start to avoid
+                    // orphaned mails from failed start attempts
+                    if (response.success && parsed.taskDescription) {
+                        void sendTaskMail(parsed.startUserId, parsed.requesterUserId, parsed.taskDescription);
+                    }
+                },
             });
             if (!sent) {
                 ack({
                     success: false,
-                    error: `Failed to send to host ${bestHostId}`,
+                    error: `Failed to send to host ${decision.bestHostId}`,
                 });
             }
         }
@@ -176,6 +212,9 @@ export function createHubAgentService(naisysServer, { hubDb }, logService, heart
                 }, (response) => {
                     if (response.success) {
                         heartbeatService.removeStoppedAgent(targetHostId, parsed.userId);
+                        revokeRuntimeApiKey(parsed.userId).catch((err) => {
+                            logService.error(`[Hub:Agents] Failed to revoke runtime key for user ${parsed.userId} on stop: ${err}`);
+                        });
                     }
                     // Ack with the first response
                     if (!acked) {
@@ -217,6 +256,7 @@ export function createHubAgentService(naisysServer, { hubDb }, logService, heart
                     const sent = naisysServer.sendMessage(targetHostId, event, {
                         userId: parsed.userId,
                         runId: parsed.runId,
+                        subagentId: parsed.subagentId,
                         sessionId: parsed.sessionId,
                         sourceHostId: hostId,
                     }, (response) => {
@@ -261,6 +301,7 @@ export function createHubAgentService(naisysServer, { hubDb }, logService, heart
                 const sent = naisysServer.sendMessage(targetHostId, HubEvents.AGENT_RUN_COMMAND, {
                     userId: parsed.userId,
                     runId: parsed.runId,
+                    subagentId: parsed.subagentId,
                     sessionId: parsed.sessionId,
                     command: parsed.command,
                     sourceHostId: hostId,

package/dist/handlers/hubAttachmentService.js

@@ -1,10 +1,8 @@
-import { mimeFromFilename } from "@naisys/common";
-import { extractBearerToken } from "@naisys/common-node";
-import { createHash, randomBytes } from "crypto";
-import { createReadStream, createWriteStream, existsSync, mkdirSync, renameSync, statSync, unlinkSync, } from "fs";
+import { extractBearerToken, generateAttachmentPublicId, getHubAttachmentPath, hashToken, MAX_HUB_ATTACHMENT_SIZE, sendAttachmentResponse, } from "@naisys/common-node";
+import { createHash } from "crypto";
+import { createWriteStream, existsSync, mkdirSync, renameSync, unlinkSync, } from "fs";
 import { join } from "path";
 import { pipeline, Writable } from "stream";
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 /**
  * HTTP attachment upload/download service.
  * Registers Fastify routes for `/hub/attachments` paths.
@@ -12,7 +10,9 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 export function createHubAttachmentService(fastify, { hubDb }, logService) {
     const naisysFolder = process.env.NAISYS_FOLDER || "";
     async function resolveUserByApiKey(apiKey) {
-        const user = await hubDb.users.findUnique({ where: { api_key: apiKey } });
+        const user = await hubDb.users.findUnique({
+            where: { api_key_hash: hashToken(apiKey) },
+        });
         return user?.id ?? null;
     }
     // Upload route — encapsulated so the raw content-type parser doesn't leak
@@ -49,9 +49,9 @@ export function createHubAttachmentService(fastify, { hubDb }, logService) {
                 if (isNaN(fileSize) || fileSize <= 0) {
                     return reply.code(400).send({ error: "Invalid filesize" });
                 }
-                if (fileSize > MAX_FILE_SIZE) {
+                if (fileSize > MAX_HUB_ATTACHMENT_SIZE) {
                     return reply.code(413).send({
-                        error: `File too large. Max size: ${MAX_FILE_SIZE} bytes`,
+                        error: `File too large. Max size: ${MAX_HUB_ATTACHMENT_SIZE} bytes`,
                     });
                 }
                 const userId = await resolveUserByApiKey(apiKey);
@@ -71,7 +71,7 @@ export function createHubAttachmentService(fastify, { hubDb }, logService) {
                     const sizeChecker = new Writable({
                         write(chunk, _encoding, callback) {
                             bytesWritten += chunk.length;
-                            if (bytesWritten > MAX_FILE_SIZE) {
+                            if (bytesWritten > MAX_HUB_ATTACHMENT_SIZE) {
                                 callback(new Error("File exceeds size limit"));
                                 return;
                             }
@@ -116,10 +116,8 @@ export function createHubAttachmentService(fastify, { hubDb }, logService) {
                         error: `Hash mismatch. Expected: ${fileHash}, got: ${computedHash}`,
                     });
                 }
-                // Move to content-addressable path: attachments/hub/<first2>/<next2>/<fullhash>
-                const storageDir = join(naisysFolder, "attachments", "hub", computedHash.slice(0, 2), computedHash.slice(2, 4));
+                const { storageDir, storagePath } = getHubAttachmentPath(naisysFolder, computedHash);
                 mkdirSync(storageDir, { recursive: true });
-                const storagePath = join(storageDir, computedHash);
                 if (existsSync(storagePath)) {
                     // Dedup: identical file already on disk, discard temp
                     try {
@@ -132,10 +130,9 @@ export function createHubAttachmentService(fastify, { hubDb }, logService) {
                 else {
                     renameSync(tmpPath, storagePath);
                 }
-                // Create DB record
                 const record = await hubDb.attachments.create({
                     data: {
-                        public_id: randomBytes(8).toString("base64url").slice(0, 10),
+                        public_id: generateAttachmentPublicId(),
                         filepath: storagePath,
                         filename,
                         file_size: bytesWritten,
@@ -174,22 +171,7 @@ export function createHubAttachmentService(fastify, { hubDb }, logService) {
         if (!attachment) {
             return reply.code(404).send({ error: "Attachment not found" });
         }
-        if (!existsSync(attachment.filepath)) {
-            return reply
-                .code(404)
-                .send({ error: "Attachment file missing from disk" });
-        }
-        const stat = statSync(attachment.filepath);
-        const contentType = mimeFromFilename(attachment.filename);
-        const disposition = contentType.startsWith("image/")
-            ? "inline"
-            : "attachment";
-        reply
-            .header("Content-Type", contentType)
-            .header("Content-Disposition", `${disposition}; filename="${attachment.filename.replace(/"/g, '\\"')}"`)
-            .header("Content-Length", stat.size);
-        const readStream = createReadStream(attachment.filepath);
-        return reply.send(readStream);
+        return sendAttachmentResponse(reply, attachment.filepath, attachment.filename);
     }
     fastify.get("/hub/attachments/:publicId/:filename", async (request, reply) => {
         try {

package/dist/handlers/hubConfigService.js

@@ -40,6 +40,7 @@ export async function createHubConfigService(naisysServer, { hubDb }, logService
         { key: "SPEND_LIMIT_DOLLARS" },
         { key: "SPEND_LIMIT_HOURS" },
         { key: "TARGET_VERSION" },
+        { key: "MAIL_ENABLED" },
     ]);
     /** Read variables from DB and build a ConfigResponse */
     async function buildConfigPayload() {

package/dist/handlers/hubCostService.js

@@ -3,9 +3,10 @@ import { CostWriteRequestSchema, HubEvents, } from "@naisys/hub-protocol";
 const SPEND_LIMIT_CHECK_INTERVAL_MS = 10_000;
 /** Handles cost_write events from NAISYS instances (fire-and-forget) */
 export function createHubCostService(naisysServer, { hubDb }, logService, heartbeatService, configService) {
-    // Track which users have been suspended due to spend limit overrun
-    const suspendedByGlobal = new Set();
-    const suspendedByAgent = new Set();
+    // Suspended users → original suspension reason. Stored so a defensive
+    // re-send (when a suspended user keeps writing costs) can use the same text.
+    const suspendedByGlobal = new Map();
+    const suspendedByAgent = new Map();
     naisysServer.registerEvent(HubEvents.COST_WRITE, async (hostId, data, ack) => {
         try {
             const parsed = CostWriteRequestSchema.parse(data);
@@ -14,10 +15,14 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
             const costPushMap = new Map();
             const userCostTotals = new Map();
             for (const entry of parsed.entries) {
+                const subagentId = entry.subagentId ?? 0;
+                // Wire format: undefined for parent (subagent_id 0 in DB), number otherwise
+                const wireSubagentId = subagentId === 0 ? undefined : subagentId;
                 await hubDb.costs.create({
                     data: {
                         user_id: entry.userId,
                         run_id: entry.runId,
+                        subagent_id: subagentId,
                         session_id: entry.sessionId,
                         host_id: hostId,
                         source: entry.source,
@@ -34,13 +39,14 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
                     where: {
                         user_id: entry.userId,
                         run_id: entry.runId,
+                        subagent_id: subagentId,
                         session_id: entry.sessionId,
                     },
                     data: {
                         total_cost: { increment: entry.cost },
                     },
                 });
-                const key = `${entry.userId}:${entry.runId}:${entry.sessionId}`;
+                const key = `${entry.userId}:${entry.runId}:${subagentId}:${entry.sessionId}`;
                 const existing = costPushMap.get(key);
                 if (existing) {
                     existing.costDelta += entry.cost;
@@ -49,6 +55,7 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
                     costPushMap.set(key, {
                         userId: entry.userId,
                         runId: entry.runId,
+                        subagentId: wireSubagentId,
                         sessionId: entry.sessionId,
                         costDelta: entry.cost,
                     });
@@ -61,10 +68,12 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
                     entries: Array.from(costPushMap.values()),
                 });
             }
-            // Re-send cost_control to any suspended users still writing costs
+            // Re-send cost_control to suspended users still writing costs.
+            // Per-agent reason wins: a per-agent limit overrides the global one.
             for (const userId of userCostTotals.keys()) {
-                if (suspendedByGlobal.has(userId) || suspendedByAgent.has(userId)) {
-                    sendCostControl(userId, false, "Spend limit exceeded");
+                const reason = suspendedByAgent.get(userId) ?? suspendedByGlobal.get(userId);
+                if (reason !== undefined) {
+                    sendCostControl(userId, false, reason);
                 }
             }
             // Decrement budget_left and return updated values
@@ -83,9 +92,9 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
     async function checkSpendLimits(candidateUserIds) {
         const activeUserIds = heartbeatService.getActiveUserIds();
         const usersToCheck = new Set(activeUserIds);
-        for (const userId of suspendedByGlobal)
+        for (const userId of suspendedByGlobal.keys())
             usersToCheck.add(userId);
-        for (const userId of suspendedByAgent)
+        for (const userId of suspendedByAgent.keys())
             usersToCheck.add(userId);
         if (candidateUserIds) {
             for (const userId of candidateUserIds)
@@ -209,7 +218,7 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
                 const reason = `Global spend limit of $${spendLimit} reached (total: $${totalCost.toFixed(2)})`;
                 logService.log(`[Hub:Costs] Suspending user ${userId} (global limit): ${reason}`);
                 sendCostControl(userId, false, reason);
-                suspendedByGlobal.add(userId);
+                suspendedByGlobal.set(userId, reason);
                 await setCostSuspendedReason(hubDb, userId, reason);
             }
             else if (!isOverLimit && wasSuspended) {
@@ -232,7 +241,7 @@ export function createHubCostService(naisysServer, { hubDb }, logService, heartb
             const reason = `Spend limit of $${spendLimit} reached (current: $${periodCost.toFixed(2)})`;
             logService.log(`[Hub:Costs] Suspending user ${userId}: ${reason}`);
             sendCostControl(userId, false, reason);
-            suspendedByAgent.add(userId);
+            suspendedByAgent.set(userId, reason);
             await setCostSuspendedReason(hubDb, userId, reason);
         }
         else if (!isOverLimit && wasSuspended) {

package/dist/handlers/hubCostService.test.js

@@ -0,0 +1,263 @@
+import { buildDefaultAgentConfig } from "@naisys/common";
+import { HubEvents } from "@naisys/hub-protocol";
+import { describe, expect, test, vi } from "vitest";
+import { createHubCostService } from "./hubCostService.js";
+function createServerHarness() {
+    const handlers = new Map();
+    const server = {
+        registerEvent: vi.fn((event, handler) => {
+            handlers.set(event, handler);
+        }),
+        broadcastToSupervisors: vi.fn(),
+        sendMessage: vi.fn(() => true),
+    };
+    async function emitCostWrite(hostId, data) {
+        const handler = handlers.get(HubEvents.COST_WRITE);
+        if (!handler)
+            throw new Error("COST_WRITE handler was not registered");
+        let ackResponse;
+        await handler(hostId, data, (response) => {
+            ackResponse = response;
+        });
+        return ackResponse;
+    }
+    return { server, emitCostWrite };
+}
+function createHubDb() {
+    const budgetLeft = new Map([[1, 5]]);
+    const hubDb = {
+        costs: {
+            create: vi.fn(() => Promise.resolve({})),
+            aggregate: vi.fn(() => Promise.resolve({ _sum: { cost: 0 } })),
+        },
+        run_session: {
+            updateMany: vi.fn(() => Promise.resolve({})),
+        },
+        users: {
+            findMany: vi.fn(() => Promise.resolve([])),
+        },
+        user_notifications: {
+            findUnique: vi.fn(({ where }) => {
+                const value = budgetLeft.get(where.user_id);
+                return Promise.resolve(value === undefined ? null : { budget_left: value });
+            }),
+            update: vi.fn(({ where, data, }) => {
+                budgetLeft.set(where.user_id, data.budget_left);
+                return Promise.resolve({ budget_left: data.budget_left });
+            }),
+            updateMany: vi.fn(() => Promise.resolve({})),
+        },
+    };
+    return { hubDb, budgetLeft };
+}
+function createLogger() {
+    return {
+        log: vi.fn(),
+        error: vi.fn(),
+        disableConsole: vi.fn(),
+    };
+}
+function createHeartbeatService(activeUserIds, hostIdsByUser = new Map([[1, [101]]])) {
+    return {
+        getActiveUserIds: vi.fn(() => activeUserIds),
+        findHostsForAgent: vi.fn((userId) => hostIdsByUser.get(userId) ?? []),
+    };
+}
+function createConfigService(config) {
+    return {
+        getConfig: vi.fn(() => ({ config })),
+    };
+}
+function userRow(id, configOverrides, spendLimitResetAt) {
+    return {
+        id,
+        config: JSON.stringify({
+            ...buildDefaultAgentConfig(`agent-${id}`),
+            ...configOverrides,
+        }),
+        user_notifications: {
+            spend_limit_reset_at: spendLimitResetAt,
+        },
+    };
+}
+describe("hubCostService", () => {
+    test("persists subagent cost entries, pushes scoped deltas, and decrements budget", async () => {
+        const { server, emitCostWrite } = createServerHarness();
+        const { hubDb } = createHubDb();
+        const logger = createLogger();
+        const heartbeatService = createHeartbeatService([]);
+        const configService = createConfigService({});
+        const service = createHubCostService(server, { hubDb }, logger, heartbeatService, configService);
+        const ack = await emitCostWrite(42, {
+            entries: [
+                {
+                    userId: 1,
+                    runId: 7,
+                    subagentId: -1,
+                    sessionId: 1,
+                    source: "genimg",
+                    model: "mock-image",
+                    cost: 0.5,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheReadTokens: 0,
+                },
+                {
+                    userId: 1,
+                    runId: 7,
+                    subagentId: -1,
+                    sessionId: 1,
+                    source: "genimg",
+                    model: "mock-image",
+                    cost: 0.25,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheReadTokens: 0,
+                },
+            ],
+        });
+        expect(hubDb.costs.create).toHaveBeenCalledWith({
+            data: expect.objectContaining({
+                user_id: 1,
+                run_id: 7,
+                subagent_id: -1,
+                session_id: 1,
+                host_id: 42,
+                cost: 0.5,
+            }),
+        });
+        expect(hubDb.run_session.updateMany).toHaveBeenCalledWith({
+            where: {
+                user_id: 1,
+                run_id: 7,
+                subagent_id: -1,
+                session_id: 1,
+            },
+            data: {
+                total_cost: { increment: 0.5 },
+            },
+        });
+        expect(server.broadcastToSupervisors).toHaveBeenCalledWith(HubEvents.COST_PUSH, {
+            entries: [
+                {
+                    userId: 1,
+                    runId: 7,
+                    subagentId: -1,
+                    sessionId: 1,
+                    costDelta: 0.75,
+                },
+            ],
+        });
+        expect(hubDb.user_notifications.update).toHaveBeenCalledWith({
+            where: { user_id: 1 },
+            data: { budget_left: 4.25 },
+        });
+        expect(ack).toEqual({ budgets: [{ userId: 1, budgetLeft: 4.25 }] });
+        service.cleanup();
+    });
+    test("normalizes parent-agent subagentId to undefined on the wire (DB row stays 0)", async () => {
+        const { server, emitCostWrite } = createServerHarness();
+        const { hubDb } = createHubDb();
+        const logger = createLogger();
+        const heartbeatService = createHeartbeatService([]);
+        const configService = createConfigService({});
+        const service = createHubCostService(server, { hubDb }, logger, heartbeatService, configService);
+        await emitCostWrite(42, {
+            entries: [
+                {
+                    userId: 1,
+                    runId: 7,
+                    // subagentId omitted — represents the parent agent
+                    sessionId: 1,
+                    source: "console",
+                    model: "mock",
+                    cost: 0.1,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheReadTokens: 0,
+                },
+            ],
+        });
+        expect(hubDb.costs.create).toHaveBeenCalledWith({
+            data: expect.objectContaining({ subagent_id: 0 }),
+        });
+        expect(server.broadcastToSupervisors).toHaveBeenCalledWith(HubEvents.COST_PUSH, {
+            entries: [
+                {
+                    userId: 1,
+                    runId: 7,
+                    subagentId: undefined,
+                    sessionId: 1,
+                    costDelta: 0.1,
+                },
+            ],
+        });
+        service.cleanup();
+    });
+    test("suspends, re-sends, and resumes per-agent cost control", async () => {
+        const { server, emitCostWrite } = createServerHarness();
+        const { hubDb } = createHubDb();
+        const logger = createLogger();
+        const heartbeatService = createHeartbeatService([1]);
+        const configService = createConfigService({});
+        vi.mocked(hubDb.users.findMany).mockResolvedValue([
+            userRow(1, { spendLimitDollars: 1 }),
+        ]);
+        vi.mocked(hubDb.costs.aggregate)
+            .mockResolvedValueOnce({ _sum: { cost: 1.25 } })
+            .mockResolvedValueOnce({ _sum: { cost: 0.25 } });
+        const service = createHubCostService(server, { hubDb }, logger, heartbeatService, configService);
+        await service.checkSpendLimits();
+        const suspendReason = "Spend limit of $1 reached (current: $1.25)";
+        expect(server.sendMessage).toHaveBeenCalledWith(101, HubEvents.COST_CONTROL, {
+            userId: 1,
+            enabled: false,
+            reason: suspendReason,
+        });
+        expect(service.isUserSpendSuspended(1)).toBe(true);
+        expect(hubDb.user_notifications.updateMany).toHaveBeenCalledWith({
+            where: { user_id: 1 },
+            data: { cost_suspended_reason: suspendReason },
+        });
+        vi.mocked(server.sendMessage).mockClear();
+        await emitCostWrite(42, {
+            entries: [
+                {
+                    userId: 1,
+                    runId: 7,
+                    subagentId: -1,
+                    sessionId: 1,
+                    source: "genimg",
+                    model: "mock-image",
+                    cost: 0.1,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheReadTokens: 0,
+                },
+            ],
+        });
+        expect(server.sendMessage).toHaveBeenCalledWith(101, HubEvents.COST_CONTROL, {
+            userId: 1,
+            enabled: false,
+            reason: suspendReason,
+        });
+        vi.mocked(server.sendMessage).mockClear();
+        await service.checkSpendLimits();
+        expect(server.sendMessage).toHaveBeenCalledWith(101, HubEvents.COST_CONTROL, {
+            userId: 1,
+            enabled: true,
+            reason: "Spend limit period reset (current: $0.25, limit: $1)",
+        });
+        expect(service.isUserSpendSuspended(1)).toBe(false);
+        expect(hubDb.user_notifications.updateMany).toHaveBeenCalledWith({
+            where: { user_id: 1 },
+            data: { cost_suspended_reason: null },
+        });
+        service.cleanup();
+    });
+});
+//# sourceMappingURL=hubCostService.test.js.map

package/dist/handlers/hubHeartbeatService.js

@@ -1,11 +1,10 @@
 import { HeartbeatSchema, HUB_HEARTBEAT_INTERVAL_MS, HubEvents, } from "@naisys/hub-protocol";
 /** Tracks NAISYS instance heartbeats and pushes aggregate active user status to all instances */
 export function createHubHeartbeatService(naisysServer, { hubDb }, logService) {
-    // Track active agent user IDs per host from heartbeat data
+    // Active agent user ids per host. Subagents ride under the parent's userId.
     const hostActiveAgents = new Map();
-    // Track each active agent's current run session and its last heartbeat time.
-    // Keyed by hostId so we can drop sessions when a host disconnects.
     const hostActiveSessions = new Map();
+    const sessionKey = (userId, subagentId) => `${userId}:${subagentId ?? 0}`;
     // Track per-agent notification IDs (latestLogId, latestMailId)
     const agentNotifications = new Map();
     /** Update a single notification field for an agent */
@@ -20,7 +19,10 @@ export function createHubHeartbeatService(naisysServer, { hubDb }, logService) {
     // Handle heartbeat from NAISYS instances
     naisysServer.registerEvent(HubEvents.HEARTBEAT, async (hostId, data) => {
         const parsed = HeartbeatSchema.parse(data);
-        const activeUserIds = parsed.activeSessions.map((s) => s.userId);
+        // Dedup: a parent and its subagents share a userId.
+        const activeUserIds = [
+            ...new Set(parsed.activeSessions.map((s) => s.userId)),
+        ];
         // Update in-memory per-host active agent IDs
         hostActiveAgents.set(hostId, activeUserIds);
         try {
@@ -42,15 +44,10 @@ export function createHubHeartbeatService(naisysServer, { hubDb }, logService) {
             // aggregate SESSION_HEARTBEAT broadcast runs on its own interval below.
             const sessionMap = new Map();
             for (const session of parsed.activeSessions) {
-                await hubDb.run_session.updateMany({
-                    where: {
-                        user_id: session.userId,
-                        run_id: session.runId,
-                        session_id: session.sessionId,
-                    },
-                    data: { last_active: now },
-                });
-                sessionMap.set(session.userId, {
+                const subagentId = session.subagentId ?? 0;
+                sessionMap.set(sessionKey(session.userId, subagentId), {
+                    userId: session.userId,
+                    subagentId: subagentId === 0 ? null : subagentId,
                     runId: session.runId,
                     sessionId: session.sessionId,
                     lastActive: now,
@@ -58,13 +55,28 @@ export function createHubHeartbeatService(naisysServer, { hubDb }, logService) {
                     state: session.state,
                 });
             }
+            if (parsed.activeSessions.length > 0) {
+                await hubDb.run_session.updateMany({
+                    where: {
+                        OR: parsed.activeSessions.map((session) => ({
+                            user_id: session.userId,
+                            run_id: session.runId,
+                            subagent_id: session.subagentId ?? 0,
+                            session_id: session.sessionId,
+                        })),
+                    },
+                    data: { last_active: now },
+                });
+            }
             hostActiveSessions.set(hostId, sessionMap);
         }
         catch (error) {
             logService.error(`[Hub:Heartbeat] Error updating heartbeat for host ${hostId}: ${error}`);
         }
     });
-    // Clean up tracking when a host disconnects
+    // Clean up tracking when a host disconnects. Runtime API keys are not
+    // touched here — they're rotated on the next AGENT_START and revoked
+    // explicitly on user disable/archive/delete.
     naisysServer.registerEvent(HubEvents.CLIENT_DISCONNECTED, (hostId) => {
         hostActiveAgents.delete(hostId);
         hostActiveSessions.delete(hostId);
@@ -97,10 +109,11 @@ export function createHubHeartbeatService(naisysServer, { hubDb }, logService) {
     function pushSessionHeartbeat() {
         const updates = [];
         for (const sessions of hostActiveSessions.values()) {
-            for (const [userId, info] of sessions) {
+            for (const info of sessions.values()) {
                 updates.push({
-                    userId,
+                    userId: info.userId,
                     runId: info.runId,
+                    subagentId: info.subagentId ?? undefined,
                     sessionId: info.sessionId,
                     lastActive: info.lastActive,
                     paused: info.paused,

package/dist/handlers/hubHostService.js

@@ -37,6 +37,9 @@ export function createHubHostService(naisysServer, hostRegistrar, logService) {
     naisysServer.registerEvent(HubEvents.CLIENT_CONNECTED, (_hostId, connection) => {
         broadcastHostList(connection);
     });
+    naisysServer.registerEvent(HubEvents.CLIENT_DISCONNECTED, () => {
+        broadcastHostList();
+    });
     naisysServer.registerEvent(HubEvents.HOSTS_CHANGED, async () => {
         logService.log("[Hub:Hosts] Received HOSTS_CHANGED, refreshing cache...");
         await hostRegistrar.refreshHosts();

package/dist/handlers/hubLogService.js

@@ -12,10 +12,14 @@ export function createHubLogService(naisysServer, { hubDb }, logService, heartbe
             for (const entry of parsed.entries) {
                 const now = new Date().toISOString();
                 const lineCount = entry.message.split("\n").length;
+                const subagentId = entry.subagentId ?? 0;
+                // Wire format: undefined for parent (subagent_id 0 in DB), number otherwise
+                const wireSubagentId = subagentId === 0 ? undefined : subagentId;
                 const log = await hubDb.context_log.create({
                     data: {
                         user_id: entry.userId,
                         run_id: entry.runId,
+                        subagent_id: subagentId,
                         session_id: entry.sessionId,
                         host_id: hostId,
                         role: entry.role,
@@ -31,6 +35,7 @@ export function createHubLogService(naisysServer, { hubDb }, logService, heartbe
                     where: {
                         user_id: entry.userId,
                         run_id: entry.runId,
+                        subagent_id: subagentId,
                         session_id: entry.sessionId,
                     },
                     data: {
@@ -69,13 +74,14 @@ export function createHubLogService(naisysServer, { hubDb }, logService, heartbe
                     }
                 }
                 // Collect push entry with DB-assigned ID
-                const sessionKey = `${entry.userId}-${entry.runId}-${entry.sessionId}`;
+                const sessionKey = `${entry.userId}-${entry.runId}-${subagentId}-${entry.sessionId}`;
                 const previousId = lastPushedLogId.get(sessionKey) ?? null;
                 pushEntries.push({
                     id: log.id,
                     previousId,
                     userId: entry.userId,
                     runId: entry.runId,
+                    subagentId: wireSubagentId,
                     sessionId: entry.sessionId,
                     role: entry.role,
                     source: entry.source,
@@ -98,6 +104,7 @@ export function createHubLogService(naisysServer, { hubDb }, logService, heartbe
                     sessionUpdates.set(sessionKey, {
                         userId: entry.userId,
                         runId: entry.runId,
+                        subagentId: wireSubagentId,
                         sessionId: entry.sessionId,
                         lastActive: now,
                         latestLogId: log.id,

package/dist/handlers/hubRunService.js

@@ -14,18 +14,42 @@ export function createHubRunService(naisysServer, { hubDb }, logService) {
     naisysServer.registerEvent(HubEvents.SESSION_CREATE, async (hostId, data, ack) => {
         try {
             const parsed = SessionCreateRequestSchema.parse(data);
-            // Get the last run_id across all sessions
-            const lastRun = await hubDb.run_session.findFirst({
-                select: { run_id: true },
-                orderBy: { run_id: "desc" },
-            });
-            const newRunId = lastRun ? lastRun.run_id + 1 : 1;
+            // Subagent path: inherit the parent's runId rather than allocating a new one.
+            let runId;
+            if (parsed.subagentId !== undefined) {
+                if (parsed.parentRunId === undefined) {
+                    throw new Error("parentRunId is required when subagentId is set");
+                }
+                // Confirm the parent's run row exists before materializing a child
+                // under it — otherwise we'd silently create an orphan subagent row.
+                const parent = await hubDb.run_session.findFirst({
+                    where: {
+                        user_id: parsed.userId,
+                        run_id: parsed.parentRunId,
+                        subagent_id: 0,
+                    },
+                    select: { run_id: true },
+                });
+                if (!parent) {
+                    throw new Error(`parent run ${parsed.parentRunId} not found for user ${parsed.userId}`);
+                }
+                runId = parsed.parentRunId;
+            }
+            else {
+                const lastRun = await hubDb.run_session.findFirst({
+                    select: { run_id: true },
+                    orderBy: { run_id: "desc" },
+                });
+                runId = lastRun ? lastRun.run_id + 1 : 1;
+            }
+            const subagentId = parsed.subagentId ?? 0;
             const newSessionId = 1;
             const now = new Date().toISOString();
             await hubDb.run_session.create({
                 data: {
                     user_id: parsed.userId,
-                    run_id: newRunId,
+                    run_id: runId,
+                    subagent_id: subagentId,
                     session_id: newSessionId,
                     host_id: hostId,
                     model_name: parsed.modelName,
@@ -35,12 +59,13 @@ export function createHubRunService(naisysServer, { hubDb }, logService) {
             });
             ack({
                 success: true,
-                runId: newRunId,
+                runId,
                 sessionId: newSessionId,
             });
             pushSessionToSupervisors({
                 userId: parsed.userId,
-                runId: newRunId,
+                runId,
+                subagentId: parsed.subagentId,
                 sessionId: newSessionId,
                 modelName: parsed.modelName,
                 createdAt: now,
@@ -55,12 +80,14 @@ export function createHubRunService(naisysServer, { hubDb }, logService) {
     naisysServer.registerEvent(HubEvents.SESSION_INCREMENT, async (hostId, data, ack) => {
         try {
             const parsed = SessionIncrementRequestSchema.parse(data);
-            // Get the max session_id for this user + run
+            const subagentId = parsed.subagentId ?? 0;
+            // Get the max session_id for this user + run + subagent
             const lastSession = await hubDb.run_session.findFirst({
                 select: { session_id: true },
                 where: {
                     user_id: parsed.userId,
                     run_id: parsed.runId,
+                    subagent_id: subagentId,
                 },
                 orderBy: { session_id: "desc" },
             });
@@ -70,6 +97,7 @@ export function createHubRunService(naisysServer, { hubDb }, logService) {
                 data: {
                     user_id: parsed.userId,
                     run_id: parsed.runId,
+                    subagent_id: subagentId,
                     session_id: newSessionId,
                     host_id: hostId,
                     model_name: parsed.modelName,
@@ -81,6 +109,7 @@ export function createHubRunService(naisysServer, { hubDb }, logService) {
             pushSessionToSupervisors({
                 userId: parsed.userId,
                 runId: parsed.runId,
+                subagentId: parsed.subagentId,
                 sessionId: newSessionId,
                 modelName: parsed.modelName,
                 createdAt: now,

package/dist/handlers/hubUserService.js

@@ -10,7 +10,6 @@ export function createHubUserService(naisysServer, { hubDb }, logService) {
                 enabled: true,
                 config: true,
                 lead_user_id: true,
-                api_key: true,
                 user_hosts: {
                     select: { host_id: true },
                 },
@@ -25,7 +24,6 @@ export function createHubUserService(naisysServer, { hubDb }, logService) {
             assignedHostIds: u.user_hosts.length > 0
                 ? u.user_hosts.map((uh) => uh.host_id)
                 : undefined,
-            apiKey: u.api_key || undefined,
         }));
         return { success: true, users };
     }

package/dist/naisysHub.js

@@ -1,4 +1,4 @@
-import { createDualLogger, cwdWithTilde, ensureDotEnv, expandNaisysFolder, promptResetSuperAdminPasskey, runSetupWizard, } from "@naisys/common-node";
+import { createDualLogger, cwdWithTilde, ensureDotEnv, expandNaisysFolder, promptResetSuperAdminAccount, runSetupWizard, } from "@naisys/common-node";
 import { createHubDatabaseService } from "@naisys/hub-database";
 import { program } from "commander";
 import dotenv from "dotenv";
@@ -29,6 +29,7 @@ import { createNaisysServer } from "./services/naisysServer.js";
 export const startHub = async (startupType, startSupervisor, plugins, startupAgentPath, wizardRan) => {
     try {
         const agentPath = startupAgentPath || ".";
+        let cleanupSupervisor;
         // Create log service first
         const logService = createDualLogger("hub-server.log");
         logService.log(`[Hub] Starting Hub server in ${startupType} mode...`);
@@ -43,8 +44,9 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         await seedAgentConfigs(hubDatabaseService, logService, agentPath);
         // Create host registrar for tracking NAISYS instance connections
         const hostRegistrar = await createHostRegistrar(hubDatabaseService);
-        // Create Fastify instance (TLS is handled by the reverse proxy)
-        const fastify = Fastify({ pluginTimeout: 60_000 });
+        // trustProxy: TLS terminates at the reverse proxy, so honor X-Forwarded-*
+        // headers — otherwise request.protocol reads the internal http hop.
+        const fastify = Fastify({ pluginTimeout: 60_000, trustProxy: true });
         // Register HTTP attachment upload/download routes
         createHubAttachmentService(fastify, hubDatabaseService, logService);
         // Attach Socket.IO to the underlying HTTP server.
@@ -78,7 +80,7 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         // Register hub agent service for agent_start requests routed to target hosts
         const agentService = createHubAgentService(naisysServer, hubDatabaseService, logService, heartbeatService, sendMailService, hostRegistrar);
         // Register hub mail service for mail events from NAISYS instances
-        createHubMailService(naisysServer, hubDatabaseService, logService, heartbeatService, sendMailService, agentService, costService, configService);
+        const mailService = createHubMailService(naisysServer, hubDatabaseService, logService, heartbeatService, sendMailService, agentService, costService, configService);
         /**
          * There should be no dependency between supervisor and hub
          * Sharing the same process space is to save 150 mb of node.js runtime memory on small servers
@@ -87,12 +89,16 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
             // Don't import the whole fastify web server module tree unless needed
             // Use variable to avoid compile-time type dependency on @naisys/supervisor (allows parallel builds)
             const supervisorModule = "@naisys/supervisor";
-            const { supervisorPlugin, bootstrapSupervisor } = (await import(supervisorModule));
-            const resetSuperAdminPasskey = wizardRan
-                ? await promptResetSuperAdminPasskey("Supervisor Setup")
+            const hostedSupervisor = (await import(supervisorModule));
+            const { supervisorPlugin, bootstrapSupervisor } = hostedSupervisor;
+            cleanupSupervisor = hostedSupervisor.cleanupSupervisor;
+            const resetSuperAdminAccount = wizardRan
+                ? await promptResetSuperAdminAccount("Supervisor Setup", {
+                    defaultReset: !process.argv.includes("--setup"),
+                })
                 : false;
             // Bootstrap before plugin register so the operator prompt isn't bounded by pluginTimeout and doesn't interleave with hub connection logs.
-            await bootstrapSupervisor({ resetSuperAdminPasskey });
+            await bootstrapSupervisor({ resetSuperAdminAccount });
             await fastify.register(supervisorPlugin, {
                 plugins,
                 serverPort,
@@ -105,6 +111,24 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         if (startupType === "hosted") {
             logService.disableConsole();
         }
+        let shutdownPromise = null;
+        // Like NAISYS: process exit reaps sockets and Fastify. Clear known timers
+        // synchronously, but only wait for the DB disconnect.
+        async function runShutdown() {
+            try {
+                cleanupSupervisor?.();
+                heartbeatService.cleanup();
+                costService.cleanup();
+                mailService.cleanup();
+            }
+            finally {
+                await hubDatabaseService.disconnect();
+            }
+        }
+        const shutdown = () => {
+            shutdownPromise ??= runShutdown();
+            return shutdownPromise;
+        };
         // Hosted mode: parent process owns signal handling
         if (startupType === "standalone") {
             let shuttingDown = false;
@@ -116,8 +140,7 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
                 shuttingDown = true;
                 logService.log(`[Hub] Shutting down (${signal})...`);
                 try {
-                    await io.close();
-                    await fastify.close();
+                    await shutdown();
                 }
                 catch (err) {
                     console.error("[Hub] Error during shutdown:", err);
@@ -127,7 +150,7 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
             process.on("SIGTERM", () => void handleShutdown("SIGTERM"));
             process.on("SIGINT", () => void handleShutdown("SIGINT"));
         }
-        return { serverPort };
+        return { serverPort, shutdown };
     }
     catch (err) {
         console.error("[Hub] Failed to start hub server:", err);

package/dist/services/agentRegistrar.js

@@ -1,6 +1,6 @@
 import { adminAgentConfig, toUrlSafeKey } from "@naisys/common";
 import { loadAgentConfigs } from "@naisys/common-node";
-import { randomBytes, randomUUID } from "crypto";
+import { randomUUID } from "crypto";
 /** Seeds agent configs from YAML files into an empty database. Skips if users already exist. */
 export async function seedAgentConfigs({ hubDb }, logService, startupAgentPath) {
     // Check if users table already has rows (seed-once pattern)
@@ -38,7 +38,6 @@ async function seedUsersToDatabase(hubDb, logService, users) {
                 username: safeUsername,
                 title: user.config.title,
                 config: JSON.stringify({ ...user.config, username: safeUsername }),
-                api_key: randomBytes(32).toString("hex"),
             },
         });
         loaderIdToDbId.set(user.userId, dbUser.id);

package/dist/services/naisysServer.js

@@ -68,7 +68,10 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
         const { hubAccessKey: clientAccessKey, hostName, machineId: rawMachineId, instanceId: rawInstanceId, startedAt: rawStartedAt, hostType: rawHostType, clientVersion, environment: rawEnvironment, } = socket.handshake.auth;
         if (!clientAccessKey || clientAccessKey !== hubAccessKey) {
             logService.log(`[Hub] Connection rejected: invalid access key from ${socket.handshake.address}`);
-            return next(createConnectError("Invalid access key", "invalid_access_key"));
+            // Non-fatal: keys can rotate while a client is in retry; the client's
+            // auth callback re-reads the key on each attempt so the next try picks
+            // up the new value.
+            return next(createConnectError("Invalid access key", "invalid_access_key", false));
         }
         if (!hostName) {
             logService.log(`[Hub] Connection rejected: missing hostName`);
@@ -123,7 +126,9 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
         }
         catch (err) {
             logService.error(`[Hub] Connection rejected: failed to register host ${hostName}: ${err}`);
-            return next(createConnectError("NAISYS instance registration failed", "registration_failed"));
+            // Non-fatal: registration touches the DB and can hit transient failures
+            // (pool timeout, deadlock); let the client keep retrying.
+            return next(createConnectError("NAISYS instance registration failed", "registration_failed", false));
         }
     });
     // Handle new connections

package/npm-shrinkwrap.json

@@ -1,17 +1,17 @@
 {
   "name": "@naisys/hub",
-  "version": "3.0.0-beta.37",
+  "version": "3.0.0-beta.39",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@naisys/hub",
-      "version": "3.0.0-beta.37",
+      "version": "3.0.0-beta.39",
       "dependencies": {
-        "@naisys/common": "3.0.0-beta.37",
-        "@naisys/common-node": "3.0.0-beta.37",
-        "@naisys/hub-database": "3.0.0-beta.37",
-        "@naisys/hub-protocol": "3.0.0-beta.37",
+        "@naisys/common": "3.0.0-beta.39",
+        "@naisys/common-node": "3.0.0-beta.39",
+        "@naisys/hub-database": "3.0.0-beta.39",
+        "@naisys/hub-protocol": "3.0.0-beta.39",
         "commander": "^14.0.3",
         "dotenv": "^17.3.1",
         "fastify": "^5.8.2",
@@ -24,7 +24,7 @@
         "node": ">=22.0.0"
       },
       "peerDependencies": {
-        "@naisys/supervisor": "3.0.0-beta.37"
+        "@naisys/supervisor": "3.0.0-beta.39"
       },
       "peerDependenciesMeta": {
         "@naisys/supervisor": {
@@ -189,32 +189,32 @@
       "license": "MIT"
     },
     "node_modules/@naisys/common": {
-      "version": "3.0.0-beta.37",
-      "resolved": "https://registry.npmjs.org/@naisys/common/-/common-3.0.0-beta.37.tgz",
-      "integrity": "sha512-b0XfCadaPcfewmK9b649WD+ZGB86Uk9BjTrx/tLSgd5Nbx7L6NuzTqTnDFScdeCmtyPk4oUGAzATmXwKTM8bew==",
+      "version": "3.0.0-beta.39",
+      "resolved": "https://registry.npmjs.org/@naisys/common/-/common-3.0.0-beta.39.tgz",
+      "integrity": "sha512-H65s+TNhjKC+6piF9sP9LpydRL+K7IEyD6gUgXDekiQ1+6OV9xgxzZmeOgTAGs/Mk3fSs73OJ6JC4WPjBwVSdA==",
       "dependencies": {
         "semver": "^7.7.4",
         "zod": "^4.3.6"
       }
     },
     "node_modules/@naisys/common-node": {
-      "version": "3.0.0-beta.37",
-      "resolved": "https://registry.npmjs.org/@naisys/common-node/-/common-node-3.0.0-beta.37.tgz",
-      "integrity": "sha512-V4yyA79G93OSqZ+6l5FWoMqnATE2It78VkGyziNTqcrv2CIf8UDGbds7hHV+bp/0VplNe6BrZ4P7quYvgyCeeQ==",
+      "version": "3.0.0-beta.39",
+      "resolved": "https://registry.npmjs.org/@naisys/common-node/-/common-node-3.0.0-beta.39.tgz",
+      "integrity": "sha512-UGQwcHx8hbeTHjYKYB0Y9BQouwip614bOxUXeo2U+552gUTjmdjc2T7ng14opVqtZmYYzTidLWQrblS8mNa+sw==",
       "dependencies": {
-        "@naisys/common": "3.0.0-beta.37",
+        "@naisys/common": "3.0.0-beta.39",
         "better-sqlite3": "^12.6.2",
         "js-yaml": "^4.1.1",
         "pino": "^10.3.1"
       }
     },
     "node_modules/@naisys/hub-database": {
-      "version": "3.0.0-beta.37",
-      "resolved": "https://registry.npmjs.org/@naisys/hub-database/-/hub-database-3.0.0-beta.37.tgz",
-      "integrity": "sha512-PI8Jj4niCc6agObLWpP+Am8nrNcwAAk77/OmZmUWq1ZiBW+m5C60PFdfBvzLEZX/6G/JOb0VvI9oLpzFD6VRKg==",
+      "version": "3.0.0-beta.39",
+      "resolved": "https://registry.npmjs.org/@naisys/hub-database/-/hub-database-3.0.0-beta.39.tgz",
+      "integrity": "sha512-rTKKwhRWGp/5LcBiFLurY3VYdk6a5YNiEj7nfGMWYGbTozTw1X6PlCoBT3UV6g/brFPKDIlsS9tMDAhI/ibuuw==",
       "dependencies": {
-        "@naisys/common": "3.0.0-beta.37",
-        "@naisys/common-node": "3.0.0-beta.37",
+        "@naisys/common": "3.0.0-beta.39",
+        "@naisys/common-node": "3.0.0-beta.39",
         "@prisma/adapter-better-sqlite3": "^7.5.0",
         "@prisma/client": "^7.5.0",
         "better-sqlite3": "^12.6.2",
@@ -222,11 +222,11 @@
       }
     },
     "node_modules/@naisys/hub-protocol": {
-      "version": "3.0.0-beta.37",
-      "resolved": "https://registry.npmjs.org/@naisys/hub-protocol/-/hub-protocol-3.0.0-beta.37.tgz",
-      "integrity": "sha512-hJ7kr4WT6TfCmVQFPCfnjC4Sjp7DehuZ4la+z5/MZ3AEm6Ds/WxqcoPOf1F47y6uZA70WhnVHvAt/dci0dO8Ow==",
+      "version": "3.0.0-beta.39",
+      "resolved": "https://registry.npmjs.org/@naisys/hub-protocol/-/hub-protocol-3.0.0-beta.39.tgz",
+      "integrity": "sha512-zYBhBSVuN/RlEiMpY4ke2J9SwL5Nyd4VNZmP2ZH7hXiL3bDlp8K3odZQqfd1kIUKidnhNzqEH4H+CLOwB4kJPA==",
       "dependencies": {
-        "@naisys/common": "3.0.0-beta.37",
+        "@naisys/common": "3.0.0-beta.39",
         "zod": "^4.3.6"
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naisys/hub",
-  "version": "3.0.0-beta.37",
+  "version": "3.0.0-beta.39",
   "description": "NAISYS Hub - Adds persistence and multi-instance coordination to NAISYS",
   "type": "module",
   "main": "dist/naisysHub.js",
@@ -17,6 +17,7 @@
     "dev": "tsx watch src/naisysHub.ts",
     "start": "node dist/naisysHub.js",
     "build": "tsc",
+    "test": "vitest run",
     "type-check": "tsc --noEmit",
     "npm:publish:dryrun": "npm publish --dry-run",
     "npm:publish": "npm publish --access public"
@@ -31,7 +32,7 @@
     "!dist/**/*.d.ts.map"
   ],
   "peerDependencies": {
-    "@naisys/supervisor": "3.0.0-beta.37"
+    "@naisys/supervisor": "3.0.0-beta.39"
   },
   "peerDependenciesMeta": {
     "@naisys/supervisor": {
@@ -39,10 +40,10 @@
     }
   },
   "dependencies": {
-    "@naisys/common": "3.0.0-beta.37",
-    "@naisys/common-node": "3.0.0-beta.37",
-    "@naisys/hub-database": "3.0.0-beta.37",
-    "@naisys/hub-protocol": "3.0.0-beta.37",
+    "@naisys/common": "3.0.0-beta.39",
+    "@naisys/common-node": "3.0.0-beta.39",
+    "@naisys/hub-database": "3.0.0-beta.39",
+    "@naisys/hub-protocol": "3.0.0-beta.39",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fastify": "^5.8.2",
@@ -51,7 +52,8 @@
   "devDependencies": {
     "@types/node": "^25.5.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
   },
   "engines": {
     "node": ">=22.0.0"