@hivemagnus/magnus-server 1.1.13 → 2.1.0

package/dist/routes/terminal-ticket.js

@@ -3,13 +3,13 @@ import { authMiddleware, requireRole } from '../middleware/auth.js';
 export const terminalTicketRouter = new Hono();
 terminalTicketRouter.use('*', authMiddleware);
 terminalTicketRouter.use('*', requireRole('ADMIN', 'OPERATOR'));
-/** The password-backed Control API terminal is retired; use the dashboard's
- * dedicated restricted key and inventory-pinned terminal transport. */
+/** The password-backed Control API terminal is retired. The web terminal lives in the separate
+ * fleet gateway, so this process never holds the restricted SSH key. */
 terminalTicketRouter.post('/ticket', (c) => c.json({
     success: false,
     error: {
         code: 'TERMINAL_RETIRED',
-        message: 'Control API terminal tickets are retired; use the dashboard terminal.',
+        message: 'Control API terminal tickets are retired; the fleet gateway carries the web terminal.',
     },
 }, 410));
 //# sourceMappingURL=terminal-ticket.js.map

package/dist/routes/terminal.js

@@ -1,8 +1,8 @@
 import { WebSocketServer } from 'ws';
 /**
  * The former Control API terminal used retired reusable SSH passwords. Keep a
- * deterministic upgrade rejection so old clients fail closed while the
- * dashboard's separately scoped, host-key-pinned terminal remains available.
+ * deterministic upgrade rejection so old clients fail closed. The web terminal
+ * lives in the fleet gateway, so this process never holds the restricted SSH key.
  */
 export function setupTerminalWebSocket(server) {
     const wss = new WebSocketServer({ noServer: true });

package/dist/routes/webhooks.js

@@ -3,7 +3,7 @@ import { authMiddleware, getUser, requireRole } from '../middleware/auth.js';
 import { logAuditEvent } from '../services/audit-service.js';
 import { HttpError } from '../middleware/error-handler.js';
 import { listWebhookEndpoints, getWebhookEndpoint, createWebhookEndpoint, updateWebhookEndpoint, deleteWebhookEndpoint, listDeliveries, testWebhookEndpoint, dispatchWebhook, redeliverWebhookDelivery, } from '../services/webhook-service.js';
-import { validateWebhookTarget } from '../services/webhook-security.js';
+import { validateWebhookTarget, WebhookOriginNotAllowedError } from '../services/webhook-security.js';
 /** Audit only the target origin: webhook paths and queries often embed tokens. */
 function webhookOrigin(url) {
     try {
@@ -13,6 +13,17 @@ function webhookOrigin(url) {
         return 'invalid';
     }
 }
+/** Refused targets stay indistinguishable, so this cannot probe DNS or internal addresses. Only the allowlist is explained. */
+async function assertApprovedTarget(url) {
+    try {
+        await validateWebhookTarget(url);
+    }
+    catch (error) {
+        if (error instanceof WebhookOriginNotAllowedError)
+            throw new HttpError(400, 'VALIDATION_ERROR', error.message);
+        throw new HttpError(400, 'VALIDATION_ERROR', 'Webhook target is not an approved public HTTPS endpoint');
+    }
+}
 export const webhooksRouter = new Hono();
 // All webhook routes require ADMIN role
 webhooksRouter.use('*', authMiddleware);
@@ -35,12 +46,7 @@ webhooksRouter.post('/', async (c) => {
     if (!body.name || !body.url) {
         throw new HttpError(400, 'VALIDATION_ERROR', 'name and url are required');
     }
-    try {
-        await validateWebhookTarget(body.url);
-    }
-    catch {
-        throw new HttpError(400, 'VALIDATION_ERROR', 'Webhook target is not an approved public HTTPS endpoint');
-    }
+    await assertApprovedTarget(body.url);
     const user = c.get('user');
     const endpoint = await createWebhookEndpoint({
         ...body,
@@ -61,14 +67,8 @@ webhooksRouter.patch('/:id', async (c) => {
     if (!existing)
         throw new HttpError(404, 'NOT_FOUND', 'Webhook endpoint not found');
     const body = await c.req.json();
-    if (body.url !== undefined) {
-        try {
-            await validateWebhookTarget(body.url);
-        }
-        catch {
-            throw new HttpError(400, 'VALIDATION_ERROR', 'Webhook target is not an approved public HTTPS endpoint');
-        }
-    }
+    if (body.url !== undefined)
+        await assertApprovedTarget(body.url);
     const endpoint = await updateWebhookEndpoint(id, body);
     // Record which fields changed, never secret or header values.
     await logAuditEvent({

package/dist/sdk/node-api-client.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { assertLiveExecution } from '../config/rehearsal.js';
 import { MANAGED_CLAIM_HEADER, credentialMutationIdentity, httpIdentity, httpReceiptBody, managedHttpRequestSchema } from '../security/managed-http.js';
 import { nativeCompletionDescriptor, nativeCompletionResourceKey } from '../security/native-completion-registry.js';
 import { COMMAND_COMPLETION_REGISTRY, COMMAND_COMPLETION_REGISTRY_SHA256, commandCompletionDescriptor } from '../security/command-completion-registry.js';
@@ -201,7 +202,7 @@ export class NodeApiClient {
             headers: {
                 'x-node-token': options.nodeToken,
             },
-            hooks: { afterResponse: [rejectUnprivilegedAgent] },
+            hooks: { beforeRequest: [() => assertLiveExecution()], afterResponse: [rejectUnprivilegedAgent] },
         });
     }
     /** All finite native mutations use the same central owner and node execution slot. */
@@ -302,6 +303,27 @@ export class NodeApiClient {
         return { response: result.response, evidence: result.evidence };
     }
     // ── Health ──
+    async hiveSkillsTargetPosture(target, registryId) {
+        return this.api.get('hiveskills/targets/' + encodeURIComponent(target), { searchParams: { registryId }, retry: 0 }).json();
+    }
+    async syncHiveSkills(body, commandId) {
+        const result = await this.mutateWithEvidence('POST', 'hiveskills/sync', body, 120000, commandId, undefined, true);
+        if (!result.evidence)
+            throw new Error('Skills execution requires an enrolled node and signed receipt');
+        return { response: result.response, evidence: result.evidence };
+    }
+    async securityResponseCapable() {
+        const reply = await this.api.get('ping', { timeout: 5000, retry: 0 }).json();
+        return reply.success === true && reply.data?.features?.securityResponse === 1;
+    }
+    async securityResponse(body, commandId) {
+        if (!await this.securityResponseCapable())
+            throw new HttpError(409, 'RESPONSE_DISABLED', 'Target has not enabled its managed response adapter');
+        const result = await this.mutateWithEvidence('POST', 'security-response', body, 120000, commandId, undefined, true);
+        if (!result.evidence)
+            throw new Error('Response requires a signed managed receipt');
+        return { response: result.response, evidence: result.evidence };
+    }
     async collectHealth() {
         return this.api.get('health/collect').json();
     }

package/dist/security/cindertrace-response.js

@@ -0,0 +1,14 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export function bridgeSignature(secret, method, path, timestamp, nonce, body) {
+    if (secret.length < 32)
+        throw new Error('Dedicated bridge secret is required');
+    return createHmac('sha256', secret)
+        .update(`cindertrace.magnus-response.v1\n${method}\n${path}\n${timestamp}\n${nonce}\n${body}`)
+        .digest('hex');
+}
+export function equalSignature(a, b) {
+    return (/^[a-f0-9]{64}$/.test(a) &&
+        /^[a-f0-9]{64}$/.test(b) &&
+        timingSafeEqual(Buffer.from(a, 'hex'), Buffer.from(b, 'hex')));
+}
+//# sourceMappingURL=cindertrace-response.js.map

package/dist/security/native-completion-registry.js

@@ -2,6 +2,10 @@ import { createHash } from 'node:crypto';
 export const NATIVE_COMPLETION_REGISTRY = {
     version: 1,
     descriptors: [
+        { id: 'hiveskills-sync', method: 'POST', pathMatcher: { kind: 'exact', path: '/hiveskills/sync' },
+            completionMode: 'buffered-synchronous-http', timeoutCeilingSeconds: 120, resourceClassifier: 'node-skill-catalog' },
+        { id: 'security-response', method: 'POST', pathMatcher: { kind: 'exact', path: '/security-response' },
+            completionMode: 'buffered-synchronous-http', timeoutCeilingSeconds: 120, resourceClassifier: 'node-filesystem' },
         { id: 'file-write', method: 'POST', pathMatcher: { kind: 'exact', path: '/files/write' },
             completionMode: 'buffered-synchronous-http', timeoutCeilingSeconds: 3600, resourceClassifier: 'node-filesystem' },
         { id: 'skill-install', method: 'POST', pathMatcher: { kind: 'exact', path: '/skills/install' },
@@ -43,4 +47,14 @@ export function nativeCompletionResourceKey(descriptor, nodeId) {
         throw new Error('Native completion resource cannot be classified');
     return descriptor.resourceClassifier === 'node-ardent' ? `node:${nodeId}:ardent` : `node:${nodeId}`;
 }
+/** Preserve settlement of pre-extraction leases without granting the new response boundary retroactively. */
+export function knownNativeCompletionIdentity(version, sha256, descriptorId) {
+    if (version !== 1 || !descriptorId)
+        return false;
+    const descriptor = NATIVE_COMPLETION_REGISTRY.descriptors.find(item => item.id === descriptorId);
+    if (!descriptor)
+        return false;
+    return sha256 === NATIVE_COMPLETION_REGISTRY_SHA256 || (descriptorId !== 'hiveskills-sync' && sha256 === 'e1303b169387f536c257e686eb95a29c1ff9b09e26fc38ac0d71d6c0daf9eb55') || (descriptorId !== 'security-response' && descriptorId !== 'hiveskills-sync'
+        && sha256 === 'b0f05a1eac40dba262ec5ff0cc0de8d2b7c9f119a6a2d7ed3a00d94dcb6b1d3d');
+}
 //# sourceMappingURL=native-completion-registry.js.map

package/dist/server.js

@@ -1,8 +1,8 @@
+import { cindertraceResponseRouter } from './routes/cindertrace-response.js';
 import { resourceLeasesRouter } from './routes/resource-leases.js';
 import { sharedResourceLeasesRouter } from './routes/shared-resource-leases.js';
 import { securityBackupRouter } from './routes/security-backup.js';
 import { securityIntegrationRouter } from './routes/security-integration.js';
-import { securityConsoleUrl, securityFusionMode } from './services/security-export.js';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { logger } from 'hono/logger';
@@ -17,6 +17,7 @@ import { nodesRouter } from './routes/nodes.js';
 import { commandsRouter } from './routes/commands.js';
 import { cronRouter } from './routes/cron.js';
 import { filesRouter } from './routes/files.js';
+import { hiveskillsRouter } from './routes/hiveskills.js';
 import { skillsRouter } from './routes/skills.js';
 import { logsRouter } from './routes/logs.js';
 import { healthRouter } from './routes/health.js';
@@ -34,6 +35,7 @@ import { systemUpdatesRouter } from './routes/system-updates.js';
 import { agentUpgradesRouter } from './routes/agent-upgrades.js';
 import { scanRouter } from './routes/scan.js';
 import { terminalTicketRouter } from './routes/terminal-ticket.js';
+import { fleetGatewayRouter } from './routes/fleet-gateway.js';
 import { usersRouter, authRouter } from './routes/users.js';
 import { docsRouter } from './routes/docs.js';
 import { webhooksRouter } from './routes/webhooks.js';
@@ -61,8 +63,11 @@ import { fleetChecksRouter } from './routes/fleet-checks.js';
 import { opsRouter } from './routes/ops.js';
 import { mcpRouter } from './routes/mcp.js';
 import { securityFusionRouter } from './routes/security-fusion.js';
+import { consoleRouter } from './routes/console.js';
 import { resolveCorsConfiguration } from './config/cors.js';
+import { rehearsalReadOnly } from './config/rehearsal.js';
 export const app = new Hono();
+app.use('*', rehearsalReadOnly);
 // ── Global middleware ──
 app.use('*', logger());
 app.use('*', correlationId);
@@ -85,6 +90,7 @@ app.use('/api/v1/*', requestLogger);
 app.use('/api/v1/security-fusion/ingest/events', bodyLimitMiddleware(Math.min(Math.max(Number(process.env['SECURITY_FUSION_INGEST_MAX_BYTES']) || 262_144, 1), 262_144)));
 app.use('/api/v1/security-fusion/ingest/source-status', bodyLimitMiddleware(32_768));
 app.route('/api/v1/security-integration/backups', securityBackupRouter);
+app.use('/api/v1/security-integration/response/*', bodyLimitMiddleware(16_384));
 app.use('/api/v1/*', async (c, next) => {
     const limit = c.req.path === '/api/v1/hermes-registry/capture' || c.req.path === '/api/v1/hermes-registry/revisions'
         ? 4_500_000 : Number(process.env['API_BODY_LIMIT_BYTES'] ?? 1_048_576);
@@ -117,6 +123,7 @@ v1.route('/shared-resource-leases', sharedResourceLeasesRouter);
 v1.route('/cron', cronRouter);
 v1.route('/files', filesRouter);
 v1.route('/skills', skillsRouter);
+v1.route('/hiveskills', hiveskillsRouter);
 v1.route('/logs', logsRouter);
 v1.route('/health', healthRouter);
 v1.route('/audit', auditRouter);
@@ -133,6 +140,7 @@ v1.route('/system/updates', systemUpdatesRouter);
 v1.route('/agents/upgrade', agentUpgradesRouter);
 v1.route('/scan', scanRouter);
 v1.route('/terminal', terminalTicketRouter);
+v1.route('/fleet-gateway', fleetGatewayRouter);
 v1.route('/users', usersRouter);
 v1.route('/auth', authRouter);
 v1.route('/webhooks', webhooksRouter);
@@ -157,22 +165,11 @@ v1.route('/ai-schedules', aiScheduleRouter);
 v1.route('/profiling', profilingRouter);
 v1.route('/assistant', assistantRouter);
 v1.route('/events/stream', eventsStreamRouter);
+v1.route('/console', consoleRouter);
 v1.route('/ops', opsRouter);
 v1.route('/mcp', mcpRouter);
+v1.route('/security-integration/response', cindertraceResponseRouter);
 v1.route('/security-integration', securityIntegrationRouter);
-v1.use('/security-fusion/*', async (c, next) => {
-    const mode = securityFusionMode();
-    if (mode === 'remote') {
-        const url = securityConsoleUrl();
-        return c.json({ success: false, error: { code: 'SECURITY_FUSION_MOVED',
-                message: 'Security Fusion is served by the external security console', ...(url ? { url } : {}) } }, 410);
-    }
-    if (mode === 'off') {
-        return c.json({ success: false, error: { code: 'SECURITY_FUSION_DISABLED',
-                message: 'Security Fusion is disabled; set SECURITY_FUSION_MODE=local or remote to enable it' } }, 404);
-    }
-    await next();
-});
 v1.route('/security-fusion', securityFusionRouter);
 app.route('/api/v1', v1);
 // ── API documentation (Swagger UI + OpenAPI spec) ──

package/dist/services/ai-assistant-service.js

@@ -13,6 +13,7 @@ import { z } from 'zod';
 import { getDb } from '../db/index.js';
 import { executeAiTool, listAvailableTools } from './ai-tools.js';
 import { logAuditEvent } from './audit-service.js';
+import { clientErrorMessage } from '../utils/safe-errors.js';
 import { autoStoreToolResult, listScratchpadEntries } from './ai-scratchpad-service.js';
 import { getLlmProvider, getLlmProviderStatuses } from './llm-providers/index.js';
 import { getOllamaThinkingCapability } from './llm-providers/ollama.js';
@@ -1625,12 +1626,37 @@ export async function chat(request) {
     };
 }
 // ── Conversation list / message queries ──
+/** The values of `createdBy` that mean this caller: conversations store the email, or the user ID without one. */
+export function conversationOwners(user) {
+    return [...new Set([user?.email, user?.userId].filter((value) => Boolean(value)))];
+}
+/**
+ * The fleet heartbeat conversation is the server's own and describes the fleet, not
+ * anyone's work, and the anomaly page checks for it, so every role can read it.
+ */
+const SHARED_CONVERSATION = { createdBy: 'system', type: 'heartbeat' };
+/** What a caller may read: their own conversations and the shared heartbeat. */
+function readableConversations(owners) {
+    return { OR: [{ createdBy: { in: owners } }, SHARED_CONVERSATION] };
+}
+/** 'owner' may change a conversation, 'shared' may only read it, and null may not know it exists. */
+export async function getConversationAccess(conversationId, owners) {
+    const conversation = await getDb().aiConversation.findUnique({
+        where: { id: conversationId },
+        select: { createdBy: true, type: true },
+    });
+    if (!conversation)
+        return null;
+    if (owners.includes(conversation.createdBy))
+        return 'owner';
+    return conversation.createdBy === SHARED_CONVERSATION.createdBy && conversation.type === SHARED_CONVERSATION.type ? 'shared' : null;
+}
 export async function listConversations(params) {
     const db = getDb();
     const page = params.page ?? 1;
     const pageSize = Math.min(params.pageSize ?? 20, 50);
     const skip = (page - 1) * pageSize;
-    const where = {};
+    const where = readableConversations(params.owners);
     if (params.type)
         where['type'] = params.type;
     // 'all' is a sentinel meaning no status filter
@@ -1689,16 +1715,16 @@ export async function getConversationMessages(conversationId, params) {
         total,
     };
 }
-export async function getUnreadAiMessageCount() {
+export async function getUnreadAiMessageCount(owners) {
     const db = getDb();
     return db.aiMessage.count({
-        where: { role: 'assistant', isRead: false },
+        where: { role: 'assistant', isRead: false, conversation: readableConversations(owners) },
     });
 }
-export async function markAiMessagesRead(messageIds) {
+export async function markAiMessagesRead(messageIds, owners) {
     const db = getDb();
     const result = await db.aiMessage.updateMany({
-        where: { id: { in: messageIds }, isRead: false },
+        where: { id: { in: messageIds }, isRead: false, conversation: readableConversations(owners) },
         data: { isRead: true, readAt: new Date() },
     });
     return result.count;
@@ -2435,7 +2461,7 @@ export async function chatStream(request, onEvent) {
     catch (err) {
         onEvent({
             event: 'error',
-            data: { message: err instanceof Error ? err.message : 'Unknown streaming error' },
+            data: { message: clientErrorMessage(err, 'Unknown streaming error') },
         });
     }
 }

package/dist/services/ai-tools.js

@@ -15,11 +15,14 @@ import { logAuditEvent } from './audit-service.js';
 import { listSkills, getSkill, getSkillFile, createSkill } from './skill-service.js';
 import { NodeApiClient } from '../sdk/node-api-client.js';
 import { getNodeBaseUrl } from '../utils/node-url.js';
+import { SENTINEL_NODE_IDS } from '../utils/sentinel-nodes.js';
+import { clientErrorMessage } from '../utils/safe-errors.js';
 import { getNodeManagerSecret } from '../utils/env.js';
 import { correlateAnomalies, getAnomalyTimeline } from './ai-correlation-service.js';
 import { getHiveMemClient } from './hivemem-client.js';
 import { aliasScratchpadEntry, compareScratchpadSnapshots, listScratchpadEntries, setScratchpadEntry, transformScratchpadData, } from './ai-scratchpad-service.js';
 import { getDependencyHealth, getFleetReadiness, getFleetTimeline, getPredictiveMaintenance, getIncidentSummary, classifyRemediationPlan, getHermesEffectiveState, getPackageSecurityPosture, } from './ops-service.js';
+import { nodeMetadataForRole } from './secret-views.js';
 import { getCodexFleetPosture } from './codex-service.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const WORKSPACE_ROOT = resolve(__dirname, '../..');
@@ -63,6 +66,7 @@ function parseWazuhPosture(value) {
 registerTool('getFleetStatus', async () => {
     const db = getDb();
     const nodes = await db.node.findMany({
+        where: { id: { notIn: SENTINEL_NODE_IDS } },
         orderBy: { name: 'asc' },
         select: {
             id: true,
@@ -168,6 +172,7 @@ registerTool('getNodeHealth', async (args) => {
 registerTool('getWazuhFleetStatus', async () => {
     const db = getDb();
     const nodes = await db.node.findMany({
+        where: { id: { notIn: SENTINEL_NODE_IDS } },
         orderBy: { name: 'asc' },
         select: {
             id: true,
@@ -206,6 +211,7 @@ registerTool('getWazuhFleetStatus', async () => {
 registerTool('getSystemUpdateFleetStatus', async () => {
     const db = getDb();
     const nodes = await db.node.findMany({
+        where: { id: { notIn: SENTINEL_NODE_IDS } },
         orderBy: { name: 'asc' },
         select: {
             id: true, name: true, hostname: true, status: true, lastHeartbeatAt: true,
@@ -569,7 +575,7 @@ registerTool('searchNodes', async (args) => {
     const status = args['status'] ? String(args['status']).toUpperCase() : undefined;
     if (!query && !status)
         return { error: 'query or status is required' };
-    const where = {};
+    const where = { id: { notIn: SENTINEL_NODE_IDS } };
     if (status)
         where['status'] = status;
     if (query) {
@@ -648,10 +654,10 @@ registerTool('getSkills', async () => {
 registerTool('getDashboardStats', async () => {
     const db = getDb();
     const [totalNodes, onlineNodes, offlineNodes, degradedNodes, totalCommands, runningCommands, pendingCommands, totalCronJobs, activeCronJobs,] = await Promise.all([
-        db.node.count(),
-        db.node.count({ where: { status: 'ONLINE' } }),
-        db.node.count({ where: { status: 'OFFLINE' } }),
-        db.node.count({ where: { status: 'DEGRADED' } }),
+        db.node.count({ where: { id: { notIn: SENTINEL_NODE_IDS } } }),
+        db.node.count({ where: { id: { notIn: SENTINEL_NODE_IDS }, status: 'ONLINE' } }),
+        db.node.count({ where: { id: { notIn: SENTINEL_NODE_IDS }, status: 'OFFLINE' } }),
+        db.node.count({ where: { id: { notIn: SENTINEL_NODE_IDS }, status: 'DEGRADED' } }),
         db.remoteCommand.count(),
         db.remoteCommand.count({ where: { status: 'RUNNING' } }),
         db.remoteCommand.count({ where: { status: 'PENDING' } }),
@@ -729,7 +735,8 @@ registerTool('getNodeDetails', async (args) => {
         os: node.os,
         arch: node.arch,
         tags: node.tags ? JSON.parse(node.tags) : [],
-        metadata: node.metadata ? JSON.parse(node.metadata) : {},
+        // Tool results reach a model provider and stored conversations whatever the caller's role.
+        metadata: node.metadata ? JSON.parse(nodeMetadataForRole(node.metadata, 'VIEWER')) : {},
         lastHeartbeatAt: node.lastHeartbeatAt?.toISOString() ?? null,
         createdAt: node.createdAt.toISOString(),
         updatedAt: node.updatedAt.toISOString(),
@@ -1182,7 +1189,7 @@ registerTool('executeNaturalCommand', async (args) => {
     else {
         // If no node specified, try to extract from intent text
         const nodes = await db.node.findMany({
-            where: { status: 'ONLINE' },
+            where: { id: { notIn: SENTINEL_NODE_IDS }, status: 'ONLINE' },
             select: { id: true, name: true, hostname: true },
         });
         for (const n of nodes) {
@@ -1332,7 +1339,7 @@ export async function executeAiTool(call) {
             name: call.name,
             success: false,
             result: null,
-            error: err instanceof Error ? err.message : 'Tool execution failed',
+            error: clientErrorMessage(err, 'Tool execution failed'),
         };
     }
 }

package/dist/services/ardent-scope-enrollment.js

@@ -3,7 +3,7 @@ import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
 import { z } from 'zod';
 import { getDb } from '../db/index.js';
 import { HttpError } from '../middleware/error-handler.js';
-import { apiDrainAttestationSchema, apiDrainAttestationSigningPayload, canonical, dashboardEnrollmentSecret, drainReceiptSchema, enrollmentSigningPayload } from './resource-enrollment.js';
+import { apiDrainAttestationSchema, apiDrainAttestationSigningPayload, canonical, assertDashboardStillAbsent, dashboardReceiptKey, drainReceiptSchema, enrollmentSigningPayload } from './resource-enrollment.js';
 import { lockResourceNode, resourceNodeIdentity } from './resource-node-lock.js';
 import { reconciliationSecret } from './resource-participant-work.js';
 import { RESULT_SIGNING_SECRET } from '../utils/env.js';
@@ -52,8 +52,10 @@ async function receiptHashes(tx, nodeId, nodeFqdn, epoch, barrierId) {
             fail();
         }
         const { signature, ...unsigned } = receipt;
+        if (participant === 'dashboard')
+            await assertDashboardStillAbsent(tx, nodeId);
         const key = participant === 'api' ? reconciliationSecret()
-            : participant === 'dashboard' ? dashboardEnrollmentSecret() : RESULT_SIGNING_SECRET;
+            : participant === 'dashboard' ? dashboardReceiptKey() : RESULT_SIGNING_SECRET;
         const payload = participant === 'api'
             ? apiDrainAttestationSigningPayload(unsigned)
             : enrollmentSigningPayload(unsigned);

package/dist/services/command-resource-leases.js

@@ -17,7 +17,7 @@ import { RESULT_SIGNING_SECRET, RESULT_SIGNING_PREVIOUS_SECRET } from '../utils/
 import { getNodeBaseUrl } from '../utils/node-url.js';
 import { COMMAND_COMPLETION_REGISTRY, COMMAND_COMPLETION_REGISTRY_SHA256, commandCompletionDescriptor } from '../security/command-completion-registry.js';
 import { MANAGED_HTTP_COMMAND } from '../security/managed-http.js';
-import { NATIVE_COMPLETION_REGISTRY, NATIVE_COMPLETION_REGISTRY_SHA256, nativeCompletionDescriptor, nativeCompletionResourceKey } from '../security/native-completion-registry.js';
+import { NATIVE_COMPLETION_REGISTRY, NATIVE_COMPLETION_REGISTRY_SHA256, nativeCompletionDescriptor, nativeCompletionResourceKey, knownNativeCompletionIdentity } from '../security/native-completion-registry.js';
 import { logAuditEvent } from './audit-service.js';
 const HELD = ['reserved', 'running', 'unknown'];
 export class ResourceLeaseConflict extends HttpError {
@@ -382,9 +382,7 @@ export async function settleResourceResult(commandId, result) {
         && row.completionRegistrySha256 === COMMAND_COMPLETION_REGISTRY_SHA256
         && COMMAND_COMPLETION_REGISTRY.descriptors.some(descriptor => descriptor.id === row.completionDescriptorId);
     const native = row.completionClass === 'native-http'
-        && row.completionRegistryVersion === NATIVE_COMPLETION_REGISTRY.version
-        && row.completionRegistrySha256 === NATIVE_COMPLETION_REGISTRY_SHA256
-        && NATIVE_COMPLETION_REGISTRY.descriptors.some(descriptor => descriptor.id === row.completionDescriptorId);
+        && knownNativeCompletionIdentity(row.completionRegistryVersion, row.completionRegistrySha256, row.completionDescriptorId);
     const scheduler = row.completionClass === 'managed-scheduler'
         && /^[a-f0-9]{64}$/.test(row.completionOccurrenceId ?? '')
         && /^[a-f0-9]{64}$/.test(row.completionSpecSha256 ?? '')

package/dist/services/forecast-service.js

@@ -1,4 +1,5 @@
 import { getDb } from '../db/index.js';
+import { SENTINEL_NODE_IDS } from '../utils/sentinel-nodes.js';
 function linearRegression(points) {
     const n = points.length;
     if (n < 2)
@@ -10,13 +11,17 @@ function linearRegression(points) {
     const denom = n * sumX2 - sumX ** 2;
     if (denom === 0)
         return { slope: 0, intercept: sumY / n, r2: 0 };
-    const slope = (n * sumXY - sumX * sumY) / denom;
-    const intercept = (sumY - slope * sumX) / n;
     // R² for confidence
     const yMean = sumY / n;
     const ssTot = points.reduce((a, p) => a + (p.y - yMean) ** 2, 0);
+    // Identical samples have no trend. The formula below would still answer with a
+    // rounding residue, which reads as a tiny growth rate at full confidence.
     if (ssTot === 0)
-        return { slope, intercept, r2: 1 };
+        return { slope: 0, intercept: yMean, r2: 1 };
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    if (!Number.isFinite(slope))
+        return { slope: 0, intercept: yMean, r2: 0 };
     const ssRes = points.reduce((a, p) => a + (p.y - (slope * p.x + intercept)) ** 2, 0);
     const r2 = 1 - ssRes / ssTot;
     return { slope, intercept, r2 };
@@ -26,6 +31,10 @@ const MS_PER_DAY = 86_400_000;
 const MIN_DATA_POINTS = 3;
 const MIN_FORECAST_CONFIDENCE = 0.25;
 const DEFAULT_LOOKBACK_DAYS = 30;
+/** Samples closer together than this are a burst, not a growth trend. */
+const MIN_TREND_SPAN_MS = 60 * 60 * 1000;
+/** A fill date further out than this says nothing useful, and far enough out it is not a valid Date at all. */
+const MAX_FORECAST_DAYS = 36_500;
 const SYSTEM_MOUNT_PREFIXES = ['/boot', '/snap', '/var/lib/docker/', '/var/lib/containers/'];
 const READ_ONLY_FILESYSTEMS = new Set(['iso9660', 'squashfs']);
 function isForecastableVolume(disk) {
@@ -103,15 +112,20 @@ export async function forecastDisk(nodeId, lookbackDays = DEFAULT_LOOKBACK_DAYS)
             x: (s.timestamp - t0) / MS_PER_DAY,
             y: s.usedBytes,
         }));
-        const reg = linearRegression(points);
+        const reg = latest.timestamp - t0 >= MIN_TREND_SPAN_MS
+            ? linearRegression(points)
+            : { slope: 0, intercept: latest.usedBytes, r2: 0 };
         const growthRatePerDay = reg.slope; // bytes per day
         let estimatedFullDate = null;
         let daysUntilFull = null;
         if (growthRatePerDay > 0 && reg.r2 >= MIN_FORECAST_CONFIDENCE) {
-            const availableBytes = totalBytes - latest.usedBytes;
-            daysUntilFull = Math.ceil(availableBytes / growthRatePerDay);
-            const fullDate = new Date(Date.now() + daysUntilFull * MS_PER_DAY);
-            estimatedFullDate = fullDate.toISOString().split('T')[0] ?? null;
+            const availableBytes = Math.max(0, totalBytes - latest.usedBytes);
+            const days = Math.ceil(availableBytes / growthRatePerDay);
+            if (days <= MAX_FORECAST_DAYS) {
+                daysUntilFull = days;
+                const fullDate = new Date(Date.now() + days * MS_PER_DAY);
+                estimatedFullDate = fullDate.toISOString().split('T')[0] ?? null;
+            }
         }
         forecasts.push({
             mountPoint,
@@ -129,6 +143,7 @@ export async function forecastDisk(nodeId, lookbackDays = DEFAULT_LOOKBACK_DAYS)
 export async function forecastAtRisk(daysThreshold = 30) {
     const db = getDb();
     const nodes = await db.node.findMany({
+        where: { id: { notIn: SENTINEL_NODE_IDS } },
         select: { id: true, hostname: true },
     });
     const results = [];

package/dist/services/ops-service.js

@@ -9,6 +9,8 @@ import { getRateLimitHealth } from '../middleware/rate-limit.js';
 import { listHermesInstallations } from './hermes-service.js';
 import { getHealthRetentionCutoffs, getHealthRetentionPolicy, getRetentionPolicyReadiness } from './health-retention.js';
 import { getNotificationRetentionPolicy } from './notification-retention.js';
+import { SENTINEL_NODE_IDS } from '../utils/sentinel-nodes.js';
+import { databaseFailure, describeTransportFailure } from '../utils/safe-errors.js';
 const STALE_THRESHOLD_MS = Number(process.env['STALE_NODE_THRESHOLD_MS'] ?? 120_000);
 function fingerprint(value) {
     if (!value)
@@ -24,26 +26,10 @@ async function timed(fn) {
     catch (err) {
         return {
             latencyMs: Math.round((performance.now() - started) * 100) / 100,
-            error: err instanceof Error ? err.message : String(err),
+            error: databaseFailure(err)?.message ?? describeTransportFailure(err),
         };
     }
 }
-function describeDependencyError(error) {
-    if (!(error instanceof Error))
-        return String(error);
-    const cause = error.cause;
-    if (cause && typeof cause === 'object') {
-        const code = 'code' in cause && typeof cause.code === 'string' ? cause.code : undefined;
-        const message = 'message' in cause && typeof cause.message === 'string' ? cause.message : undefined;
-        if (code && message)
-            return `${error.message} (${code}: ${message})`;
-        if (code)
-            return `${error.message} (${code})`;
-        if (message)
-            return `${error.message} (${message})`;
-    }
-    return error.message;
-}
 export function resolveRouterHealthUrl(routerUrl, explicitHealthUrl) {
     if (explicitHealthUrl)
         return explicitHealthUrl;
@@ -70,7 +56,7 @@ export async function checkHttp(name, url, timeoutMs = 2500) {
         return {
             name,
             status: 'warn',
-            message: describeDependencyError(error),
+            message: describeTransportFailure(error),
             latencyMs: Math.round((performance.now() - started) * 100) / 100,
         };
     }
@@ -143,10 +129,17 @@ export async function getDependencyHealth() {
     const status = failCount > 0 ? 'unhealthy' : warnCount > 0 ? 'degraded' : 'healthy';
     return { status, checks, generatedAt: new Date().toISOString() };
 }
-export async function getFleetReadiness() {
+/**
+ * Fleet readiness. Secret fingerprints are opt-in, and only an ADMIN response
+ * asks for them: every other caller, including assistant tools and MCP, sees
+ * whether a node's credential is current without the value that identifies it.
+ */
+export async function getFleetReadiness(options = {}) {
+    const includeSecretFingerprints = options.includeSecretFingerprints === true;
     const db = getDb();
     const [nodes, latestHealthSnapshots] = await withReadRetry('fleet readiness', () => Promise.all([
         db.node.findMany({
+            where: { id: { notIn: SENTINEL_NODE_IDS } },
             orderBy: { name: 'asc' },
             include: {
                 agent: true,
@@ -171,10 +164,12 @@ export async function getFleetReadiness() {
     return {
         generatedAt: new Date().toISOString(),
         thresholds: { staleNodeMs: STALE_THRESHOLD_MS },
-        expectedFingerprints: {
-            nodeManagerSecret: fingerprint(getNodeManagerSecret()),
-            apiSecret: fingerprint(API_SECRET),
-        },
+        ...(includeSecretFingerprints ? {
+            expectedFingerprints: {
+                nodeManagerSecret: fingerprint(getNodeManagerSecret()),
+                apiSecret: fingerprint(API_SECRET),
+            },
+        } : {}),
         nodes: nodes.map((node) => {
             const heartbeatAgeMs = node.lastHeartbeatAt ? now - node.lastHeartbeatAt.getTime() : null;
             const stale = heartbeatAgeMs === null || heartbeatAgeMs > STALE_THRESHOLD_MS;
@@ -217,9 +212,9 @@ export async function getFleetReadiness() {
                     lastDetectedAt: hermes.lastDetectedAt?.toISOString() ?? null,
                 } : null,
                 secretFingerprint: {
-                    expectedNodeManagerSecret,
-                    observedNodeManagerSecret,
+                    ...(includeSecretFingerprints ? { expectedNodeManagerSecret, observedNodeManagerSecret } : {}),
                     match: observedNodeManagerSecret === null ? 'unknown' : observedNodeManagerSecret === expectedNodeManagerSecret ? 'match' : 'mismatch',
+                    state: typeof metadata['nodeManagerSecretState'] === 'string' ? metadata['nodeManagerSecretState'] : 'unknown',
                 },
             };
         }),