@swarmclawai/swarmclaw 1.9.3 → 1.9.4

package/README.md

@@ -399,19 +399,29 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.4 Highlights
+
+Bundled runtime-environment release: gateway execution visibility, task context handoff, and operator triage in one release cycle.
+
+- **OpenClaw environments.** Gateway topology now calls `environments.list`, stores available environment counts, exposes `/api/gateways/:id/environments`, and adds CLI commands for list/status checks.
+- **Provider dashboard visibility.** The Providers screen now shows fleet-wide and per-gateway execution environment availability alongside nodes, sessions, presence, and pairings.
+- **Task context packets.** Prepared task workspaces now write `context.json` with task, preview, runtime, blocker, tag, and upstream-result context for external workers.
+- **Runtime env handoff.** Workspaces now include `.env.swarmclaw` plus SwarmClaw, portable task/workspace, and `AGENT_HOME` env hints without embedding secrets.
+- **Operations Pulse triage.** Gateway actions now surface zero-available-environment states as high-priority operator work.
+
 ### v1.9.3 Highlights
 
-Bundled extension-orchestration release: Paperclip-style managed plugin resources, Hermes-style gateway/setup declarations, and safer local folder access in one release cycle.
+Bundled extension-orchestration release: managed plugin resources, gateway/setup declarations, and safer local folder access in one release cycle.
 
-- **Managed extension resources.** Extensions can now declare provisionable agents, schedules/routines, local folders, gateway platforms, and setup checks through `managedResources` or Paperclip-compatible top-level aliases.
+- **Managed extension resources.** Extensions can now declare provisionable agents, schedules/routines, local folders, gateway platforms, and setup checks through `managedResources` or top-level manifest aliases.
 - **Deterministic reconciliation.** `/api/extensions/managed-resources` can preview and reconcile extension-owned agents and routines with stable IDs and `managedByExtension` markers.
 - **Trusted local folders.** Extension-declared local folders support root-bounded inspection and recursive listing with traversal and symlink-escape protection.
 - **Operator UI.** The Extensions screen now shows managed-resource badges and a Managed tab with totals plus per-extension reconcile controls.
-- **Extension authoring spec.** `extension_creator` now documents managed resources, gateway declarations, setup checks, and Paperclip-compatible manifest aliases.
+- **Extension authoring spec.** `extension_creator` now documents managed resources, gateway declarations, setup checks, and manifest aliases.
 
 ### v1.9.2 Highlights
 
-Bundled competitor-parity release: Hermes-style reasoning hygiene, deterministic delegation routing, Mission Control task workflow polish, OpenClaw export hardening, and Paperclip-style timeout hygiene.
+Bundled runtime-polish release: reasoning hygiene, deterministic delegation routing, task workflow polish, OpenClaw export hardening, and timeout hygiene.
 
 - **Stateful reasoning tag scrubber.** String-streamed `<think>`, `<thinking>`, `<reasoning>`, `<thought>`, and `<REASONING_SCRATCHPAD>` blocks are removed across split deltas and routed into SwarmClaw's thinking stream instead of leaking into visible answers.
 - **Deterministic delegation profiles.** `manage_tasks` now accepts explicit `workType` and `requiredCapabilities` routing hints, returns a stable `routeKey`, and can auto-assign unowned work without a classifier call when the profile is explicit.
@@ -421,7 +431,7 @@ Bundled competitor-parity release: Hermes-style reasoning hygiene, deterministic
 
 ### v1.9.1 Highlights
 
-Task execution workspace release: the first Paperclip-style work-control slice for task-scoped workspaces, preview handoffs, and liveness evidence.
+Task execution workspace release: task-scoped workspaces, preview handoffs, and liveness evidence.
 
 - **Task-scoped execution workspaces.** Tasks can now provision a deterministic workspace under the SwarmClaw workspace root, preserving source cwd and project context while creating a task-local README for artifacts and handoffs.
 - **Preview and runtime metadata.** Tasks can carry preview links and runtime services, and the task board surfaces those links directly on task cards and sheets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.3",
+  "version": "1.9.4",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/src/app/api/gateways/[id]/environments/[environmentId]/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server'
+
+import { notFound } from '@/lib/server/collection-helpers'
+import { getOpenClawGatewayEnvironmentStatus } from '@/lib/server/gateways/gateway-topology'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ id: string; environmentId: string }> },
+) {
+  const { id, environmentId } = await params
+  const snapshot = await getOpenClawGatewayEnvironmentStatus(id, decodeURIComponent(environmentId))
+  if (!snapshot) return notFound()
+  return NextResponse.json(snapshot, { status: snapshot.errors.length > 0 ? 502 : 200 })
+}

package/src/app/api/gateways/[id]/environments/route.ts

@@ -0,0 +1,13 @@
+import { NextResponse } from 'next/server'
+
+import { notFound } from '@/lib/server/collection-helpers'
+import { listOpenClawGatewayEnvironments } from '@/lib/server/gateways/gateway-topology'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const snapshot = await listOpenClawGatewayEnvironments(id)
+  if (!snapshot) return notFound()
+  return NextResponse.json(snapshot)
+}

package/src/app/api/gateways/topology-route.test.ts

@@ -18,6 +18,36 @@ test('gateway topology route returns 404 for unknown profiles', () => {
   assert.equal(output.body.error, 'Not found')
 })
 
+test('gateway environments route returns 404 for unknown profiles', () => {
+  const output = runWithTempDataDir<{ status: number; body: { error: string } }>(`
+    const routeMod = await import('./src/app/api/gateways/[id]/environments/route')
+    const route = routeMod.default || routeMod
+    const response = await route.GET(
+      new Request('http://local/api/gateways/missing/environments'),
+      { params: Promise.resolve({ id: 'missing' }) },
+    )
+    console.log(JSON.stringify({ status: response.status, body: await response.json() }))
+  `, { prefix: 'swarmclaw-gateway-environments-route-test-' })
+
+  assert.equal(output.status, 404)
+  assert.equal(output.body.error, 'Not found')
+})
+
+test('gateway environment status route returns 404 for unknown profiles', () => {
+  const output = runWithTempDataDir<{ status: number; body: { error: string } }>(`
+    const routeMod = await import('./src/app/api/gateways/[id]/environments/[environmentId]/route')
+    const route = routeMod.default || routeMod
+    const response = await route.GET(
+      new Request('http://local/api/gateways/missing/environments/gateway'),
+      { params: Promise.resolve({ id: 'missing', environmentId: 'gateway' }) },
+    )
+    console.log(JSON.stringify({ status: response.status, body: await response.json() }))
+  `, { prefix: 'swarmclaw-gateway-environment-status-route-test-' })
+
+  assert.equal(output.status, 404)
+  assert.equal(output.body.error, 'Not found')
+})
+
 test('gateway fleet route reports empty totals when no OpenClaw profiles exist', () => {
   const output = runWithTempDataDir<{
     status: number

package/src/app/api/tasks/task-workspace-route.test.ts

@@ -81,9 +81,13 @@ test('PUT /api/tasks/:id provisions an execution workspace and preview links', a
   assert.equal(response.status, 200)
   const body = await response.json() as BoardTask
   assert.equal(body.executionWorkspace?.sourceCwd, '/source/repo')
+  assert.equal(body.executionWorkspace?.context?.taskId, 'task-route-workspace')
+  assert.equal(body.executionWorkspace?.envHints?.some((hint) => hint.key === 'WORKSPACE_CWD'), true)
   assert.equal(body.previewLinks?.[0]?.url, 'http://127.0.0.1:3456')
   assert.equal(body.runtimeServices?.[0]?.name, 'Next dev')
   assert.equal(fs.existsSync(body.executionWorkspace?.path || ''), true)
+  assert.equal(fs.existsSync(body.executionWorkspace?.contextPath || ''), true)
+  assert.equal(fs.existsSync(body.executionWorkspace?.envPath || ''), true)
 })
 
 test('GET /api/tasks returns computed blocked liveness without persisting a task patch', async () => {

package/src/cli/index.js

@@ -273,6 +273,8 @@ const COMMAND_GROUPS = [
       cmd('delete', 'DELETE', '/gateways/:id', 'Delete a gateway profile'),
       cmd('health', 'GET', '/gateways/:id/health', 'Run a gateway health check'),
       cmd('topology', 'GET', '/gateways/:id/topology', 'Refresh and return one gateway topology snapshot'),
+      cmd('environments', 'GET', '/gateways/:id/environments', 'List OpenClaw gateway execution environments'),
+      cmd('environment-status', 'GET', '/gateways/:id/environments/:environmentId', 'Get one OpenClaw gateway execution environment status'),
       cmd('fleet', 'GET', '/gateways/fleet', 'Refresh and return fleet-wide gateway topology'),
     ],
   },

package/src/cli/spec.js

@@ -221,6 +221,8 @@ const COMMAND_GROUPS = {
       delete: { description: 'Delete a gateway profile', method: 'DELETE', path: '/gateways/:id', params: ['id'] },
       health: { description: 'Run a gateway health check', method: 'GET', path: '/gateways/:id/health', params: ['id'] },
       topology: { description: 'Refresh and return one gateway topology snapshot', method: 'GET', path: '/gateways/:id/topology', params: ['id'] },
+      environments: { description: 'List OpenClaw gateway execution environments', method: 'GET', path: '/gateways/:id/environments', params: ['id'] },
+      'environment-status': { description: 'Get one OpenClaw gateway execution environment status', method: 'GET', path: '/gateways/:id/environments/:environmentId', params: ['id', 'environmentId'] },
       fleet: { description: 'Refresh and return fleet-wide gateway topology', method: 'GET', path: '/gateways/fleet' },
     },
   },

package/src/components/providers/provider-list.tsx

@@ -475,10 +475,14 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
               <div className="text-[12px] font-800 text-text">Gateway fleet topology</div>
               <div className="mt-1 text-[11px] text-text-3/70">
                 {gatewayFleetTopology.totals.connectedGatewayCount}/{gatewayFleetTopology.totals.gatewayCount} gateways connected ·{' '}
-                {gatewayFleetTopology.totals.connectedNodeCount}/{gatewayFleetTopology.totals.nodeCount} nodes connected
+                {gatewayFleetTopology.totals.connectedNodeCount}/{gatewayFleetTopology.totals.nodeCount} nodes connected ·{' '}
+                {gatewayFleetTopology.totals.availableEnvironmentCount || 0}/{gatewayFleetTopology.totals.environmentCount || 0} environments available
               </div>
             </div>
             <div className="flex flex-wrap gap-2 text-[11px] text-text-3/70">
+              <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2.5 py-1">
+                {gatewayFleetTopology.totals.environmentCount || 0} environments
+              </span>
               <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2.5 py-1">
                 {gatewayFleetTopology.totals.sessionCount || 0} sessions
               </span>
@@ -536,6 +540,7 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
             const topologyErrors = topology?.errors || []
             const pendingPairings = (stats?.pendingNodePairings || 0) + (stats?.pendingDevicePairings || 0)
             const topologyErrorCount = topologyErrors.length || stats?.lastTopologyErrorCount || 0
+            const environments = topology?.environments || []
             return (
           <div
             key={gateway.id}
@@ -602,6 +607,12 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
                     {stats?.connectedNodeCount ?? 0}/{stats?.nodeCount ?? 0} nodes · {stats?.pairedDeviceCount ?? 0} devices
                   </div>
                 </div>
+                <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                  <div className="uppercase tracking-[0.08em] text-text-3/50">Environments</div>
+                  <div className="mt-1 text-text-2">
+                    {stats?.availableEnvironmentCount ?? 0}/{stats?.environmentCount ?? 0} available
+                  </div>
+                </div>
                 <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
                   <div className="uppercase tracking-[0.08em] text-text-3/50">Sessions</div>
                   <div className="mt-1 text-text-2">
@@ -616,6 +627,28 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
                 </div>
               </div>
             )}
+            {!inSidebar && environments.length > 0 && (
+              <div className="mt-3 flex flex-wrap gap-1.5">
+                {environments.slice(0, 4).map((environment) => (
+                  <span
+                    key={`${gateway.id}-${environment.id}`}
+                    className={`rounded-full border px-2 py-0.5 text-[10px] font-700 uppercase tracking-[0.08em] ${
+                      environment.status === 'available'
+                        ? 'border-emerald-400/20 bg-emerald-400/[0.06] text-emerald-300'
+                        : 'border-white/[0.06] bg-white/[0.03] text-text-3/70'
+                    }`}
+                    title={environment.capabilities?.join(', ') || environment.id}
+                  >
+                    {environment.label || environment.id}
+                  </span>
+                ))}
+                {environments.length > 4 && (
+                  <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2 py-0.5 text-[10px] font-700 uppercase tracking-[0.08em] text-text-3/70">
+                    +{environments.length - 4}
+                  </span>
+                )}
+              </div>
+            )}
             {!inSidebar && (pendingPairings > 0 || topologyErrorCount > 0) && (
               <div className={`mt-3 rounded-[10px] border px-3 py-2 text-[11px] leading-relaxed ${
                 topologyErrorCount > 0

package/src/components/tasks/task-sheet.tsx

@@ -462,6 +462,31 @@ export function TaskSheet() {
             {editing.executionWorkspace?.path && (
               <code className="block text-[12px] text-text-3 font-mono break-all">{editing.executionWorkspace.path}</code>
             )}
+            {(editing.executionWorkspace?.contextPath || editing.executionWorkspace?.envPath) && (
+              <div className="grid grid-cols-1 gap-2 text-[11px] text-text-3/70">
+                {editing.executionWorkspace.contextPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Context</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.contextPath}</code>
+                  </div>
+                )}
+                {editing.executionWorkspace.envPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Env</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.envPath}</code>
+                  </div>
+                )}
+              </div>
+            )}
+            {editing.executionWorkspace?.envHints?.length ? (
+              <div className="flex flex-wrap gap-1.5">
+                {editing.executionWorkspace.envHints.slice(0, 8).map((hint) => (
+                  <InfoChip key={hint.key} tone="neutral" title={hint.value}>
+                    <span className="max-w-[220px] truncate">{hint.key}</span>
+                  </InfoChip>
+                ))}
+              </div>
+            ) : null}
             {previewLinks.length > 0 && (
               <div className="flex flex-wrap gap-2">
                 {previewLinks.map((link) => (
@@ -942,6 +967,31 @@ export function TaskSheet() {
             {editing.executionWorkspace?.path && (
               <code className="block text-[12px] text-text-3 font-mono break-all">{editing.executionWorkspace.path}</code>
             )}
+            {(editing.executionWorkspace?.contextPath || editing.executionWorkspace?.envPath) && (
+              <div className="grid grid-cols-1 gap-2 text-[11px] text-text-3/70">
+                {editing.executionWorkspace.contextPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Context</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.contextPath}</code>
+                  </div>
+                )}
+                {editing.executionWorkspace.envPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Env</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.envPath}</code>
+                  </div>
+                )}
+              </div>
+            )}
+            {editing.executionWorkspace?.envHints?.length ? (
+              <div className="flex flex-wrap gap-1.5">
+                {editing.executionWorkspace.envHints.slice(0, 8).map((hint) => (
+                  <InfoChip key={hint.key} tone="neutral" title={hint.value}>
+                    <span className="max-w-[220px] truncate">{hint.key}</span>
+                  </InfoChip>
+                ))}
+              </div>
+            ) : null}
             {previewLinks.length > 0 && (
               <div className="flex flex-wrap gap-2">
                 {previewLinks.map((link) => (

package/src/features/gateways/queries.ts

@@ -3,6 +3,7 @@ import { api } from '@/lib/app/api-client'
 import { credentialQueryKeys } from '@/features/credentials/queries'
 import type {
   GatewayProfile,
+  OpenClawEnvironmentSummary,
   OpenClawDevicePairRequest,
   OpenClawGatewayFleetTopology,
   OpenClawGatewayPresenceEntry,
@@ -60,6 +61,7 @@ export interface RefreshGatewayTopologyResult {
   pairedDevices: OpenClawPairedDevice[]
   sessions: OpenClawGatewaySession[]
   presence: OpenClawGatewayPresenceEntry[]
+  environments: OpenClawEnvironmentSummary[]
   errors: OpenClawGatewayRpcError[]
   topology: OpenClawGatewayTopology
 }
@@ -190,6 +192,7 @@ export function useRefreshGatewayTopologyMutation() {
         pairedDevices: topology.pairedDevices,
         sessions: topology.sessions,
         presence: topology.presence,
+        environments: topology.environments,
         errors: topology.errors,
         topology,
       }

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/tasks/task-execution-workspace.test.ts

@@ -66,10 +66,24 @@ describe('task execution workspaces', () => {
     assert.match(patch.executionWorkspace.path, /task-alpha-launch-qa-preview/)
     assert.equal(fs.existsSync(patch.executionWorkspace.path), true)
     assert.equal(fs.existsSync(patch.executionWorkspace.readmePath || ''), true)
+    assert.equal(fs.existsSync(patch.executionWorkspace.contextPath || ''), true)
+    assert.equal(fs.existsSync(patch.executionWorkspace.envPath || ''), true)
     assert.equal(patch.executionWorkspace.sourceCwd, '/repo/source')
+    assert.equal(patch.executionWorkspace.context?.taskId, 'task-alpha')
+    assert.equal(patch.executionWorkspace.context?.workspacePath, patch.executionWorkspace.path)
+    assert.equal(patch.executionWorkspace.envHints?.some((hint) => hint.key === 'WORKSPACE_CWD'), true)
+    assert.equal(patch.executionWorkspace.envHints?.some((hint) => hint.key === 'KANBAN_TASK_ID'), true)
     assert.equal(patch.executionWorkspace.previewLinks[0]?.label, 'Local preview')
     assert.equal(patch.previewLinks[0]?.url, 'http://127.0.0.1:3456')
     assert.equal(patch.runtimeServices[0]?.status, 'planned')
+
+    const context = JSON.parse(fs.readFileSync(patch.executionWorkspace.contextPath || '', 'utf8'))
+    assert.equal(context.taskId, 'task-alpha')
+    assert.equal(context.previewLinks[0]?.url, 'http://127.0.0.1:3456')
+    const envFile = fs.readFileSync(patch.executionWorkspace.envPath || '', 'utf8')
+    assert.equal(envFile.includes('SWARMCLAW_TASK_ID="task-alpha"'), true)
+    assert.equal(envFile.includes('WORKSPACE_SOURCE="/repo/source"'), true)
+    assert.equal(envFile.includes('KANBAN_WORKSPACE='), true)
   })
 
   it('deduplicates preview URLs and computes blocked, stale, and retrying liveness', () => {

package/src/lib/server/tasks/task-execution-workspace.ts

@@ -7,6 +7,8 @@ import type {
   TaskExecutionWorkspace,
   TaskLivenessSnapshot,
   TaskPreviewLink,
+  TaskRuntimeContextPacket,
+  TaskRuntimeEnvHint,
   TaskRuntimeService,
 } from '@/types'
 
@@ -182,11 +184,106 @@ function writeWorkspaceReadme(task: BoardTask, workspacePath: string, now: numbe
   ]
   if (task.projectId) lines.push(`Project ID: ${task.projectId}`)
   if (task.cwd) lines.push(`Source cwd: ${task.cwd}`)
-  lines.push('', 'Use this directory for task-local notes, generated artifacts, and preview handoff files.')
+  lines.push(
+    '',
+    'Runtime context: ./context.json',
+    'Environment hints: ./.env.swarmclaw',
+    '',
+    'Use this directory for task-local notes, generated artifacts, and preview handoff files.',
+  )
   fs.writeFileSync(readmePath, `${lines.join('\n')}\n`, 'utf8')
   return readmePath
 }
 
+function addEnvHint(out: TaskRuntimeEnvHint[], key: string, value: unknown, description?: string) {
+  if (typeof value !== 'string' || !value) return
+  out.push({ key, value, ...(description ? { description } : {}) })
+}
+
+function buildRuntimeEnvHints(params: {
+  task: BoardTask
+  workspacePath: string
+  sourceCwd?: string | null
+  mode: TaskExecutionWorkspace['mode']
+  contextPath: string
+  envPath: string
+}): TaskRuntimeEnvHint[] {
+  const { task, workspacePath, sourceCwd, mode, contextPath, envPath } = params
+  const hints: TaskRuntimeEnvHint[] = []
+  const workspaceId = taskWorkspaceSlug(task)
+  addEnvHint(hints, 'SWARMCLAW_TASK_ID', task.id, 'SwarmClaw task id')
+  addEnvHint(hints, 'SWARMCLAW_TASK_TITLE', task.title || 'Task', 'SwarmClaw task title')
+  addEnvHint(hints, 'SWARMCLAW_TASK_STATUS', task.status, 'SwarmClaw task status')
+  addEnvHint(hints, 'SWARMCLAW_TASK_AGENT_ID', task.agentId, 'Assigned SwarmClaw agent id')
+  addEnvHint(hints, 'SWARMCLAW_WORKSPACE_ID', workspaceId, 'Stable task workspace id')
+  addEnvHint(hints, 'SWARMCLAW_WORKSPACE_CWD', workspacePath, 'Task workspace directory')
+  addEnvHint(hints, 'SWARMCLAW_WORKSPACE_MODE', mode, 'Task workspace mode')
+  addEnvHint(hints, 'SWARMCLAW_WORKSPACE_CONTEXT', contextPath, 'Runtime context packet path')
+  addEnvHint(hints, 'SWARMCLAW_WORKSPACE_ENV', envPath, 'Reusable runtime env file')
+  addEnvHint(hints, 'SWARMCLAW_PROJECT_ID', task.projectId || '', 'SwarmClaw project id')
+  addEnvHint(hints, 'SWARMCLAW_SOURCE_CWD', sourceCwd || '', 'Original source directory')
+  addEnvHint(hints, 'AGENT_HOME', workspacePath, 'Agent-local home directory')
+  addEnvHint(hints, 'TASK_ID', task.id, 'Portable task id')
+  addEnvHint(hints, 'TASK_TITLE', task.title || 'Task', 'Portable task title')
+  addEnvHint(hints, 'WORKSPACE_ID', workspaceId, 'Portable workspace id')
+  addEnvHint(hints, 'WORKSPACE_CWD', workspacePath, 'Portable workspace cwd')
+  addEnvHint(hints, 'WORKSPACE_SOURCE', sourceCwd || workspacePath, 'Portable source path')
+  addEnvHint(
+    hints,
+    'WORKSPACE_STRATEGY',
+    mode === 'project' ? 'project-task-workspace' : 'task-workspace',
+    'Portable workspace strategy',
+  )
+  addEnvHint(hints, 'KANBAN_TASK_ID', task.id, 'Portable board task id')
+  addEnvHint(hints, 'KANBAN_WORKSPACE', workspacePath, 'Portable board workspace path')
+  return hints
+}
+
+function envLine(hint: TaskRuntimeEnvHint): string {
+  return `${hint.key}=${JSON.stringify(hint.value)}`
+}
+
+function writeWorkspaceEnv(envPath: string, hints: TaskRuntimeEnvHint[]) {
+  const lines = [
+    '# Generated by SwarmClaw. Contains task context only, not secrets.',
+    ...hints.map(envLine),
+  ]
+  fs.writeFileSync(envPath, `${lines.join('\n')}\n`, 'utf8')
+}
+
+function buildTaskRuntimeContext(params: {
+  task: BoardTask
+  executionWorkspace: Omit<TaskExecutionWorkspace, 'context'>
+  previewLinks: TaskPreviewLink[]
+  runtimeServices: TaskRuntimeService[]
+  generatedAt: number
+}): TaskRuntimeContextPacket {
+  const { task, executionWorkspace, previewLinks, runtimeServices, generatedAt } = params
+  return {
+    taskId: task.id,
+    title: task.title || 'Task',
+    description: task.description || undefined,
+    status: task.status,
+    agentId: task.agentId,
+    projectId: executionWorkspace.projectId || null,
+    workspacePath: executionWorkspace.path,
+    sourceCwd: executionWorkspace.sourceCwd || null,
+    mode: executionWorkspace.mode,
+    preparedAt: executionWorkspace.preparedAt,
+    generatedAt,
+    previewLinks,
+    runtimeServices,
+    blockedBy: task.blockedBy,
+    blocks: task.blocks,
+    tags: task.tags,
+    upstreamResults: task.upstreamResults,
+  }
+}
+
+function writeWorkspaceContext(contextPath: string, context: TaskRuntimeContextPacket) {
+  fs.writeFileSync(contextPath, `${JSON.stringify(context, null, 2)}\n`, 'utf8')
+}
+
 export function computeTaskLiveness(
   task: BoardTask,
   tasks: Record<string, BoardTask> = {},
@@ -284,6 +381,8 @@ export function prepareTaskExecutionWorkspace(
   const existing = task.executionWorkspace || null
   const workspacePath = existing?.path || path.join(taskWorkspaceRoot(task, workspaceRoot), taskWorkspaceSlug(task))
   fs.mkdirSync(workspacePath, { recursive: true })
+  const contextPath = path.join(workspacePath, 'context.json')
+  const envPath = path.join(workspacePath, '.env.swarmclaw')
   const readmePath = writeWorkspaceReadme(task, workspacePath, now)
   const previewLinks = normalizeTaskPreviewLinks(
     task.previewLinks || existing?.previewLinks,
@@ -295,17 +394,45 @@ export function prepareTaskExecutionWorkspace(
     options.runtimeServices,
     now,
   )
-  const executionWorkspace: TaskExecutionWorkspace = {
+  const mode: TaskExecutionWorkspace['mode'] = task.projectId ? 'project' : 'task'
+  const sourceCwd = task.cwd || existing?.sourceCwd || null
+  const projectId = task.projectId || existing?.projectId || null
+  const preparedAt = existing?.preparedAt || now
+  const envHints = buildRuntimeEnvHints({
+    task,
+    workspacePath,
+    sourceCwd,
+    mode,
+    contextPath,
+    envPath,
+  })
+  const executionWorkspaceBase: Omit<TaskExecutionWorkspace, 'context'> = {
     path: workspacePath,
-    mode: task.projectId ? 'project' : 'task',
-    sourceCwd: task.cwd || existing?.sourceCwd || null,
-    projectId: task.projectId || existing?.projectId || null,
-    preparedAt: existing?.preparedAt || now,
+    mode,
+    sourceCwd,
+    projectId,
+    preparedAt,
     preparedBy: options.actor || existing?.preparedBy || null,
     readmePath,
+    contextPath,
+    envPath,
+    envHints,
     previewLinks,
     runtimeServices,
   }
+  const context = buildTaskRuntimeContext({
+    task,
+    executionWorkspace: executionWorkspaceBase,
+    previewLinks,
+    runtimeServices,
+    generatedAt: now,
+  })
+  writeWorkspaceContext(contextPath, context)
+  writeWorkspaceEnv(envPath, envHints)
+  const executionWorkspace: TaskExecutionWorkspace = {
+    ...executionWorkspaceBase,
+    context,
+  }
   const taskForLiveness = {
     ...task,
     executionWorkspace,

package/src/types/misc.ts

@@ -672,6 +672,8 @@ export interface OpenClawGatewayStats {
   externalRuntimeCount?: number
   sessionCount?: number
   presenceCount?: number
+  environmentCount?: number
+  availableEnvironmentCount?: number
   lastTopologyCheckedAt?: number
   lastTopologyErrorCount?: number
   lastTopologyError?: string | null
@@ -803,7 +805,19 @@ export interface OpenClawGatewayPresenceEntry {
   updatedAt?: number | null
 }
 
+export type OpenClawEnvironmentStatus = 'available' | 'unavailable' | 'starting' | 'stopping' | 'error'
+
+export interface OpenClawEnvironmentSummary {
+  id: string
+  type: string
+  label?: string | null
+  status: OpenClawEnvironmentStatus
+  capabilities?: string[]
+}
+
 export interface OpenClawGatewayTopologyStats extends OpenClawGatewayStats {
+  environmentCount: number
+  availableEnvironmentCount: number
   pendingPairingCount: number
   hasErrors: boolean
 }
@@ -819,6 +833,23 @@ export interface OpenClawGatewayTopology {
   pairedDevices: OpenClawPairedDevice[]
   sessions: OpenClawGatewaySession[]
   presence: OpenClawGatewayPresenceEntry[]
+  environments: OpenClawEnvironmentSummary[]
+  errors: OpenClawGatewayRpcError[]
+}
+
+export interface OpenClawGatewayEnvironmentList {
+  profile: GatewayProfile
+  connected: boolean
+  refreshedAt: number
+  environments: OpenClawEnvironmentSummary[]
+  errors: OpenClawGatewayRpcError[]
+}
+
+export interface OpenClawGatewayEnvironmentStatusSnapshot {
+  profile: GatewayProfile
+  connected: boolean
+  refreshedAt: number
+  environment: OpenClawEnvironmentSummary | null
   errors: OpenClawGatewayRpcError[]
 }
 

package/src/types/task.ts

@@ -43,6 +43,32 @@ export interface TaskRuntimeService {
   updatedAt: number
 }
 
+export interface TaskRuntimeEnvHint {
+  key: string
+  value: string
+  description?: string
+}
+
+export interface TaskRuntimeContextPacket {
+  taskId: string
+  title: string
+  description?: string
+  status: BoardTaskStatus
+  agentId: string
+  projectId?: string | null
+  workspacePath: string
+  sourceCwd?: string | null
+  mode: TaskExecutionWorkspaceMode
+  preparedAt: number
+  generatedAt: number
+  previewLinks: TaskPreviewLink[]
+  runtimeServices: TaskRuntimeService[]
+  blockedBy?: string[]
+  blocks?: string[]
+  tags?: string[]
+  upstreamResults?: BoardTask['upstreamResults']
+}
+
 export interface TaskExecutionWorkspace {
   path: string
   mode: TaskExecutionWorkspaceMode
@@ -51,6 +77,10 @@ export interface TaskExecutionWorkspace {
   preparedAt: number
   preparedBy?: string | null
   readmePath?: string | null
+  contextPath?: string | null
+  envPath?: string | null
+  envHints?: TaskRuntimeEnvHint[]
+  context?: TaskRuntimeContextPacket
   previewLinks: TaskPreviewLink[]
   runtimeServices: TaskRuntimeService[]
 }