@swarmclawai/swarmclaw 1.9.2 → 1.9.4

package/src/lib/server/extensions.ts

@@ -11,6 +11,7 @@ import type {
   ExtensionUIDefinition,
   ExtensionProviderDefinition,
   ExtensionConnectorDefinition,
+  ExtensionManagedResources,
   Session,
   ExtensionPackageManager,
   ExtensionDependencyInstallStatus,
@@ -467,11 +468,60 @@ function coerceTools(rawTools: unknown): ExtensionToolDef[] {
   return []
 }
 
+function coerceManagedResources(raw: Record<string, unknown>): ExtensionManagedResources | undefined {
+  const explicit = isRecord(raw.managedResources)
+    ? raw.managedResources as Record<string, unknown>
+    : {}
+  const agents = Array.isArray(explicit.agents)
+    ? explicit.agents
+    : Array.isArray(raw.agents)
+      ? raw.agents
+      : undefined
+  const schedules = Array.isArray(explicit.schedules)
+    ? explicit.schedules
+    : Array.isArray(raw.schedules)
+      ? raw.schedules
+      : undefined
+  const routines = Array.isArray(explicit.routines)
+    ? explicit.routines
+    : Array.isArray(raw.routines)
+      ? raw.routines
+      : undefined
+  const localFolders = Array.isArray(explicit.localFolders)
+    ? explicit.localFolders
+    : Array.isArray(raw.localFolders)
+      ? raw.localFolders
+      : undefined
+  const gatewayPlatforms = Array.isArray(explicit.gatewayPlatforms)
+    ? explicit.gatewayPlatforms
+    : Array.isArray(raw.gatewayPlatforms)
+      ? raw.gatewayPlatforms
+      : undefined
+  const setupChecks = Array.isArray(explicit.setupChecks)
+    ? explicit.setupChecks
+    : Array.isArray(raw.setupChecks)
+      ? raw.setupChecks
+      : undefined
+
+  const managedResources: ExtensionManagedResources = {
+    agents: agents as ExtensionManagedResources['agents'],
+    schedules: schedules as ExtensionManagedResources['schedules'],
+    routines: routines as ExtensionManagedResources['routines'],
+    localFolders: localFolders as ExtensionManagedResources['localFolders'],
+    gatewayPlatforms: gatewayPlatforms as ExtensionManagedResources['gatewayPlatforms'],
+    setupChecks: setupChecks as ExtensionManagedResources['setupChecks'],
+  }
+
+  return Object.values(managedResources).some((value) => Array.isArray(value) && value.length > 0)
+    ? managedResources
+    : undefined
+}
+
 function normalizeExtension(mod: unknown): Extension | null {
   const modObj = mod as Record<string, unknown>
   const raw: Record<string, unknown> = (modObj?.default as Record<string, unknown>) || modObj
 
-  if (raw.name && (raw.hooks || raw.tools || raw.ui || raw.providers || raw.connectors)) {
+  if (raw.name && (raw.hooks || raw.tools || raw.ui || raw.providers || raw.connectors || raw.managedResources || raw.agents || raw.schedules || raw.routines || raw.localFolders || raw.gatewayPlatforms || raw.setupChecks)) {
     const hooks = isRecord(raw.hooks) ? (raw.hooks as ExtensionHooks) : {}
     return {
       name: raw.name as string,
@@ -484,6 +534,7 @@ function normalizeExtension(mod: unknown): Extension | null {
       ui: isRecord(raw.ui) ? (raw.ui as ExtensionUIDefinition) : undefined,
       providers: Array.isArray(raw.providers) ? (raw.providers as ExtensionProviderDefinition[]) : undefined,
       connectors: Array.isArray(raw.connectors) ? (raw.connectors as ExtensionConnectorDefinition[]) : undefined,
+      managedResources: coerceManagedResources(raw),
     } as Extension
   }
 
@@ -639,6 +690,7 @@ interface LoadedExtension {
   ui?: ExtensionUIDefinition
   providers?: ExtensionProviderDefinition[]
   connectors?: ExtensionConnectorDefinition[]
+  managedResources?: ExtensionManagedResources
   isBuiltin?: boolean
 }
 
@@ -1017,6 +1069,7 @@ class ExtensionManager {
           ui: p.ui,
           providers: p.providers,
           connectors: p.connectors,
+          managedResources: p.managedResources || coerceManagedResources(p as unknown as Record<string, unknown>),
           isBuiltin: true
         })
         this.markExtensionSuccess(id)
@@ -1064,6 +1117,7 @@ class ExtensionManager {
               ui: ext.ui,
               providers: ext.providers,
               connectors: ext.connectors,
+              managedResources: ext.managedResources,
             })
             this.markExtensionSuccess(file)
           } catch (err: unknown) {
@@ -1145,6 +1199,55 @@ class ExtensionManager {
     return allUI
   }
 
+  getManagedResourceExtensions(): Array<{
+    extensionId: string
+    extensionName: string
+    enabled: boolean
+    isBuiltin: boolean
+    source?: ExtensionMeta['source']
+    managedResources: ExtensionManagedResources
+  }> {
+    this.load()
+    const result: Array<{
+      extensionId: string
+      extensionName: string
+      enabled: boolean
+      isBuiltin: boolean
+      source?: ExtensionMeta['source']
+      managedResources: ExtensionManagedResources
+    }> = []
+
+    for (const [id, entry] of this.extensions.entries()) {
+      const managedResources = entry.managedResources
+      if (!managedResources) continue
+      if (!Object.values(managedResources).some((value) => Array.isArray(value) && value.length > 0)) continue
+      result.push({
+        extensionId: id,
+        extensionName: entry.meta.name,
+        enabled: entry.meta.enabled,
+        isBuiltin: entry.isBuiltin === true,
+        source: entry.meta.source,
+        managedResources,
+      })
+    }
+
+    return result
+  }
+
+  getManagedResources(extensionId: string): ExtensionManagedResources | null {
+    this.load()
+    const candidateIds = expandExtensionIds([extensionId])
+    for (const id of candidateIds) {
+      const loaded = this.extensions.get(id)
+      if (loaded?.managedResources) return loaded.managedResources
+      const builtin = this.builtins.get(id)
+      if (builtin) {
+        return builtin.managedResources || coerceManagedResources(builtin as unknown as Record<string, unknown>) || null
+      }
+    }
+    return null
+  }
+
   listExtensionIds(): string[] {
     this.load()
     return Array.from(this.extensions.keys())
@@ -1842,11 +1945,14 @@ class ExtensionManager {
       const failures = this.readFailureState()
       const metas: ExtensionMeta[] = []
 
-      const describeCapabilities = (loaded?: LoadedExtension, fallback?: Extension): Pick<ExtensionMeta, 'toolCount' | 'hookCount' | 'hasUI' | 'providerCount' | 'connectorCount' | 'settingsFields'> => {
+      const describeCapabilities = (loaded?: LoadedExtension, fallback?: Extension): Pick<ExtensionMeta, 'toolCount' | 'hookCount' | 'hasUI' | 'providerCount' | 'connectorCount' | 'settingsFields' | 'managedAgentCount' | 'managedScheduleCount' | 'localFolderCount' | 'gatewayPlatformCount' | 'setupCheckCount'> => {
         const tools = loaded?.tools || fallback?.tools || []
         const hooks = loaded?.hooks || fallback?.hooks || {}
         const providers = loaded?.providers || fallback?.providers || []
         const connectors = loaded?.connectors || fallback?.connectors || []
+        const managedResources = loaded?.managedResources
+          || fallback?.managedResources
+          || (fallback ? coerceManagedResources(fallback as unknown as Record<string, unknown>) : undefined)
         const hasUi = !!(loaded?.ui || fallback?.ui)
         const settingsFields = loaded?.ui?.settingsFields || fallback?.ui?.settingsFields
         return {
@@ -1855,6 +1961,11 @@ class ExtensionManager {
           hasUI: hasUi,
           providerCount: Array.isArray(providers) ? providers.length : 0,
           connectorCount: Array.isArray(connectors) ? connectors.length : 0,
+          managedAgentCount: managedResources?.agents?.length || 0,
+          managedScheduleCount: (managedResources?.schedules?.length || 0) + (managedResources?.routines?.length || 0),
+          localFolderCount: managedResources?.localFolders?.length || 0,
+          gatewayPlatformCount: managedResources?.gatewayPlatforms?.length || 0,
+          setupCheckCount: managedResources?.setupChecks?.length || 0,
           settingsFields: settingsFields?.length ? settingsFields : undefined,
         }
       }

package/src/lib/server/gateways/gateway-profile-service.ts

@@ -70,6 +70,8 @@ function normalizeStats(value: unknown): OpenClawGatewayStats | null {
     externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
     sessionCount: normalizeNullableNumber(stats.sessionCount) ?? undefined,
     presenceCount: normalizeNullableNumber(stats.presenceCount) ?? undefined,
+    environmentCount: normalizeNullableNumber(stats.environmentCount) ?? undefined,
+    availableEnvironmentCount: normalizeNullableNumber(stats.availableEnvironmentCount) ?? undefined,
     lastTopologyCheckedAt: normalizeNullableNumber(stats.lastTopologyCheckedAt) ?? undefined,
     lastTopologyErrorCount: normalizeNullableNumber(stats.lastTopologyErrorCount) ?? undefined,
     lastTopologyError: normalizeText(stats.lastTopologyError),

package/src/lib/server/gateways/gateway-topology.test.ts

@@ -1,7 +1,11 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 
-import { buildOpenClawGatewayTopology, getOpenClawGatewayFleetTopology } from './gateway-topology'
+import {
+  buildOpenClawGatewayTopology,
+  getOpenClawGatewayEnvironmentStatus,
+  getOpenClawGatewayFleetTopology,
+} from './gateway-topology'
 import type { GatewayProfile, OpenClawGatewayStats } from '@/types'
 
 const now = 1_800_000_000_000
@@ -60,6 +64,25 @@ describe('OpenClaw gateway topology', () => {
         },
         'sessions.list': { sessions: [{ sessionId: 'session_1', title: 'Release room' }] },
         'system-presence': { presence: [{ deviceId: 'phone_1', mode: 'active' }] },
+        'environments.list': {
+          environments: [
+            {
+              id: 'gateway',
+              type: 'local',
+              label: 'Gateway local',
+              status: 'available',
+              capabilities: ['agent.run', 'sessions', 'tools', 'workspace'],
+            },
+            {
+              id: 'node:node_1',
+              type: 'node',
+              label: 'Mac Studio',
+              status: 'available',
+              capabilities: ['shell.exec'],
+            },
+            { id: 'node:node_2', type: 'node', label: 'Builder', status: 'unavailable' },
+          ],
+        },
       }) as never,
       persistStats: (id, input) => {
         assert.equal(id, 'gateway_1')
@@ -77,6 +100,10 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(topology.stats.pairedDeviceCount, 1)
     assert.equal(topology.stats.sessionCount, 1)
     assert.equal(topology.stats.presenceCount, 1)
+    assert.equal(topology.stats.environmentCount, 3)
+    assert.equal(topology.stats.availableEnvironmentCount, 2)
+    assert.equal(topology.environments[0]?.id, 'gateway')
+    assert.equal(topology.environments[1]?.capabilities?.[0], 'shell.exec')
     assert.equal(topology.stats.pendingPairingCount, 2)
     assert.equal(topology.stats.hasErrors, false)
     assert.equal(topology.stats.lastTopologyCheckedAt, now)
@@ -92,15 +119,17 @@ describe('OpenClaw gateway topology', () => {
         'device.pair.list': { pending: [], paired: [] },
         'sessions.list': new Error('sessions unavailable'),
         'system-presence': new Error('presence unavailable'),
+        'environments.list': new Error('environments unavailable'),
       }) as never,
       persistStats: (id, input) => ({ ...profile({ id }), stats: input.stats as OpenClawGatewayStats }),
     })
 
     assert.equal(topology.nodes.length, 1)
     assert.equal(topology.sessions.length, 0)
-    assert.deepEqual(topology.errors.map((error) => error.method), ['sessions.list', 'system-presence'])
+    assert.equal(topology.environments.length, 2)
+    assert.deepEqual(topology.errors.map((error) => error.method), ['sessions.list', 'system-presence', 'environments.list'])
     assert.equal(topology.stats.hasErrors, true)
-    assert.equal(topology.stats.lastTopologyErrorCount, 2)
+    assert.equal(topology.stats.lastTopologyErrorCount, 3)
     assert.equal(topology.stats.lastTopologyError, 'sessions unavailable')
   })
 
@@ -113,6 +142,7 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(topology.connected, false)
     assert.equal(topology.stats.hasErrors, true)
     assert.equal(topology.stats.nodeCount, 0)
+    assert.equal(topology.stats.environmentCount, 0)
     assert.equal(topology.errors[0]?.method, 'gateway.connect')
   })
 
@@ -132,6 +162,11 @@ describe('OpenClaw gateway topology', () => {
         'device.pair.list': { pending: [], paired: [] },
         'sessions.list': { sessions: target?.profileId === 'gateway_a' ? [{ id: 'session_a' }] : [] },
         'system-presence': { presence: [] },
+        'environments.list': {
+          environments: target?.profileId === 'gateway_a'
+            ? [{ id: 'gateway', type: 'local', status: 'available' }]
+            : [{ id: 'gateway', type: 'local', status: 'available' }, { id: 'node:node_b', type: 'node', status: 'unavailable' }],
+        },
       }) as never,
       persistStats: (id, input) => ({
         ...(id === 'gateway_a' ? first : second),
@@ -144,8 +179,29 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(fleet.totals.connectedGatewayCount, 2)
     assert.equal(fleet.totals.nodeCount, 2)
     assert.equal(fleet.totals.connectedNodeCount, 1)
+    assert.equal(fleet.totals.environmentCount, 3)
+    assert.equal(fleet.totals.availableEnvironmentCount, 2)
     assert.equal(fleet.totals.pendingNodePairings, 1)
     assert.equal(fleet.totals.sessionCount, 1)
     assert.equal(fleet.gateways.length, 2)
   })
+
+  it('returns direct environment status through the gateway protocol', async () => {
+    const calls: Array<{ method: string; params?: Record<string, unknown> }> = []
+    const status = await getOpenClawGatewayEnvironmentStatus('gateway_1', 'node:node_1', {
+      now: () => now,
+      getGatewayProfile: () => profile(),
+      ensureGatewayConnected: async () => ({
+        connected: true,
+        rpc: async (method: string, params?: Record<string, unknown>) => {
+          calls.push({ method, params })
+          return { id: 'node:node_1', type: 'node', label: 'Mac Studio', status: 'available', capabilities: ['shell.exec'] }
+        },
+      }) as never,
+    })
+
+    assert.equal(status?.environment?.id, 'node:node_1')
+    assert.equal(status?.environment?.status, 'available')
+    assert.deepEqual(calls, [{ method: 'environments.status', params: { environmentId: 'node:node_1' } }])
+  })
 })

package/src/lib/server/gateways/gateway-topology.ts

@@ -6,8 +6,11 @@ import {
 } from './gateway-profile-service'
 import { ensureGatewayConnected } from '@/lib/server/openclaw/gateway'
 import type {
+  OpenClawEnvironmentSummary,
   GatewayProfile,
   OpenClawDevicePairRequest,
+  OpenClawGatewayEnvironmentList,
+  OpenClawGatewayEnvironmentStatusSnapshot,
   OpenClawGatewayFleetTopology,
   OpenClawGatewayPresenceEntry,
   OpenClawGatewayRpcError,
@@ -26,6 +29,7 @@ type GatewayRpcClient = {
 
 interface GatewayTopologyDeps {
   ensureGatewayConnected?: typeof ensureGatewayConnected
+  getGatewayProfile?: typeof getGatewayProfileById
   listGatewayProfiles?: typeof listOpenClawGatewayProfiles
   now?: () => number
   persistStats?: typeof updateGatewayProfile
@@ -176,14 +180,72 @@ function normalizePresence(value: unknown): OpenClawGatewayPresenceEntry | null
   }
 }
 
+function uniqueStrings(...items: Array<readonly string[] | undefined>): string[] {
+  const values = new Set<string>()
+  for (const item of items) {
+    for (const value of item || []) {
+      const trimmed = asString(value)
+      if (trimmed) values.add(trimmed)
+    }
+  }
+  return [...values].sort((left, right) => left.localeCompare(right))
+}
+
+function normalizeEnvironmentStatus(value: unknown): OpenClawEnvironmentSummary['status'] {
+  return value === 'available'
+    || value === 'starting'
+    || value === 'stopping'
+    || value === 'error'
+    ? value
+    : 'unavailable'
+}
+
+function normalizeEnvironment(value: unknown): OpenClawEnvironmentSummary | null {
+  const record = asObject(value)
+  const id = asString(record?.id) || asString(record?.environmentId)
+  if (!record || !id) return null
+  const capabilities = Array.isArray(record.capabilities)
+    ? uniqueStrings(record.capabilities.map(asString).filter(Boolean) as string[])
+    : undefined
+  return {
+    id,
+    type: asString(record.type) || 'local',
+    label: asString(record.label) || asString(record.name),
+    status: normalizeEnvironmentStatus(record.status),
+    capabilities: capabilities && capabilities.length > 0 ? capabilities : undefined,
+  }
+}
+
+function deriveEnvironments(profile: GatewayProfile, nodes: OpenClawNode[], connected: boolean): OpenClawEnvironmentSummary[] {
+  const gatewayEnvironment: OpenClawEnvironmentSummary = {
+    id: 'gateway',
+    type: 'local',
+    label: profile.name || 'Gateway local',
+    status: connected ? 'available' : 'unavailable',
+    capabilities: ['agent.run', 'sessions', 'tools', 'workspace'],
+  }
+  const nodeEnvironments = nodes.map((node) => {
+    const capabilities = uniqueStrings(node.caps, node.commands)
+    return {
+      id: `node:${node.nodeId}`,
+      type: 'node',
+      label: node.displayName || node.nodeId,
+      status: node.connected === true ? 'available' : 'unavailable',
+      capabilities: capabilities.length > 0 ? capabilities : undefined,
+    } satisfies OpenClawEnvironmentSummary
+  })
+  return [gatewayEnvironment, ...nodeEnvironments]
+}
+
 async function safeRpc<T>(
   gateway: GatewayRpcClient,
   method: string,
   errors: OpenClawGatewayRpcError[],
   normalize: (value: unknown) => T,
+  params: Record<string, unknown> = {},
 ): Promise<T> {
   try {
-    return normalize(await gateway.rpc(method, {}))
+    return normalize(await gateway.rpc(method, params))
   } catch (err: unknown) {
     errors.push({ method, message: errorMessage(err) })
     return normalize(null)
@@ -197,6 +259,7 @@ function topologyStats(params: {
   pairedDevices: OpenClawPairedDevice[]
   sessions: OpenClawGatewaySession[]
   presence: OpenClawGatewayPresenceEntry[]
+  environments: OpenClawEnvironmentSummary[]
   errors: OpenClawGatewayRpcError[]
   refreshedAt: number
 }): OpenClawGatewayTopologyStats {
@@ -208,6 +271,8 @@ function topologyStats(params: {
     pendingDevicePairings: params.devicePairings.length,
     sessionCount: params.sessions.length,
     presenceCount: params.presence.length,
+    environmentCount: params.environments.length,
+    availableEnvironmentCount: params.environments.filter((environment) => environment.status === 'available').length,
     pendingPairingCount: params.nodePairings.length + params.devicePairings.length,
     hasErrors: params.errors.length > 0,
     lastTopologyCheckedAt: params.refreshedAt,
@@ -235,6 +300,7 @@ export async function buildOpenClawGatewayTopology(
       pairedDevices: [],
       sessions: [],
       presence: [],
+      environments: [],
       errors,
       refreshedAt,
     })
@@ -249,11 +315,12 @@ export async function buildOpenClawGatewayTopology(
       pairedDevices: [],
       sessions: [],
       presence: [],
+      environments: [],
       errors,
     }
   }
 
-  const [nodes, nodePairingsRaw, devicePairingsRaw, sessions, presence] = await Promise.all([
+  const [nodes, nodePairingsRaw, devicePairingsRaw, sessions, presence, rpcEnvironments] = await Promise.all([
     safeRpc(gateway, 'node.list', errors, (value) =>
       extractArray(value, ['nodes']).map(normalizeNode).filter(Boolean) as OpenClawNode[],
     ),
@@ -265,6 +332,9 @@ export async function buildOpenClawGatewayTopology(
     safeRpc(gateway, 'system-presence', errors, (value) =>
       extractArray(value, ['presence']).map(normalizePresence).filter(Boolean) as OpenClawGatewayPresenceEntry[],
     ),
+    safeRpc(gateway, 'environments.list', errors, (value) =>
+      extractArray(value, ['environments']).map(normalizeEnvironment).filter(Boolean) as OpenClawEnvironmentSummary[],
+    ),
   ])
 
   const devicePairingsRecord = asObject(devicePairingsRaw) || {}
@@ -277,6 +347,9 @@ export async function buildOpenClawGatewayTopology(
   const pairedDevices = extractArray(devicePairingsRecord.paired)
     .map(normalizePairedDevice)
     .filter(Boolean) as OpenClawPairedDevice[]
+  const environments = rpcEnvironments.length > 0
+    ? rpcEnvironments
+    : deriveEnvironments(profile, nodes, gateway.connected)
   const stats = topologyStats({
     nodes,
     nodePairings,
@@ -284,6 +357,7 @@ export async function buildOpenClawGatewayTopology(
     pairedDevices,
     sessions,
     presence,
+    environments,
     errors,
     refreshedAt,
   })
@@ -301,6 +375,54 @@ export async function buildOpenClawGatewayTopology(
     pairedDevices,
     sessions,
     presence,
+    environments,
+    errors,
+  }
+}
+
+export async function listOpenClawGatewayEnvironments(
+  id: string,
+  deps: GatewayTopologyDeps = {},
+): Promise<OpenClawGatewayEnvironmentList | null> {
+  const topology = await getOpenClawGatewayTopology(id, deps)
+  if (!topology) return null
+  return {
+    profile: topology.profile,
+    connected: topology.connected,
+    refreshedAt: topology.refreshedAt,
+    environments: topology.environments,
+    errors: topology.errors,
+  }
+}
+
+export async function getOpenClawGatewayEnvironmentStatus(
+  id: string,
+  environmentId: string,
+  deps: GatewayTopologyDeps = {},
+): Promise<OpenClawGatewayEnvironmentStatusSnapshot | null> {
+  const profile = (deps.getGatewayProfile ?? getGatewayProfileById)(id)
+  if (!profile) return null
+  const now = deps.now ?? (() => Date.now())
+  const refreshedAt = now()
+  const ensureConnected = deps.ensureGatewayConnected ?? ensureGatewayConnected
+  const errors: OpenClawGatewayRpcError[] = []
+  const gateway = await ensureConnected({ profileId: profile.id }) as GatewayRpcClient | null
+  if (!gateway) {
+    errors.push({ method: 'gateway.connect', message: 'OpenClaw gateway not connected' })
+    return { profile, connected: false, refreshedAt, environment: null, errors }
+  }
+  const environment = await safeRpc(
+    gateway,
+    'environments.status',
+    errors,
+    (value) => normalizeEnvironment(value),
+    { environmentId },
+  )
+  return {
+    profile,
+    connected: gateway.connected,
+    refreshedAt,
+    environment,
     errors,
   }
 }
@@ -311,6 +433,8 @@ function emptyTotals(generatedAt: number): OpenClawGatewayFleetTopology['totals'
     connectedGatewayCount: 0,
     nodeCount: 0,
     connectedNodeCount: 0,
+    environmentCount: 0,
+    availableEnvironmentCount: 0,
     pendingNodePairings: 0,
     pairedDeviceCount: 0,
     pendingDevicePairings: 0,
@@ -328,7 +452,7 @@ export async function getOpenClawGatewayTopology(
   id: string,
   deps: GatewayTopologyDeps = {},
 ): Promise<OpenClawGatewayTopology | null> {
-  const profile = getGatewayProfileById(id)
+  const profile = (deps.getGatewayProfile ?? getGatewayProfileById)(id)
   if (!profile) return null
   return buildOpenClawGatewayTopology(profile, deps)
 }
@@ -355,6 +479,8 @@ export async function getOpenClawGatewayFleetTopology(
     acc.pendingDevicePairings = (acc.pendingDevicePairings || 0) + (topology.stats.pendingDevicePairings || 0)
     acc.sessionCount = (acc.sessionCount || 0) + (topology.stats.sessionCount || 0)
     acc.presenceCount = (acc.presenceCount || 0) + (topology.stats.presenceCount || 0)
+    acc.environmentCount = (acc.environmentCount || 0) + (topology.stats.environmentCount || 0)
+    acc.availableEnvironmentCount = (acc.availableEnvironmentCount || 0) + (topology.stats.availableEnvironmentCount || 0)
     acc.pendingPairingCount += topology.stats.pendingPairingCount
     acc.hasErrors = acc.hasErrors || topology.stats.hasErrors
     acc.lastTopologyErrorCount = (acc.lastTopologyErrorCount || 0) + (topology.stats.lastTopologyErrorCount || 0)

package/src/lib/server/operations/operation-pulse.test.ts

@@ -161,4 +161,33 @@ describe('operation pulse', () => {
     assert.ok((pulse.actions[0]?.summary || '').includes('pending OpenClaw pairing'))
     assert.equal(pulse.actions[0]?.href, '/providers')
   })
+
+  it('raises gateway attention when no execution environments are available', () => {
+    const pulse = buildOperationPulse({
+      range: '24h',
+      now,
+      missions: [],
+      runs: [],
+      approvals: [],
+      connectors: [],
+      gateways: [
+        gateway({
+          status: 'healthy',
+          stats: {
+            nodeCount: 1,
+            connectedNodeCount: 1,
+            environmentCount: 2,
+            availableEnvironmentCount: 0,
+            lastTopologyCheckedAt: now - 1000,
+          },
+        }),
+      ],
+    })
+
+    assert.equal(pulse.kpis.gatewayAttention, 1)
+    assert.equal(pulse.actions[0]?.kind, 'gateway')
+    assert.equal(pulse.actions[0]?.severity, 'high')
+    assert.ok((pulse.actions[0]?.summary || '').includes('no available OpenClaw execution environments'))
+    assert.equal(pulse.actions[0]?.evidence.includes('0/2 environments'), true)
+  })
 })

package/src/lib/server/operations/operation-pulse.ts

@@ -87,6 +87,7 @@ function gatewayAttentionReason(gateway: GatewayProfile, now: number): {
   const evidence = [
     `status:${gateway.status}`,
     `${gateway.stats?.connectedNodeCount || 0}/${gateway.stats?.nodeCount || 0} nodes`,
+    `${gateway.stats?.availableEnvironmentCount || 0}/${gateway.stats?.environmentCount || 0} environments`,
   ]
 
   if (gateway.status === 'offline') {
@@ -113,6 +114,14 @@ function gatewayAttentionReason(gateway: GatewayProfile, now: number): {
     }
   }
 
+  if ((gateway.stats?.environmentCount || 0) > 0 && (gateway.stats?.availableEnvironmentCount || 0) === 0) {
+    return {
+      severity: 'high',
+      summary: `${gateway.name} has no available OpenClaw execution environments.`,
+      evidence,
+    }
+  }
+
   if (pendingPairings > 0) {
     return {
       severity: 'medium',

package/src/lib/server/session-tools/extension-creator.ts

@@ -138,6 +138,54 @@ module.exports = {
     }
   ],
 
+  // --- Managed Resources (Paperclip-compatible) ---
+  managedResources: {
+    agents: [
+      {
+        agentKey: 'researcher',
+        displayName: 'Managed Researcher',
+        description: 'Reusable agent this extension can provision.',
+        systemPrompt: 'Research carefully and cite durable evidence.',
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        capabilities: ['research', 'analysis'],
+        extensions: ['web', 'memory']
+      }
+    ],
+    schedules: [
+      {
+        scheduleKey: 'daily-digest',
+        displayName: 'Daily Digest',
+        agentRef: { resourceKind: 'agent', resourceKey: 'researcher' },
+        taskPrompt: 'Prepare the daily digest.',
+        scheduleType: 'cron',
+        cron: '0 9 * * *',
+        timezone: 'UTC',
+        status: 'paused'
+      }
+    ],
+    localFolders: [
+      {
+        folderKey: 'workspace',
+        displayName: 'Workspace Folder',
+        access: 'readWrite',
+        requiredDirectories: ['inputs', 'outputs']
+      }
+    ],
+    gatewayPlatforms: [
+      {
+        platformKey: 'openai-compatible-api',
+        displayName: 'OpenAI-compatible API',
+        transport: 'http',
+        endpoint: 'http://127.0.0.1:8642/v1',
+        authMode: 'bearer'
+      }
+    ],
+    setupChecks: [
+      { checkKey: 'api-key', displayName: 'API key configured', kind: 'env', target: 'OPENAI_API_KEY', required: true }
+    ]
+  },
+
   // --- Real OpenClaw Format (register API) ---
   register(api) {
     api.registerHook('agent:start', (ctx) => {
@@ -162,6 +210,8 @@ Key rules:
 - If your extension needs npm/pnpm/yarn/bun packages, include a packageJson object during scaffold or call install_dependencies later.
 - Dependency installs are run by the extension manager inside a per-extension workspace using the selected package manager with scripts disabled.
 - Extension settings are declared through ui.settingsFields and stored per extension ID
+- Managed resources let an extension declare provisionable agents, schedules/routines, trusted local folders, gateway platforms, and setup checks. Operators reconcile them through Extensions > Managed Resources or /api/extensions/managed-resources.
+- Paperclip-compatible top-level agents, routines, and localFolders are also accepted; SwarmClaw reconciles routines as schedules when they include schedule timing.
 - Keep extensions focused: one clear purpose per extension
 `
     }