@xopcai/xopc 0.0.230 → 0.0.232

package/dist/src/gateway/image-generation-setup.d.ts

@@ -14,9 +14,9 @@ export declare function getAgentImageGenerationConfig(config: Config, agentIdRaw
     agentId: string;
     model: {
         primary: string;
-        fallbacks?: string[];
+        fallbacks: string[];
+        autoProviderFallback: boolean;
         timeoutMs?: number;
-        autoProviderFallback?: boolean;
     };
 };
 export declare function prepareImageGenerationSetup(config: Config, agentIdRaw: string, input: ImageGenerationSetupInput): {

package/dist/src/gateway/image-generation-setup.js

@@ -1,6 +1,6 @@
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { init_agent_scope, normalizeAgentId } from "../agent/agent-scope.js";
-import { resolveEffectiveAgentManifestForAgent } from "../config/agent-profile.js";
+import { resolveEffectiveAgentConfigForAgent } from "../config/agent-profile.js";
 import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
 import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
@@ -56,7 +56,7 @@ function getAgentImageGenerationConfig(config, agentIdRaw) {
 	if (!config.agents.list.some((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId)) throw new Error(`Agent not found: ${agentId}`);
 	return {
 		agentId,
-		model: resolveEffectiveAgentManifestForAgent(config, agentId).models.imageGenerationModel ?? null
+		model: resolveEffectiveAgentConfigForAgent(config, agentId).config.models.imageGeneration ?? null
 	};
 }
 function prepareImageGenerationSetup(config, agentIdRaw, input) {
@@ -96,11 +96,12 @@ function prepareImageGenerationSetup(config, agentIdRaw, input) {
 	};
 	const entry = next.agents.list[index];
 	entry.models = {
-		...entry.models ?? {
-			defaultRole: resolveEffectiveAgentManifestForAgent(config, agentId).models.defaultRole,
-			roles: {}
-		},
-		imageGenerationModel: { primary: `${providerId}/${modelId}` }
+		...entry.models ?? {},
+		imageGeneration: {
+			primary: `${providerId}/${modelId}`,
+			fallbacks: [],
+			autoProviderFallback: false
+		}
 	};
 	const parsed = ConfigSchema.safeParse(next);
 	if (!parsed.success) return {

package/dist/src/gateway/public-url.d.ts

@@ -1,7 +1,7 @@
 /**
  * Runtime accessors for `gateway.publicUrl` (the user-deployed reverse-proxy
  * URL). Centralizes the "is it configured?" + "normalized origin" lookup so
- * callers (pair-context, exchange-token, CORS allowlist, UI status) all agree
+ * callers (device access, CORS allowlist, UI status) all agree
  * on the same value.
  */
 import type { Config } from '../config/schema.js';

package/dist/src/gateway/security/gateway-principal.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from 'hono';
+import type { GatewayScope } from './gateway-scopes.js';
+export type GatewayPrincipal = {
+    kind: 'owner' | 'device' | 'trusted-proxy';
+    principalId: string;
+    deviceId?: string;
+    accessSessionId?: string;
+    scopes: readonly GatewayScope[];
+};
+export declare function setGatewayPrincipal(c: Context, principal: GatewayPrincipal): void;
+export declare function getGatewayPrincipal(c: Context): GatewayPrincipal;

package/dist/src/gateway/security/gateway-principal.js

@@ -0,0 +1,12 @@
+//#region src/gateway/security/gateway-principal.ts
+const PRINCIPAL_CONTEXT_KEY = "gatewayPrincipal";
+function setGatewayPrincipal(c, principal) {
+	c.set(PRINCIPAL_CONTEXT_KEY, principal);
+}
+function getGatewayPrincipal(c) {
+	const principal = c.get(PRINCIPAL_CONTEXT_KEY);
+	if (!principal) throw new Error("Gateway principal is unavailable");
+	return principal;
+}
+//#endregion
+export { getGatewayPrincipal, setGatewayPrincipal };

package/dist/src/gateway/security/gateway-scopes.d.ts

@@ -0,0 +1,7 @@
+export declare const GATEWAY_SCOPES: readonly ["gateway.status", "agents.read", "agents.run", "sessions.read", "sessions.write", "workspace.read", "workspace.write", "tasks.read", "tasks.write", "automations.read", "automations.write", "notifications.self", "device.self", "gateway.admin"];
+export type GatewayScope = typeof GATEWAY_SCOPES[number];
+export declare const DEFAULT_MOBILE_SCOPES: readonly GatewayScope[];
+export declare function isGatewayScope(value: unknown): value is GatewayScope;
+export declare function parseGatewayScopes(value: string): GatewayScope[];
+export declare function requiredGatewayScope(method: string, path: string): GatewayScope;
+export declare function hasGatewayScope(granted: readonly GatewayScope[], required: GatewayScope): boolean;

package/dist/src/gateway/security/gateway-scopes.js

@@ -0,0 +1,66 @@
+//#region src/gateway/security/gateway-scopes.ts
+const GATEWAY_SCOPES = [
+	"gateway.status",
+	"agents.read",
+	"agents.run",
+	"sessions.read",
+	"sessions.write",
+	"workspace.read",
+	"workspace.write",
+	"tasks.read",
+	"tasks.write",
+	"automations.read",
+	"automations.write",
+	"notifications.self",
+	"device.self",
+	"gateway.admin"
+];
+const KNOWN_GATEWAY_SCOPES = new Set(GATEWAY_SCOPES);
+const DEFAULT_MOBILE_SCOPES = [
+	"gateway.status",
+	"agents.read",
+	"agents.run",
+	"sessions.read",
+	"sessions.write",
+	"workspace.read",
+	"workspace.write",
+	"tasks.read",
+	"tasks.write",
+	"automations.read",
+	"automations.write",
+	"notifications.self",
+	"device.self"
+];
+function isGatewayScope(value) {
+	return typeof value === "string" && KNOWN_GATEWAY_SCOPES.has(value);
+}
+function parseGatewayScopes(value) {
+	const parsed = JSON.parse(value);
+	if (!Array.isArray(parsed) || !parsed.every(isGatewayScope)) throw new Error("Stored device scopes are invalid");
+	return [...new Set(parsed)];
+}
+function methodScope(method, read, write) {
+	return method === "GET" ? read : write;
+}
+function requiredGatewayScope(method, path) {
+	if (path === "/api/realtime/tickets" || path.startsWith("/api/status")) return "gateway.status";
+	if (path === "/api/device-auth/refresh" || path === "/api/devices/me") return "device.self";
+	if (path.startsWith("/api/devices/me/push")) return "notifications.self";
+	if (path.startsWith("/api/endpoint-tools")) return "device.self";
+	if (path === "/api/agent" || path.startsWith("/api/agent/")) return "agents.run";
+	if (path.startsWith("/api/agents") || path.startsWith("/api/models")) return methodScope(method, "agents.read", "gateway.admin");
+	if (path.startsWith("/api/sessions") || path.startsWith("/api/side-chats")) return methodScope(method, "sessions.read", "sessions.write");
+	if (path.startsWith("/api/tasks")) return methodScope(method, "tasks.read", "tasks.write");
+	if (path.startsWith("/api/home") || path.startsWith("/api/inbox")) return methodScope(method, "tasks.read", "tasks.write");
+	if (path.startsWith("/api/automations") || path.startsWith("/api/automation-runs")) return methodScope(method, "automations.read", "automations.write");
+	if (path.startsWith("/api/workflows")) return methodScope(method, "automations.read", "automations.write");
+	if (path.startsWith("/api/voice") || path.startsWith("/api/media") || path.startsWith("/api/clarify")) return "sessions.write";
+	if (path.startsWith("/api/commands") || path.startsWith("/api/skills")) return methodScope(method, "agents.read", "gateway.admin");
+	if (path.startsWith("/api/workspace") || path.startsWith("/api/files") || path.startsWith("/api/projects") || path.startsWith("/api/notes") || path.startsWith("/api/shares")) return methodScope(method, "workspace.read", "workspace.write");
+	return "gateway.admin";
+}
+function hasGatewayScope(granted, required) {
+	return granted.includes("gateway.admin") || granted.includes(required);
+}
+//#endregion
+export { DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, hasGatewayScope, isGatewayScope, parseGatewayScopes, requiredGatewayScope };

package/dist/src/gateway/security/index.d.ts

@@ -2,7 +2,8 @@ export { safeEqualSecret } from './secret-equal.js';
 export { assertGatewayAuthNotKnownWeak, KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, } from './known-weak-secrets.js';
 export { checkBrowserOrigin } from './origin-check.js';
 export { computeInlineScriptHashes, buildGatewayConsoleCspHeader } from './csp.js';
-export { ADMIN_SCOPE, READ_SCOPE, WRITE_SCOPE, KNOWN_OPERATOR_SCOPES, DEFAULT_OPERATOR_SCOPES, isOperatorScope, authorizeRouteScope, authorizeScope, parseScopesHeader, type OperatorScope, } from './operator-scopes.js';
+export { GATEWAY_SCOPES, DEFAULT_MOBILE_SCOPES, hasGatewayScope, isGatewayScope, parseGatewayScopes, requiredGatewayScope, type GatewayScope, } from './gateway-scopes.js';
+export { getGatewayPrincipal, setGatewayPrincipal, type GatewayPrincipal, } from './gateway-principal.js';
 export { DEFAULT_GATEWAY_HTTP_TOOL_DENY, isDangerousHttpTool, filterDangerousHttpTools, } from './dangerous-tools.js';
 export { createPreauthConnectionBudget, getMaxPreauthConnectionsPerIp, type PreauthConnectionBudget, } from './preauth-connection-budget.js';
 export { auditGatewayConfig, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings, type SecurityAuditFinding, } from './audit.js';

package/dist/src/gateway/security/index.js

@@ -1,3 +1,4 @@
+import { DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, hasGatewayScope, isGatewayScope, parseGatewayScopes, requiredGatewayScope } from "./gateway-scopes.js";
 import { safeEqualSecret } from "./secret-equal.js";
 import { KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, assertGatewayAuthNotKnownWeak } from "./known-weak-secrets.js";
 import { auditGatewayConfig, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings } from "./audit.js";
@@ -5,6 +6,6 @@ import { detectSuspiciousPatterns, wrapExternalContent, wrapWebContent } from ".
 import { createPreauthConnectionBudget, getMaxPreauthConnectionsPerIp } from "./preauth-connection-budget.js";
 import { buildGatewayConsoleCspHeader, computeInlineScriptHashes } from "./csp.js";
 import { checkBrowserOrigin } from "./origin-check.js";
-import { ADMIN_SCOPE, DEFAULT_OPERATOR_SCOPES, KNOWN_OPERATOR_SCOPES, READ_SCOPE, WRITE_SCOPE, authorizeRouteScope, authorizeScope, isOperatorScope, parseScopesHeader } from "./operator-scopes.js";
+import { getGatewayPrincipal, setGatewayPrincipal } from "./gateway-principal.js";
 import { DEFAULT_GATEWAY_HTTP_TOOL_DENY, filterDangerousHttpTools, isDangerousHttpTool } from "./dangerous-tools.js";
-export { ADMIN_SCOPE, DEFAULT_GATEWAY_HTTP_TOOL_DENY, DEFAULT_OPERATOR_SCOPES, KNOWN_OPERATOR_SCOPES, KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, READ_SCOPE, WRITE_SCOPE, assertGatewayAuthNotKnownWeak, auditGatewayConfig, authorizeRouteScope, authorizeScope, buildGatewayConsoleCspHeader, checkBrowserOrigin, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings, computeInlineScriptHashes, createPreauthConnectionBudget, detectSuspiciousPatterns, filterDangerousHttpTools, getMaxPreauthConnectionsPerIp, isDangerousHttpTool, isOperatorScope, parseScopesHeader, safeEqualSecret, wrapExternalContent, wrapWebContent };
+export { DEFAULT_GATEWAY_HTTP_TOOL_DENY, DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, KNOWN_WEAK_GATEWAY_TOKEN_PLACEHOLDERS, assertGatewayAuthNotKnownWeak, auditGatewayConfig, buildGatewayConsoleCspHeader, checkBrowserOrigin, collectGatewayConfigFindings, collectGatewaySecurityFindings, collectGatewayStartupGuardFindings, computeInlineScriptHashes, createPreauthConnectionBudget, detectSuspiciousPatterns, filterDangerousHttpTools, getGatewayPrincipal, getMaxPreauthConnectionsPerIp, hasGatewayScope, isDangerousHttpTool, isGatewayScope, parseGatewayScopes, requiredGatewayScope, safeEqualSecret, setGatewayPrincipal, wrapExternalContent, wrapWebContent };

package/dist/src/gateway/service.js

@@ -21,13 +21,13 @@ import { init_providers, providers_exports } from "../providers/index.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { disposeAllSessionMcpRuntimes } from "../agent/mcp/bundle-mcp-runtime.js";
+import { ProjectService } from "../projects/project-service.js";
+import { resolveProjectAgentId } from "../projects/project-agent.js";
+import "../projects/index.js";
 import { resolveEffectiveGatewayPort } from "./host.js";
 import { AutomationService } from "../automations/service/automation-service.js";
 import { onAutomationProductEvent, publishAutomationProductEvent } from "../automations/product-events.js";
 import "../automations/index.js";
-import { ProjectService } from "../projects/project-service.js";
-import { resolveProjectAgentId } from "../projects/project-agent.js";
-import "../projects/index.js";
 import { TaskApplicationService } from "../tasks/task-application-service.js";
 import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 import { TaskOutboxDispatcher } from "../tasks/task-outbox-dispatcher.js";
@@ -66,6 +66,7 @@ import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
+import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
 import { NotesStore } from "../notes/store.js";
 import { buildNoteAgentContext } from "../notes/agent-context.js";
@@ -80,7 +81,6 @@ import { EphemeralSideChatManager } from "./side-chat/manager.js";
 import { SideChatRunService } from "./side-chat/run-service.js";
 import "./side-chat/index.js";
 import { wireTunnelEventsToGateway } from "../tunnel/gateway-lifecycle.js";
-import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getExposureManager } from "../remote-access/exposure-manager.js";
 import { sanitizeTunnelConfig } from "../tunnel/tunnel-config.js";
 import { assertGatewayAuthNotKnownWeak } from "./security/known-weak-secrets.js";

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,6 +1,6 @@
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
-import { ensureGlobalDefaultsConfig, prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
+import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_model_catalog_store();
 function supportsCapability(model, capability) {
@@ -49,27 +49,25 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 		missing: selected.missing
 	};
 	const selection = selected.selection;
-	const normalized = ensureGlobalDefaultsConfig(config);
-	const presetId = normalized.agents.defaultPreset;
-	const currentModels = normalized.agents.capabilityPresets[presetId]?.models;
-	const defaultRole = currentModels?.defaultRole ?? "deep";
-	const defaultsUpdate = prepareUpdateGlobalDefaults(normalized, { models: {
-		...currentModels,
-		defaultRole,
-		roles: {
-			...currentModels?.roles ?? {},
-			[defaultRole]: {
-				...currentModels?.roles?.[defaultRole],
-				model: `xopc-cloud/${selection.chat}`
+	const currentModels = config.agents.defaults.models;
+	const defaultsUpdate = prepareUpdateGlobalDefaults(config, { defaults: {
+		...config.agents.defaults,
+		models: {
+			...currentModels,
+			chat: {
+				primary: `xopc-cloud/${selection.chat}`,
+				fallbacks: []
+			},
+			imageUnderstanding: {
+				...currentModels.imageUnderstanding,
+				primary: `xopc-cloud/${selection.vision}`,
+				fallbacks: currentModels.imageUnderstanding?.fallbacks ?? []
+			},
+			imageGeneration: {
+				...currentModels.imageGeneration,
+				primary: `xopc-cloud/${selection.imageGeneration}`,
+				fallbacks: currentModels.imageGeneration?.fallbacks ?? []
 			}
-		},
-		imageModel: {
-			...currentModels?.imageModel,
-			primary: `xopc-cloud/${selection.vision}`
-		},
-		imageGenerationModel: {
-			...currentModels?.imageGenerationModel,
-			primary: `xopc-cloud/${selection.imageGeneration}`
 		}
 	} });
 	if (defaultsUpdate.ok === false) return {

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/migrations/index.d.ts

@@ -1,4 +1,3 @@
 export * from './types.js';
 export * from './runner.js';
 export * from './registry.js';
-export * from './config/default-capability-preset.js';

package/dist/src/migrations/index.js

@@ -1,4 +1,3 @@
 import { listRegisteredMigrations, registerMigration, unregisterMigrationsForSource } from "./registry.js";
-import { DEFAULT_CAPABILITY_PRESET_MIGRATION_ID, createDefaultCapabilityPreset, defaultCapabilityPresetMigration, ensureDefaultCapabilityPresetInitialized } from "./config/default-capability-preset.js";
 import { CORE_MIGRATIONS, applyMigrations, detectMigrations, runBootstrapMigrationsSync } from "./runner.js";
-export { CORE_MIGRATIONS, DEFAULT_CAPABILITY_PRESET_MIGRATION_ID, applyMigrations, createDefaultCapabilityPreset, defaultCapabilityPresetMigration, detectMigrations, ensureDefaultCapabilityPresetInitialized, listRegisteredMigrations, registerMigration, runBootstrapMigrationsSync, unregisterMigrationsForSource };
+export { CORE_MIGRATIONS, applyMigrations, detectMigrations, listRegisteredMigrations, registerMigration, runBootstrapMigrationsSync, unregisterMigrationsForSource };

package/dist/src/migrations/runner.js

@@ -2,7 +2,6 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { listRegisteredMigrations } from "./registry.js";
-import { defaultCapabilityPresetMigration } from "./config/default-capability-preset.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 //#region src/migrations/runner.ts
@@ -11,7 +10,7 @@ init_logger();
 const log = createLogger("Migrations");
 const MIGRATION_LEDGER_FILENAME = "migrations.json";
 const CONFIG_BACKUP_COUNT = 10;
-const CORE_MIGRATIONS = [...[defaultCapabilityPresetMigration]];
+const CORE_MIGRATIONS = [];
 function listAllMigrations() {
 	return [...CORE_MIGRATIONS, ...listRegisteredMigrations().map((entry) => entry.migration)];
 }

package/dist/src/notifications/device-store.d.ts

@@ -1,6 +1,6 @@
 import { type NotificationDevice, type NotificationDevicePlatform, type NotificationLanguage, type NotificationPermission, type NotificationPreferences } from './types.js';
 export type RegisterNotificationDeviceInput = {
-    id: string;
+    deviceId: string;
     platform: NotificationDevicePlatform;
     pushToken: string;
     permissions: NotificationPermission;

package/dist/src/notifications/device-store.js

@@ -41,11 +41,11 @@ function deviceFromRow(row) {
 }
 function registerNotificationDevice(input) {
 	const now = Date.now();
-	const preferences = input.preferences ? normalizePreferences(input.preferences) : getNotificationDevice(input.id)?.preferences ?? normalizePreferences();
+	const preferences = input.preferences ? normalizePreferences(input.preferences) : getNotificationDevice(input.deviceId)?.preferences ?? normalizePreferences();
 	runSqliteWriteTransaction((db) => {
-		db.prepare(`DELETE FROM notification_devices
-       WHERE push_provider = 'expo' AND push_token = ? AND device_id <> ?`).run(input.pushToken, input.id);
-		db.prepare(`INSERT INTO notification_devices (
+		db.prepare(`DELETE FROM device_push_endpoints
+       WHERE push_token = ? AND device_id <> ?`).run(input.pushToken, input.deviceId);
+		db.prepare(`INSERT INTO device_push_endpoints (
         device_id, platform, push_token, enabled, permissions, preferences_json,
         locale, app_version, lease_expires_at, last_seen_at, created_at, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -59,16 +59,16 @@ function registerNotificationDevice(input) {
         app_version = excluded.app_version,
         lease_expires_at = excluded.lease_expires_at,
         last_seen_at = excluded.last_seen_at,
-        updated_at = excluded.updated_at`).run(input.id, input.platform, input.pushToken, input.permissions === "granted" ? 1 : 0, input.permissions, JSON.stringify(preferences), input.locale, input.appVersion?.trim() || null, now + DEVICE_LEASE_MS, now, now, now);
+        updated_at = excluded.updated_at`).run(input.deviceId, input.platform, input.pushToken, input.permissions === "granted" ? 1 : 0, input.permissions, JSON.stringify(preferences), input.locale, input.appVersion?.trim() || null, now + DEVICE_LEASE_MS, now, now, now);
 	});
-	return getNotificationDevice(input.id);
+	return getNotificationDevice(input.deviceId);
 }
 function getNotificationDevice(deviceId) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM notification_devices WHERE device_id = ?").get(deviceId);
+	const row = getSqliteDatabase().prepare("SELECT * FROM device_push_endpoints WHERE device_id = ?").get(deviceId);
 	return row ? deviceFromRow(row) : null;
 }
 function listDeliverableNotificationDevices(now = Date.now()) {
-	return getSqliteDatabase().prepare(`SELECT * FROM notification_devices
+	return getSqliteDatabase().prepare(`SELECT * FROM device_push_endpoints
      WHERE enabled = 1 AND permissions = 'granted' AND lease_expires_at > ?
      ORDER BY updated_at DESC`).all(now).map(deviceFromRow);
 }
@@ -80,16 +80,16 @@ function updateNotificationDevicePreferences(deviceId, patch) {
 		...patch
 	});
 	runSqliteWriteTransaction((db) => {
-		db.prepare("UPDATE notification_devices SET preferences_json = ?, updated_at = ? WHERE device_id = ?").run(JSON.stringify(preferences), Date.now(), deviceId);
+		db.prepare("UPDATE device_push_endpoints SET preferences_json = ?, updated_at = ? WHERE device_id = ?").run(JSON.stringify(preferences), Date.now(), deviceId);
 	});
 	return getNotificationDevice(deviceId);
 }
 function removeNotificationDevice(deviceId) {
-	return runSqliteWriteTransaction((db) => db.prepare("DELETE FROM notification_devices WHERE device_id = ?").run(deviceId).changes > 0);
+	return runSqliteWriteTransaction((db) => db.prepare("DELETE FROM device_push_endpoints WHERE device_id = ?").run(deviceId).changes > 0);
 }
 function disableNotificationDeviceForPushToken(pushToken) {
 	runSqliteWriteTransaction((db) => {
-		db.prepare("UPDATE notification_devices SET enabled = 0, updated_at = ? WHERE push_token = ?").run(Date.now(), pushToken);
+		db.prepare("UPDATE device_push_endpoints SET enabled = 0, updated_at = ? WHERE push_token = ?").run(Date.now(), pushToken);
 	});
 }
 //#endregion

package/dist/src/notifications/store.js

@@ -88,7 +88,7 @@ const DELIVERY_JOIN = `
          n.push_token, n.locale
   FROM notification_deliveries d
   JOIN notification_events e ON e.event_id = d.event_id
-  JOIN notification_devices n ON n.device_id = d.device_id
+  JOIN device_push_endpoints n ON n.device_id = d.device_id
 `;
 function listDueNotificationDeliveries(status, now = Date.now(), limit = 100) {
 	return getSqliteDatabase().prepare(`${DELIVERY_JOIN}
@@ -135,7 +135,7 @@ function notificationDeliveryMetrics() {
        SUM(CASE WHEN enabled = 1 AND permissions = 'granted' AND lease_expires_at > ? THEN 1 ELSE 0 END) AS deliverable,
        SUM(CASE WHEN enabled = 1 AND lease_expires_at <= ? THEN 1 ELSE 0 END) AS expired,
        SUM(CASE WHEN enabled = 0 OR permissions <> 'granted' THEN 1 ELSE 0 END) AS disabled
-     FROM notification_devices`).get(now, now);
+     FROM device_push_endpoints`).get(now, now);
 	const oldest = getSqliteDatabase().prepare(`SELECT MIN(next_attempt_at) AS value FROM notification_deliveries
      WHERE status IN ('pending', 'accepted')`).get();
 	const latestError = getSqliteDatabase().prepare(`SELECT event_id, device_id, last_error, updated_at
@@ -166,7 +166,7 @@ function expireUndeliverableNotificationDeliveries(now = Date.now()) {
      SET status = 'dead', last_error = 'Device registration is disabled or expired', updated_at = ?
      WHERE status IN ('pending', 'accepted')
        AND EXISTS (
-         SELECT 1 FROM notification_devices n
+         SELECT 1 FROM device_push_endpoints n
          WHERE n.device_id = notification_deliveries.device_id
            AND (n.enabled = 0 OR n.permissions <> 'granted' OR n.lease_expires_at <= ?)
        )`).run(now, now).changes));

package/dist/src/providers/index.js

@@ -90,7 +90,7 @@ function getApiKeySync(provider) {
 */
 function resolveModel(ref) {
 	const trimmedRef = typeof ref === "string" ? ref.trim() : "";
-	if (!trimmedRef) throw new Error("No default model configured. Choose a model in onboarding or set agents.capabilityPresets.default.models.roles.<role>.model.");
+	if (!trimmedRef) throw new Error("No default model configured. Choose a model in onboarding or set agents.defaults.models.chat.primary.");
 	const customModel = getModelRegistry().resolve(trimmedRef);
 	if (customModel) return normalizeProviderModel(customModel);
 	const qualifiedRef = splitProviderModelRef(trimmedRef);

package/dist/src/providers/model-reference-auditor.js

@@ -24,19 +24,24 @@ function collectToolModel(out, value, location, kind = "text") {
 function collectModelPolicy(out, value, location) {
 	const policy = asRecord(value);
 	if (!policy) return;
-	const roles = asRecord(policy.roles);
-	for (const [roleId, roleValue] of Object.entries(roles ?? {})) {
-		const role = asRecord(roleValue);
-		if (!role) continue;
-		addRef(out, role.model, `${location}.roles.${roleId}.model`);
-		if (Array.isArray(role.fallbacks)) role.fallbacks.forEach((ref, index) => addRef(out, ref, `${location}.roles.${roleId}.fallbacks[${index}]`));
+	const chat = asRecord(policy.chat);
+	if (chat) {
+		addRef(out, chat.primary, `${location}.chat.primary`);
+		if (Array.isArray(chat.fallbacks)) chat.fallbacks.forEach((ref, index) => addRef(out, ref, `${location}.chat.fallbacks[${index}]`));
 	}
-	collectToolModel(out, policy.imageModel, `${location}.imageModel`);
-	collectToolModel(out, policy.imageGenerationModel, `${location}.imageGenerationModel`, "image-generation");
+	const intents = asRecord(policy.intents);
+	for (const [intent, routeValue] of Object.entries(intents ?? {})) {
+		const route = asRecord(routeValue);
+		if (!route) continue;
+		addRef(out, route.primary, `${location}.intents.${intent}.primary`);
+		if (Array.isArray(route.fallbacks)) route.fallbacks.forEach((ref, index) => addRef(out, ref, `${location}.intents.${intent}.fallbacks[${index}]`));
+	}
+	collectToolModel(out, policy.imageUnderstanding, `${location}.imageUnderstanding`);
+	collectToolModel(out, policy.imageGeneration, `${location}.imageGeneration`, "image-generation");
 }
 function collectReferences(config, sessionConfigs) {
 	const out = [];
-	for (const [presetId, preset] of Object.entries(config.agents.capabilityPresets)) collectModelPolicy(out, preset.models, `agents.capabilityPresets.${presetId}.models`);
+	collectModelPolicy(out, config.agents.defaults.models, "agents.defaults.models");
 	for (const agent of config.agents.list) collectModelPolicy(out, agent.models, `agents.list.${agent.id}.models`);
 	for (const [sessionKey, sessionConfig] of sessionConfigs) addRef(out, sessionConfig.modelOverride, `sessions.${sessionKey}.modelOverride`);
 	return out;

package/dist/src/realtime/runtime.d.ts

@@ -10,10 +10,12 @@ export declare class RealtimeRuntime {
     private readonly preauthBudget;
     private readonly wss;
     private readonly topicCleanupTimers;
+    private readonly socketsByPrincipal;
     private closed;
     constructor(endpointTools?: EndpointToolRuntime);
     handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
     close(): void;
+    disconnectPrincipal(principalId: string): void;
     completeTopic(topic: string, ttlMs?: number): void;
     private handleConnection;
     private rawDataToText;

package/dist/src/realtime/runtime.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { hasGatewayScope } from "../gateway/security/gateway-scopes.js";
 import { REALTIME_HEARTBEAT_INTERVAL_MS, REALTIME_HEARTBEAT_TIMEOUT_MS, REALTIME_HELLO_TIMEOUT_MS, REALTIME_MAX_CLIENT_FRAME_BYTES, parseClientRealtimeJsonFrame, parseClientRealtimeMessage } from "../../packages/realtime-protocol/src/index.js";
 import { createPreauthConnectionBudget } from "../gateway/security/preauth-connection-budget.js";
 import { RealtimeBroker } from "./broker.js";
@@ -24,8 +25,13 @@ function serverMessage(kind, payload) {
 		payload
 	};
 }
-function isAuthorizedTopic(topic) {
-	return topic === "gateway" || topic === "sessions" || topic === "logs" || topic.startsWith("session:") && topic.length > 8 || topic.startsWith("run:") && topic.length > 4 || topic.startsWith("workflow:") && topic.length > 9;
+function isAuthorizedTopic(topic, scopes) {
+	if (topic === "gateway") return hasGatewayScope(scopes, "gateway.status");
+	if (topic === "logs") return hasGatewayScope(scopes, "gateway.admin");
+	if (topic === "sessions" || topic.startsWith("session:")) return hasGatewayScope(scopes, "sessions.read");
+	if (topic.startsWith("run:")) return hasGatewayScope(scopes, "agents.run");
+	if (topic.startsWith("workflow:")) return hasGatewayScope(scopes, "automations.read");
+	return false;
 }
 var RealtimeRuntime = class {
 	broker = new RealtimeBroker(void 0, (error, topic) => {
@@ -42,6 +48,7 @@ var RealtimeRuntime = class {
 		perMessageDeflate: false
 	});
 	topicCleanupTimers = /* @__PURE__ */ new Map();
+	socketsByPrincipal = /* @__PURE__ */ new Map();
 	closed = false;
 	constructor(endpointTools) {
 		this.endpointTools = endpointTools;
@@ -80,6 +87,10 @@ var RealtimeRuntime = class {
 		for (const timer of this.topicCleanupTimers.values()) clearTimeout(timer);
 		this.topicCleanupTimers.clear();
 		this.wss.close();
+		this.socketsByPrincipal.clear();
+	}
+	disconnectPrincipal(principalId) {
+		for (const socket of this.socketsByPrincipal.get(principalId) ?? []) socket.close(4403, "Device access revoked");
 	}
 	completeTopic(topic, ttlMs = 5 * 6e4) {
 		const existing = this.topicCleanupTimers.get(topic);
@@ -97,6 +108,8 @@ var RealtimeRuntime = class {
 		let lastSeenAt = Date.now();
 		let connectionId;
 		let endpointId;
+		let principalId;
+		let grantedScopes = [];
 		let budgetHeld = true;
 		const releaseBudget = () => {
 			if (!budgetHeld) return;
@@ -115,7 +128,7 @@ var RealtimeRuntime = class {
 		};
 		const subscribe = (requested) => {
 			const authorized = requested.filter((item) => {
-				if (isAuthorizedTopic(item.topic)) return true;
+				if (isAuthorizedTopic(item.topic, grantedScopes)) return true;
 				sendError("FORBIDDEN_TOPIC", `Topic is not available: ${item.topic}`);
 				return false;
 			});
@@ -172,6 +185,11 @@ var RealtimeRuntime = class {
 					return;
 				}
 				authenticated = true;
+				principalId = claim.principalId;
+				grantedScopes = claim.scopes;
+				const principalSockets = this.socketsByPrincipal.get(principalId) ?? /* @__PURE__ */ new Set();
+				principalSockets.add(socket);
+				this.socketsByPrincipal.set(principalId, principalSockets);
 				connectionId = crypto.randomUUID();
 				let endpointReady;
 				if (message.payload.endpoint) {
@@ -215,6 +233,7 @@ var RealtimeRuntime = class {
 				subscribe(message.payload.subscriptions);
 				log.info({
 					connectionId,
+					principalId,
 					clientId: claim.clientId,
 					clientKind: claim.clientKind
 				}, "Realtime client connected");
@@ -249,6 +268,11 @@ var RealtimeRuntime = class {
 			for (const handle of subscriptions.values()) handle.unsubscribe();
 			subscriptions.clear();
 			if (endpointId && connectionId) this.endpointTools?.remove(endpointId, connectionId);
+			if (principalId) {
+				const principalSockets = this.socketsByPrincipal.get(principalId);
+				principalSockets?.delete(socket);
+				if (principalSockets?.size === 0) this.socketsByPrincipal.delete(principalId);
+			}
 			if (connectionId) {
 				const reason = reasonBuffer.toString();
 				log.info({

package/dist/src/realtime/tickets.d.ts

@@ -1,7 +1,12 @@
 import type { RealtimeClientKind } from '@xopcai/realtime-protocol';
+import type { GatewayScope } from '../gateway/security/gateway-scopes.js';
 export interface RealtimeTicketClaim {
     clientId: string;
     clientKind: RealtimeClientKind;
+    principalId: string;
+    deviceId?: string;
+    accessSessionId?: string;
+    scopes: readonly GatewayScope[];
     expiresAt: number;
 }
 export interface IssuedRealtimeTicket extends RealtimeTicketClaim {
@@ -9,7 +14,7 @@ export interface IssuedRealtimeTicket extends RealtimeTicketClaim {
 }
 export declare class RealtimeTicketStore {
     private readonly claims;
-    issue(clientId: string, clientKind: RealtimeClientKind, now?: number): IssuedRealtimeTicket;
+    issue(clientId: string, clientKind: RealtimeClientKind, principal: Omit<RealtimeTicketClaim, 'clientId' | 'clientKind' | 'expiresAt'>, now?: number): IssuedRealtimeTicket;
     consume(ticket: string, clientId: string, clientKind: RealtimeClientKind, now?: number): RealtimeTicketClaim | undefined;
     private prune;
 }

package/dist/src/realtime/tickets.js

@@ -7,13 +7,14 @@ function ticketKey(ticket) {
 }
 var RealtimeTicketStore = class {
 	claims = /* @__PURE__ */ new Map();
-	issue(clientId, clientKind, now = Date.now()) {
+	issue(clientId, clientKind, principal, now = Date.now()) {
 		this.prune(now);
 		if (this.claims.size >= MAX_OUTSTANDING_TICKETS) throw new Error("Too many outstanding realtime tickets");
 		const ticket = crypto.randomBytes(32).toString("base64url");
 		const claim = {
 			clientId,
 			clientKind,
+			...principal,
 			expiresAt: now + TICKET_TTL_MS
 		};
 		this.claims.set(ticketKey(ticket), claim);

package/dist/src/remote-access/exposure-manager.js

@@ -2,11 +2,11 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { isTailscaleInstalled } from "../infra/tailscale.js";
 import { resolveGatewayBindMode } from "../config/gateway-bind.js";
-import { getTunnelConsentState } from "../tunnel/consent.js";
-import { getTunnelService } from "../tunnel/tunnel-service.js";
-import { maybeAutoStartTunnelFromConfig } from "../tunnel/gateway-lifecycle.js";
 import { collectExposureConflicts } from "./exposure-guards.js";
 import { getTailscaleExposureState, maybeStartTailscaleFromConfig, stopTailscaleExposure } from "../gateway/tailscale-lifecycle.js";
+import { getTunnelService } from "../tunnel/tunnel-service.js";
+import { getTunnelConsentState } from "../tunnel/consent.js";
+import { maybeAutoStartTunnelFromConfig } from "../tunnel/gateway-lifecycle.js";
 //#region src/remote-access/exposure-manager.ts
 init_logger();
 const log = createLogger("ExposureManager");