diff --git a/forge/comms/aclManager.js b/forge/comms/aclManager.js
index d760fb7db9..51e8349e45 100644
--- a/forge/comms/aclManager.js
+++ b/forge/comms/aclManager.js
@@ -140,6 +140,29 @@ module.exports = function (app) {
                 return false
             }
         },
+        checkTeamStateSub: async function (requestParts, usernameParts) {
+            // requestParts = [ fullTopic , <teamHash> , <entityId|'+'> ]
+            // usernameParts = [ 'fe-team', <userHash>, <teamHash>, <sessionId> ]
+            // team-wide status wildcard: gate on team membership only. requestParts[2]
+            // is the instance/device id (or '+'), never the user — don't validate it.
+            const topicTeamHash = requestParts[1]
+            const usernameUserHash = usernameParts[1]
+            const usernameTeamHash = usernameParts[2]
+            if (topicTeamHash !== usernameTeamHash) {
+                return false
+            }
+            try {
+                const team = await app.db.models.Team.byId(usernameTeamHash)
+                if (!team) return false
+                const user = await app.db.models.User.byId(usernameUserHash)
+                if (!user) return false
+                const membership = await app.db.models.TeamMember.getTeamMembership(user.id, team.id, false)
+                return !!membership
+            } catch (error) {
+                app.log.error('Unexpected error during team-channel status ACL check', { requestParts, usernameParts, error })
+                return false
+            }
+        },
         checkExpertTopic: async function (topicParts, usernameParts, acl) {
             // topicParts = [ fullTopic , <userid>, <sessionid>, <entityType>, <entityId> [, <inflightType>] ]
             // usernameParts = [ 'expert-client' | 'expert-agent', <userid> [, <sessionid>] ]
@@ -333,6 +356,10 @@ module.exports = function (app) {
                 { topic: /^ff\/v1\/[^/]+\/t\/updated$/ },
                 // - ff/v1/<team>/u/<user>/membership
                 { topic: /^ff\/v1\/[^/]+\/u\/[^/]+\/membership$/ },
+                // - ff/v1/<team>/p/<instance>/state
+                { topic: /^ff\/v1\/[^/]+\/p\/[^/]+\/state$/ },
+                // - ff/v1/<team>/d/<device>/state
+                { topic: /^ff\/v1\/[^/]+\/d\/[^/]+\/state$/ },
                 // ff/v1/platform/sync
                 { topic: /^ff\/v1\/platform\/sync$/ },
                 // ff/v1/platform/leader
@@ -396,7 +423,11 @@ module.exports = function (app) {
                 // - ff/v1/<team>/t/updated
                 { topic: /^ff\/v1\/([^/]+)\/t\/updated$/, verify: 'checkUserIsTeamMember' },
                 // - ff/v1/<team>/u/<user>/membership
-                { topic: /^ff\/v1\/([^/]+)\/u\/([^/]+)\/membership$/, verify: 'checkUserIsTeamMember' }
+                { topic: /^ff\/v1\/([^/]+)\/u\/([^/]+)\/membership$/, verify: 'checkUserIsTeamMember' },
+                // - ff/v1/<team>/p/+/state
+                { topic: /^ff\/v1\/([^/]+)\/p\/([^/]+)\/state$/, verify: 'checkTeamStateSub' },
+                // - ff/v1/<team>/d/+/state
+                { topic: /^ff\/v1\/([^/]+)\/d\/([^/]+)\/state$/, verify: 'checkTeamStateSub' }
             ],
             pub: []
         },
diff --git a/forge/comms/devices.js b/forge/comms/devices.js
index ab85b6d9cc..4c890e5576 100644
--- a/forge/comms/devices.js
+++ b/forge/comms/devices.js
@@ -121,7 +121,11 @@ class DeviceCommsHandler {
             const teamId = this.app.db.models.Team.encodeHashid(device.TeamId)
             const startTime = Date.now()
             try {
+                const previousState = device.state
                 const payload = JSON.parse(status.status)
+                if (previousState === 'restarting' && payload?.state === 'stopped') {
+                    payload.state = 'restarting'
+                }
                 await this.app.db.controllers.Device.updateState(device, payload)
 
                 if (payload === null) {
@@ -130,6 +134,10 @@ class DeviceCommsHandler {
                     return
                 }
 
+                if (payload.state !== previousState) {
+                    this.app.comms.team.notifyDeviceState(teamId, status.id, payload.state)
+                }
+
                 // If the status state===unknown, the device is waiting for confirmation
                 // it has the right details. Always response with an 'update' command in
                 // this scenario
diff --git a/forge/comms/index.js b/forge/comms/index.js
index 04a7c463e0..ab7cb9ed80 100644
--- a/forge/comms/index.js
+++ b/forge/comms/index.js
@@ -71,6 +71,14 @@ module.exports = fp(async function (app, _opts) {
                     if (!teamHash || !userHash) return
                     const msg = { reason: reason || null, srcId: srcId || null }
                     client.publish(`ff/v1/${teamHash}/u/${userHash}/membership`, JSON.stringify(msg))
+                },
+                notifyDeviceState: function (teamHash, id, state) {
+                    if (!teamHash || !id) return
+                    client.publish(`ff/v1/${teamHash}/d/${id}/state`, JSON.stringify({ id, meta: { state } }))
+                },
+                notifyInstanceState: function (teamHash, id, state) {
+                    if (!teamHash || !id) return
+                    client.publish(`ff/v1/${teamHash}/p/${id}/state`, JSON.stringify({ id, meta: { state } }))
                 }
             }
         })
diff --git a/forge/containers/stub/index.js b/forge/containers/stub/index.js
index 03401a8b2d..34faca7fea 100644
--- a/forge/containers/stub/index.js
+++ b/forge/containers/stub/index.js
@@ -119,8 +119,12 @@ module.exports = {
             } else {
                 const startTime = project.name === 'stub-slow-start' ? 6000 : module.exports.START_DELAY
                 return new Promise((resolve, reject) => {
-                    setTimeout(() => {
+                    setTimeout(async () => {
                         list[project.id].state = 'running'
+                        // mirror a real launcher reporting its settled state so inflight clears via the confirm path
+                        try {
+                            await this._app.db.controllers.Project.updateLatestProjectState(project.id, 'running')
+                        } catch (err) {}
                         resolve()
                     }, startTime)
                 })
@@ -218,6 +222,15 @@ module.exports = {
      */
     restartFlows: async (project, options) => {
         this._app.log.info(`[stub driver] Restarting flows ${project.id}`)
+        // mirror a real launcher reporting running shortly after the bounce, so the restarting mask clears
+        setTimeout(async () => {
+            if (list[project.id]) {
+                list[project.id].state = 'running'
+            }
+            try {
+                await this._app.db.controllers.Project.updateLatestProjectState(project.id, 'running')
+            } catch (err) {}
+        }, module.exports.START_DELAY)
     },
 
     /**
diff --git a/forge/db/controllers/Project.js b/forge/db/controllers/Project.js
index 19ee3b8b23..be533e369c 100644
--- a/forge/db/controllers/Project.js
+++ b/forge/db/controllers/Project.js
@@ -14,12 +14,47 @@ const latestProjectState = 'project-latestProjectState'
 
 const inflightDeploys = 'project-inflightDeploys'
 
+const lastPublishedProjectState = 'project-lastPublishedProjectState'
+
+const publishLocks = new Map()
+
 module.exports = {
 
     init (app) {
         app.caches.createCache(inflightProjectState)
         app.caches.createCache(latestProjectState)
         app.caches.createCache(inflightDeploys)
+        app.caches.createCache(lastPublishedProjectState)
+    },
+
+    // serialized per project so concurrent callers can't intermix and strand a stale state
+    publishLiveState: async function (app, project) {
+        if (!app.comms || !project?.TeamId) return
+        const key = project.id
+        const previous = publishLocks.get(key) ?? Promise.resolve()
+        const current = previous.catch(() => {}).then(() => this._publishLiveStateUnlocked(app, project))
+        const tracked = current.finally(() => {
+            if (publishLocks.get(key) === tracked) {
+                publishLocks.delete(key)
+            }
+        })
+        publishLocks.set(key, tracked)
+        return tracked
+    },
+
+    _publishLiveStateUnlocked: async function (app, project) {
+        try {
+            const inflight = await this.getInflightState(app, project)
+            const latest = await this.getLatestProjectState(app, project.id)
+            const effective = inflight ?? (project.state === 'suspended' ? 'suspended' : (latest ?? project.state))
+            if (!effective) return
+            const cache = app.caches.getCache(lastPublishedProjectState)
+            if (await cache.get(project.id) === effective) return
+            await cache.set(project.id, effective)
+            app.comms.team.notifyInstanceState(app.db.models.Team.encodeHashid(project.TeamId), project.id, effective)
+        } catch (err) {
+            app.log.warn(`Failed to broadcast live state for ${project.id}: ${err.toString()}`)
+        }
     },
 
     getProjectPaginationOptions: function (app, request) {
@@ -58,6 +93,7 @@ module.exports = {
      */
     setInflightState: async function (app, project, state) {
         await app.caches.getCache(inflightProjectState).set(project.id, state)
+        await this.publishLiveState(app, project)
     },
 
     /**
@@ -87,6 +123,7 @@ module.exports = {
     clearInflightState: async function (app, project) {
         await app.caches.getCache(inflightProjectState).del(project.id)
         await app.caches.getCache(inflightDeploys).del(project.id)
+        await this.publishLiveState(app, project)
     },
 
     /**
@@ -810,6 +847,16 @@ module.exports = {
         } else {
             await this.setLatestProjectState(app, projectId, state)
         }
+        const project = await app.db.models.Project.byId(projectId, { barebone: true })
+        if (project) {
+            const inflight = await this.getInflightState(app, project)
+            const isTransition = inflight === 'starting' || inflight === 'restarting'
+            if (isTransition && ['running', 'safe', 'crashed'].includes(state)) {
+                await this.clearInflightState(app, project)
+            } else if (app.comms) {
+                await this.publishLiveState(app, project)
+            }
+        }
     }
 }
 
diff --git a/forge/db/models/Project.js b/forge/db/models/Project.js
index fc4817f0e0..a6dab47dfd 100644
--- a/forge/db/models/Project.js
+++ b/forge/db/models/Project.js
@@ -166,6 +166,11 @@ module.exports = {
                     }
                 }
             },
+            afterSave: async (project, opts) => {
+                if (project.changed('state')) {
+                    await Controllers.Project.publishLiveState(project)
+                }
+            },
             afterDestroy: async (project, opts) => {
                 await M.AccessToken.destroy({
                     where: {
diff --git a/forge/routes/api/projectActions.js b/forge/routes/api/projectActions.js
index ebcf8d053d..0483395967 100644
--- a/forge/routes/api/projectActions.js
+++ b/forge/routes/api/projectActions.js
@@ -8,6 +8,7 @@
  * @namespace project
  * @memberof forge.routes.api
  */
+
 module.exports = async function (app) {
     app.post('/start', {
         preHandler: app.needsPermission('project:change-status'),
@@ -50,8 +51,11 @@ module.exports = async function (app) {
                 await app.db.controllers.Project.setInflightState(request.project, 'starting')
                 const startResult = await app.containers.start(request.project)
                 startResult.started.then(async () => {
-                    await app.auditLog.Project.project.started(request.session.User, null, request.project)
-                    await app.db.controllers.Project.clearInflightState(request.project)
+                    if (request.project.state === 'suspended') {
+                        await app.db.controllers.Project.clearInflightState(request.project)
+                    } else {
+                        await app.auditLog.Project.project.started(request.session.User, null, request.project)
+                    }
                     return true
                 }).catch(err => {
                     app.log.info(`failed to start project ${request.project.id}`)
@@ -154,7 +158,6 @@ module.exports = async function (app) {
             await request.project.save()
             await app.containers.restartFlows(request.project)
             await app.auditLog.Project.project.restarted(request.session.User, null, request.project)
-            await app.db.controllers.Project.clearInflightState(request.project)
             reply.send({ status: 'okay' })
         } catch (err) {
             await app.db.controllers.Project.clearInflightState(request.project)
@@ -255,10 +258,12 @@ module.exports = async function (app) {
             }
             await app.db.controllers.Project.setInflightState(request.project, 'rollback')
             await app.db.controllers.Project.importProjectSnapshot(request.project, snapshot)
-            await app.db.controllers.Project.clearInflightState(request.project)
             await app.auditLog.Project.project.snapshot.rolledBack(request.session.User, null, request.project, snapshot)
             if (restartProject) {
+                await app.db.controllers.Project.setInflightState(request.project, 'restarting')
                 await app.containers.restartFlows(request.project)
+            } else {
+                await app.db.controllers.Project.clearInflightState(request.project)
             }
             reply.send({ status: 'okay' })
         } catch (err) {
diff --git a/frontend/src/components/DevicesBrowser.vue b/frontend/src/components/DevicesBrowser.vue
index 24f8883cf0..e05e442327 100644
--- a/frontend/src/components/DevicesBrowser.vue
+++ b/frontend/src/components/DevicesBrowser.vue
@@ -377,6 +377,7 @@ import FfPopover from '../ui-components/components/Popover.vue'
 import PopoverItem from '../ui-components/components/PopoverItem.vue'
 import FfCheckbox from '../ui-components/components/form/Checkbox.vue'
 
+import { applyLiveState } from '../utils/applyLiveState.js'
 import { debounce } from '../utils/eventHandling.js'
 import { createPollTimer } from '../utils/timers.js'
 
@@ -388,6 +389,7 @@ import RemoveDeviceFromGroupDialog from './dialogs/device-group-management/Remov
 
 import { useAccountSettingsStore } from '@/stores/account-settings.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 import { useUxDialogStore } from '@/stores/ux-dialog.js'
 import { useUxToursStore } from '@/stores/ux-tours.js'
 
@@ -468,6 +470,7 @@ export default {
     computed: {
         ...mapState(useContextStore, ['team']),
         ...mapState(useAccountSettingsStore, ['featuresCheck']),
+        ...mapState(useLiveStatusStore, { liveDeviceStatuses: 'deviceStatuses', statusChannelLive: 'live' }),
         ...mapState(useUxDialogStore, ['dialog']),
         ...mapState(useUxToursStore, ['tours']),
         columns () {
@@ -604,11 +607,19 @@ export default {
             if (this.dialog?.is?.payload?.devices) {
                 this.setDialogDevices(devices)
             }
+        },
+        liveDeviceStatuses: { handler: 'applyLiveStatus', deep: true },
+        statusChannelLive (live) {
+            if (live) {
+                this.pollTimer?.stop()
+            } else {
+                this.pollTimer?.start()
+            }
         }
     },
     mounted () {
         this.fullReloadOfData()
-        this.pollTimer = createPollTimer(this.pollTimerElapsed, POLL_TIME) // auto starts
+        this.pollTimer = createPollTimer(this.pollTimerElapsed, POLL_TIME, !this.statusChannelLive)
     },
     async unmounted () {
         this.pollTimer.stop()
@@ -620,6 +631,20 @@ export default {
     },
     methods: {
         ...mapActions(useUxDialogStore, ['setDialogDevices']),
+        applyLiveStatus () {
+            for (const id of this.allDeviceStatuses.keys()) {
+                const state = this.liveDeviceStatuses[id]
+                if (!state) continue
+                const statusObj = this.allDeviceStatuses.get(id)
+                if (statusObj.status !== state) {
+                    this.allDeviceStatuses.set(id, applyLiveState(statusObj, state, { device: true }))
+                }
+                const device = this.devices.get(id)
+                if (device && device.status !== state) {
+                    this.devices.set(id, applyLiveState(device, state, { device: true }))
+                }
+            }
+        },
         pollTimerElapsed: async function () {
             this.pollTimer.pause()
             try {
diff --git a/frontend/src/composables/DeviceHelper.js b/frontend/src/composables/DeviceHelper.js
index 00ea1808e5..87584bb553 100644
--- a/frontend/src/composables/DeviceHelper.js
+++ b/frontend/src/composables/DeviceHelper.js
@@ -7,21 +7,13 @@ import deviceApi from '../api/devices.js'
 import Alerts from '../services/alerts.js'
 import Dialog from '../services/dialog.js'
 import { DeviceStateMutator } from '../utils/DeviceStateMutator.js'
+import { isTransitionState } from '../utils/stateTransitions.js'
 import { createPollTimer } from '../utils/timers.js'
 
 import { useContextStore } from '@/stores/context.js'
 
 // constants
 const POLL_TIME = 5000
-const deviceTransitionStates = [
-    'loading',
-    'installing',
-    'starting',
-    'stopping',
-    'restarting',
-    'suspending',
-    'importing'
-]
 
 export function useDeviceHelper () {
     const $router = useRouter()
@@ -33,7 +25,7 @@ export function useDeviceHelper () {
     // duplicated functionality because the pollTimer is not reactive
     const isPolling = ref(false)
 
-    const isInTransitionState = computed(() => deviceTransitionStates.includes(device.value.status))
+    const isInTransitionState = computed(() => isTransitionState(device.value.status))
 
     const agentSupportsDeviceAccess = computed(() =>
         device.value?.agentVersion && semver.gte(device.value?.agentVersion, '0.8.0')
diff --git a/frontend/src/mixins/Instance.js b/frontend/src/mixins/Instance.js
index 7a2d00b903..0449765016 100644
--- a/frontend/src/mixins/Instance.js
+++ b/frontend/src/mixins/Instance.js
@@ -6,13 +6,16 @@ import usePermissions from '../composables/Permissions.js'
 import alerts from '../services/alerts.js'
 import Dialog from '../services/dialog.js'
 import { InstanceStateMutator } from '../utils/InstanceStateMutator.js'
+import { applyLiveState } from '../utils/applyLiveState.js'
 
 import { useAccountStore } from '@/stores/account.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 
 export default {
     computed: {
         ...mapState(useContextStore, ['team']),
+        ...mapState(useLiveStatusStore, { liveInstanceStatuses: 'instanceStatuses', statusChannelLive: 'live' }),
         instanceRunning () {
             return this.instance?.meta?.state === 'running'
         },
@@ -37,10 +40,16 @@ export default {
         instance (instance) {
             this.instanceChanged()
             this.setContextualInstance(instance)
-        }
+        },
+        liveInstanceStatuses: { handler: 'applyLiveStatus', deep: true }
     },
     methods: {
         ...mapActions(useContextStore, { setContextualInstance: 'setInstance' }),
+        applyLiveStatus () {
+            const state = this.liveInstanceStatuses[this.instance?.id]
+            if (!state || this.instance?.meta?.state === state) return
+            this.instance = applyLiveState(this.instance, state, { clearFlags: true })
+        },
         showConfirmDeleteDialog () {
             this.$refs.confirmInstanceDeleteDialog.show(this.instance)
         },
diff --git a/frontend/src/pages/application/index.vue b/frontend/src/pages/application/index.vue
index 5a9cafe6ee..720bdf3e65 100644
--- a/frontend/src/pages/application/index.vue
+++ b/frontend/src/pages/application/index.vue
@@ -25,7 +25,9 @@
                 @instance-delete="instanceShowConfirmDelete"
             />
 
-            <InstanceStatusPolling v-for="instance in instancesArray" :key="instance.id" :instance="instance" @instance-updated="instanceUpdated" />
+            <template v-if="!statusChannelLive">
+                <InstanceStatusPolling v-for="instance in instancesArray" :key="instance.id" :instance="instance" @instance-updated="instanceUpdated" />
+            </template>
         </div>
     </main>
 </template>
@@ -38,6 +40,7 @@ import usePermissions from '../../composables/Permissions.js'
 
 import applicationMixin from '../../mixins/Application.js'
 import instanceActionsMixin from '../../mixins/InstanceActions.js'
+import { applyLiveState } from '../../utils/applyLiveState.js'
 
 import ConfirmInstanceDeleteDialog from '../instance/Settings/dialogs/ConfirmInstanceDeleteDialog.vue'
 
@@ -45,6 +48,7 @@ import ConfirmApplicationDeleteDialog from './Settings/dialogs/ConfirmApplicatio
 
 import { useAccountSettingsStore } from '@/stores/account-settings.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 
 export default {
     name: 'ApplicationPage',
@@ -62,6 +66,7 @@ export default {
     computed: {
         ...mapState(useContextStore, ['team']),
         ...mapState(useAccountSettingsStore, ['features']),
+        ...mapState(useLiveStatusStore, { liveInstanceStatuses: 'instanceStatuses', statusChannelLive: 'live' }),
         navigation () {
             const routes = [
                 {
@@ -133,6 +138,18 @@ export default {
         '$route.params': {
             handler: 'updateApplication',
             immediate: true
+        },
+        liveInstanceStatuses: { handler: 'applyLiveStatus', deep: true }
+    },
+    methods: {
+        applyLiveStatus () {
+            for (const id of this.applicationInstances.keys()) {
+                const state = this.liveInstanceStatuses[id]
+                if (!state) continue
+                const row = this.applicationInstances.get(id)
+                if (row?.status === state && row?.meta?.state === state) continue
+                this.applicationInstances.set(id, applyLiveState(row, state, { clearFlags: true }))
+            }
         }
     }
 }
diff --git a/frontend/src/pages/device/index.vue b/frontend/src/pages/device/index.vue
index bfa510d9db..d03feafd34 100644
--- a/frontend/src/pages/device/index.vue
+++ b/frontend/src/pages/device/index.vue
@@ -154,6 +154,8 @@ import Alerts from '../../services/alerts.js'
 import Dialog from '../../services/dialog.js'
 
 import { DeviceStateMutator } from '../../utils/DeviceStateMutator.js'
+import { applyLiveState } from '../../utils/applyLiveState.js'
+import { isTransitionState } from '../../utils/stateTransitions.js'
 import { createPollTimer } from '../../utils/timers.js'
 
 import DeviceAssignApplicationDialog from '../team/Devices/dialogs/DeviceAssignApplicationDialog.vue'
@@ -169,22 +171,13 @@ import DeviceModeBadge from './components/DeviceModeBadge.vue'
 import { useAccountSettingsStore } from '@/stores/account-settings.js'
 import { useAccountStore } from '@/stores/account.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 
 import { useUxStore } from '@/stores/ux.js'
 
 // constants
 const POLL_TIME = 5000
 
-const deviceTransitionStates = [
-    'loading',
-    'installing',
-    'starting',
-    'stopping',
-    'restarting',
-    'suspending',
-    'importing'
-]
-
 export default {
     name: 'DevicePage',
     components: {
@@ -227,6 +220,7 @@ export default {
     computed: {
         ...mapState(useContextStore, ['team']),
         ...mapState(useAccountSettingsStore, ['features']),
+        ...mapState(useLiveStatusStore, { liveDeviceStatuses: 'deviceStatuses', statusChannelLive: 'live' }),
         actionsButtonKind () {
             switch (true) {
             case this.neverConnected:
@@ -363,7 +357,17 @@ export default {
         }
     },
     watch: {
-        device: 'deviceChanged'
+        device: 'deviceChanged',
+        liveDeviceStatuses: { handler: 'applyLiveStatus', deep: true },
+        statusChannelLive (live) {
+            if (live) {
+                this.pollTimer?.stop()
+            } else if (this.pollTimer) {
+                this.pollTimer.start()
+            } else {
+                this.pollTimer = createPollTimer(this.pollTimerElapsed, POLL_TIME)
+            }
+        }
     },
     async mounted () {
         this.mounted = true
@@ -380,6 +384,11 @@ export default {
     methods: {
         ...mapActions(useUxStore, ['validateUserAction']),
         ...mapActions(useContextStore, { setContextualDevice: 'setDevice' }),
+        applyLiveStatus () {
+            const state = this.liveDeviceStatuses[this.device?.id]
+            if (!state || this.device?.status === state) return
+            this.device = applyLiveState(this.device, state, { device: true, clearFlags: true })
+        },
         pollTimerElapsed: async function () {
             // Only refresh device via the timer if we are on the overview page, developer mode page
             // the device status is empty or the device is in a transition state
@@ -391,7 +400,7 @@ export default {
                     await this.loadDevice()
                 } else if (typeof this.device?.status === 'undefined') {
                     await this.loadDevice()
-                } else if (deviceTransitionStates.includes(this.device?.status)) {
+                } else if (isTransitionState(this.device?.status)) {
                     await this.loadDevice()
                 }
             } catch (err) {
@@ -410,7 +419,7 @@ export default {
                     return this.$router.push({ name: 'Home' })
                 }
             }
-            if (!this.pollTimer) {
+            if (!this.pollTimer && !this.statusChannelLive) {
                 this.pollTimer = createPollTimer(this.pollTimerElapsed, POLL_TIME)
             }
 
@@ -422,7 +431,7 @@ export default {
             useAccountStore().setTeam(this.device.team.slug)
         },
         deviceRefresh: async function () {
-            if (this.pollTimer.running) {
+            if (this.pollTimer?.running) {
                 // If the poll timer is running, we don't need to manually refresh the device
                 return
             }
diff --git a/frontend/src/pages/instance/Editor/index.vue b/frontend/src/pages/instance/Editor/index.vue
index 82e9ae15dd..c771fa66e3 100644
--- a/frontend/src/pages/instance/Editor/index.vue
+++ b/frontend/src/pages/instance/Editor/index.vue
@@ -43,6 +43,7 @@
         <ConfirmInstanceDeleteDialog ref="confirmInstanceDeleteDialog" :instance="instance" @confirm="onInstanceDelete" />
 
         <InstanceStatusPolling
+            v-if="!statusChannelLive"
             :instance="instance"
             @instance-updated="instanceUpdated"
         />
diff --git a/frontend/src/pages/instance/index.vue b/frontend/src/pages/instance/index.vue
index 7f4cd6b85d..0920682f50 100644
--- a/frontend/src/pages/instance/index.vue
+++ b/frontend/src/pages/instance/index.vue
@@ -70,7 +70,7 @@
             />
         </div>
 
-        <InstanceStatusPolling :instance="instance" @instance-updated="instanceUpdated" />
+        <InstanceStatusPolling v-if="!statusChannelLive" :instance="instance" @instance-updated="instanceUpdated" />
     </ff-page>
 </template>
 
diff --git a/frontend/src/pages/team/Applications/components/compact/DeviceTile.vue b/frontend/src/pages/team/Applications/components/compact/DeviceTile.vue
index 475708d74e..42ad55fdac 100644
--- a/frontend/src/pages/team/Applications/components/compact/DeviceTile.vue
+++ b/frontend/src/pages/team/Applications/components/compact/DeviceTile.vue
@@ -1,8 +1,8 @@
 <template>
     <div class="device-tile" data-el="device-tile">
         <div class="status">
-            <StatusBadge v-if="!minimalView" :status="device.status" :instanceId="device.id" instanceType="device" />
-            <InstanceMinimalStatusBadge v-else :status="device.status" />
+            <StatusBadge v-if="!minimalView" :status="localDevice.status" :instanceId="device.id" instanceType="device" />
+            <InstanceMinimalStatusBadge v-else :status="localDevice.status" />
         </div>
         <div class="details">
             <div class="detail-wrapper">
@@ -50,15 +50,20 @@
 </template>
 
 <script>
+import { mapState } from 'pinia'
+
 import FinishSetupButton from '../../../../../components/FinishSetup.vue'
 import StatusBadge from '../../../../../components/StatusBadge.vue'
 import usePermissions from '../../../../../composables/Permissions.js'
 import AuditMixin from '../../../../../mixins/Audit.js'
 import deviceActionsMixin from '../../../../../mixins/DeviceActions.js'
 import FfKebabMenu from '../../../../../ui-components/components/kebab-menu/KebabMenu.vue'
+import { applyLiveState } from '../../../../../utils/applyLiveState.js'
 import DaysSince from '../../../../application/Snapshots/components/cells/DaysSince.vue'
 import InstanceMinimalStatusBadge from '../../../../instance/components/InstanceMinimalStatusBadge.vue'
 
+import { useLiveStatusStore } from '@/stores/live-status'
+
 export default {
     name: 'DeviceTile',
     components: {
@@ -89,12 +94,30 @@ export default {
         const { hasPermission } = usePermissions()
         return { hasPermission }
     },
+    data () {
+        return {
+            localDevice: this.device
+        }
+    },
     computed: {
+        ...mapState(useLiveStatusStore, { liveDeviceStatuses: 'deviceStatuses' }),
         neverConnected () {
             return !this.device.lastSeenAt
         }
     },
+    watch: {
+        device (newValue) {
+            this.localDevice = newValue
+            this.applyLiveStatus()
+        },
+        liveDeviceStatuses: { handler: 'applyLiveStatus', deep: true }
+    },
     methods: {
+        applyLiveStatus () {
+            const state = this.liveDeviceStatuses[this.localDevice?.id]
+            if (!state || this.localDevice?.status === state) return
+            this.localDevice = applyLiveState(this.localDevice, state, { device: true })
+        },
         shouldDisplayKebabMenu () {
             return this.hasPermission('device:edit') ||
             this.hasPermission('device:delete')
diff --git a/frontend/src/pages/team/Applications/components/compact/InstanceTile.vue b/frontend/src/pages/team/Applications/components/compact/InstanceTile.vue
index 6c3ecc9e1f..b06b661bf0 100644
--- a/frontend/src/pages/team/Applications/components/compact/InstanceTile.vue
+++ b/frontend/src/pages/team/Applications/components/compact/InstanceTile.vue
@@ -82,7 +82,7 @@
             </ff-kebab-menu>
         </div>
     </div>
-    <InstanceStatusPolling :instance="localInstance" @instance-updated="instanceUpdated" />
+    <InstanceStatusPolling v-if="!statusChannelLive" :instance="localInstance" @instance-updated="instanceUpdated" />
 </template>
 
 <script>
@@ -97,12 +97,14 @@ import instanceActionsMixin from '../../../../../mixins/InstanceActions.js'
 
 import FfKebabMenu from '../../../../../ui-components/components/kebab-menu/KebabMenu.vue'
 import { InstanceStateMutator } from '../../../../../utils/InstanceStateMutator.js'
+import { applyLiveState } from '../../../../../utils/applyLiveState.js'
 import DashboardLink from '../../../../instance/components/DashboardLink.vue'
 import InstanceEditorLink from '../../../../instance/components/EditorLink.vue'
 import InstanceMinimalStatusBadge from '../../../../instance/components/InstanceMinimalStatusBadge.vue'
 import InstanceStatusBadge from '../../../../instance/components/InstanceStatusBadge.vue'
 
 import { useAccountAuthStore } from '@/stores/account-auth.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 
 export default {
     name: 'InstanceTile',
@@ -144,6 +146,7 @@ export default {
     },
     computed: {
         ...mapState(useAccountAuthStore, ['isAdminUser']),
+        ...mapState(useLiveStatusStore, { liveInstanceStatuses: 'instanceStatuses', statusChannelLive: 'live' }),
         isInstanceRunning () {
             return this.localInstance.meta?.state === 'running'
         },
@@ -166,9 +169,15 @@ export default {
     watch: {
         instance (newValue) {
             this.instanceUpdated(newValue)
-        }
+        },
+        liveInstanceStatuses: { handler: 'applyLiveStatus', deep: true }
     },
     methods: {
+        applyLiveStatus () {
+            const state = this.liveInstanceStatuses[this.localInstance?.id]
+            if (!state || this.localInstance?.meta?.state === state) return
+            this.localInstance = applyLiveState(this.localInstance, state, { clearFlags: true })
+        },
         navigateToInstance () {
             this.$router.push({ name: 'Instance', params: { id: this.localInstance.id } })
         },
diff --git a/frontend/src/pages/team/Instances.vue b/frontend/src/pages/team/Instances.vue
index f89915981c..1ebd1755af 100644
--- a/frontend/src/pages/team/Instances.vue
+++ b/frontend/src/pages/team/Instances.vue
@@ -156,7 +156,9 @@
                 </EmptyState>
             </template>
         </div>
-        <InstanceStatusPolling v-for="instance in instances" :key="instance.id" :instance="instance" @instance-updated="instanceUpdated" />
+        <template v-if="!statusChannelLive">
+            <InstanceStatusPolling v-for="instance in instances" :key="instance.id" :instance="instance" @instance-updated="instanceUpdated" />
+        </template>
         <ConfirmInstanceDeleteDialog ref="confirmInstanceDeleteDialog" @confirm="onInstanceDeleted" />
     </ff-page>
 </template>
@@ -176,6 +178,7 @@ import usePermissions from '../../composables/Permissions.js'
 import instanceActionsMixin from '../../mixins/InstanceActions.js'
 import Alerts from '../../services/alerts.js'
 import { InstanceStateMutator } from '../../utils/InstanceStateMutator.js'
+import { applyLiveState } from '../../utils/applyLiveState.js'
 import { debounce } from '../../utils/eventHandling.js'
 import ApplicationLink from '../application/components/cells/ApplicationLink.vue'
 import DeploymentName from '../application/components/cells/DeploymentName.vue'
@@ -187,6 +190,7 @@ import InstanceStatusBadge from '../instance/components/InstanceStatusBadge.vue'
 
 import { useAccountSettingsStore } from '@/stores/account-settings.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 
 export default {
     name: 'TeamInstances',
@@ -273,6 +277,7 @@ export default {
     computed: {
         ...mapState(useContextStore, ['team']),
         ...mapState(useAccountSettingsStore, ['featuresCheck']),
+        ...mapState(useLiveStatusStore, { liveInstanceStatuses: 'instanceStatuses', statusChannelLive: 'live' }),
         instances () {
             return Array.from(this.instancesMap.values())
         },
@@ -289,7 +294,8 @@ export default {
         }
     },
     watch: {
-        team: 'fullReload'
+        team: 'fullReload',
+        liveInstanceStatuses: { handler: 'applyLiveStatus', deep: true }
     },
     mounted () {
         this.fullReload()
@@ -336,12 +342,27 @@ export default {
                     nextMap.set(instance.id, instance)
                 })
                 this.instancesMap = nextMap
+                this.applyLiveStatus()
             } catch (e) {
                 Alerts.emit('Failed to load instances.', 'warning')
             } finally {
                 this.loading = false
             }
         },
+        applyLiveStatus () {
+            const statuses = this.liveInstanceStatuses
+            for (const id of this.instancesMap.keys()) {
+                const state = statuses[id]
+                if (!state) continue
+                const row = this.instancesMap.get(id)
+                if (row.status === state && row.meta?.state === state) continue
+                this.instancesMap.set(id, {
+                    ...applyLiveState(row, state, { clearFlags: true }),
+                    running: this.isRunningState(state),
+                    notSuspended: state !== 'suspended'
+                })
+            }
+        },
         updateSearch: debounce(function (term) {
             this.searchTerm = term
             this.page = 1
diff --git a/frontend/src/stores/live-status.ts b/frontend/src/stores/live-status.ts
new file mode 100644
index 0000000000..a4af110424
--- /dev/null
+++ b/frontend/src/stores/live-status.ts
@@ -0,0 +1,31 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+
+export const useLiveStatusStore = defineStore('live-status', () => {
+    const instanceStatuses = ref<Record<string, string>>({})
+    const deviceStatuses = ref<Record<string, string>>({})
+    const live = ref(false)
+
+    const getInstanceStatus = computed(() => (id: string) => instanceStatuses.value[id])
+    const getDeviceStatus = computed(() => (id: string) => deviceStatuses.value[id])
+
+    function setInstanceStatus (id: string, state: string): void {
+        instanceStatuses.value[id] = state
+    }
+
+    function setDeviceStatus (id: string, state: string): void {
+        deviceStatuses.value[id] = state
+    }
+
+    function setLive (value: boolean): void {
+        live.value = value
+    }
+
+    function clear (): void {
+        instanceStatuses.value = {}
+        deviceStatuses.value = {}
+        live.value = false
+    }
+
+    return { instanceStatuses, deviceStatuses, live, getInstanceStatus, getDeviceStatus, setDeviceStatus, setInstanceStatus, setLive, clear }
+})
diff --git a/frontend/src/subscribers/team-channel.subscriber.ts b/frontend/src/subscribers/team-channel.subscriber.ts
index c4a3bb2e6a..41e3af6bd2 100644
--- a/frontend/src/subscribers/team-channel.subscriber.ts
+++ b/frontend/src/subscribers/team-channel.subscriber.ts
@@ -3,11 +3,14 @@ import { BaseSubscriber } from './subscriber.contract'
 import teamApi from '@/api/team.js'
 import { useAccountAuthStore } from '@/stores/account-auth.js'
 import { useContextStore } from '@/stores/context.js'
+import { useLiveStatusStore } from '@/stores/live-status'
 import { Maybe } from '@/types/common/types'
 import type { CreateSubscriberOptions, TeamChannelSubscriberI, TeamRef } from '@/types/subscribers/subscriber.types'
 
 const MEMBERSHIP_TOPIC_REGEX = /^ff\/v1\/[^/]+\/u\/([^/]+)\/membership$/
 const TEAM_UPDATED_TOPIC_REGEX = /^ff\/v1\/[^/]+\/t\/updated$/
+const DEVICE_STATE_TOPIC_REGEX = /^ff\/v1\/[^/]+\/d\/[^/]+\/state$/
+const INSTANCE_STATE_TOPIC_REGEX = /^ff\/v1\/[^/]+\/p\/[^/]+\/state$/
 
 function connectionKey (teamId: string): string {
     return `team:${teamId}`
@@ -73,6 +76,7 @@ class TeamChannelSubscriber extends BaseSubscriber implements TeamChannelSubscri
         if (!transport) return
         try {
             await transport.disconnect(key)
+            useLiveStatusStore().clear()
         } catch {
             // ignore teardown failures
         }
@@ -88,8 +92,12 @@ class TeamChannelSubscriber extends BaseSubscriber implements TeamChannelSubscri
         try {
             await transport.subscribe(connectionKey(teamId), [
                 `ff/v1/${teamId}/t/updated`,
-                `ff/v1/${teamId}/u/${userId}/membership`
+                `ff/v1/${teamId}/u/${userId}/membership`,
+                `ff/v1/${teamId}/p/+/state`,
+                `ff/v1/${teamId}/d/+/state`
             ], { qos: 1 })
+
+            useLiveStatusStore().setLive(true)
         } catch {
             // non-fatal — the transport replays subscriptions on reconnect
         }
@@ -116,13 +124,29 @@ class TeamChannelSubscriber extends BaseSubscriber implements TeamChannelSubscri
 
     // topic pattern → store action; the store owns interpretation (what a
     // reason means, what to refresh). Add a row per new sync-able entity.
-    protected _topicRoutes (): Array<{ pattern: RegExp, handle: (payload: { reason?: string }) => void }> {
+    protected _topicRoutes (): Array<{ pattern: RegExp, handle: (payload: { reason?: string, id?: string, meta?: { state?: string } }) => void }> {
         return [
             { pattern: MEMBERSHIP_TOPIC_REGEX, handle: (payload) => this._onMembership(payload) },
-            { pattern: TEAM_UPDATED_TOPIC_REGEX, handle: () => this._onTeamUpdated() }
+            { pattern: TEAM_UPDATED_TOPIC_REGEX, handle: () => this._onTeamUpdated() },
+            { pattern: DEVICE_STATE_TOPIC_REGEX, handle: (payload) => this._onDeviceStatus(payload) },
+            { pattern: INSTANCE_STATE_TOPIC_REGEX, handle: (payload) => this._onInstanceStatus(payload) }
         ]
     }
 
+    protected _onInstanceStatus (payload: { id?: string, meta?: { state?: string } }): void {
+        if (!payload?.id || !payload.meta?.state) return
+        try {
+            useLiveStatusStore().setInstanceStatus(payload.id, payload.meta.state)
+        } catch {}
+    }
+
+    protected _onDeviceStatus (payload: { id?: string, meta?: { state?: string } }): void {
+        if (!payload?.id || !payload.meta?.state) return
+        try {
+            useLiveStatusStore().setDeviceStatus(payload.id, payload.meta.state)
+        } catch {}
+    }
+
     protected _onMembership (payload: { reason?: string }): void {
         try {
             useContextStore().onTeamChannelMembership(payload).catch(() => undefined)
diff --git a/frontend/src/utils/DeviceStateMutator.ts b/frontend/src/utils/DeviceStateMutator.ts
index 5e58643808..d33d33307f 100644
--- a/frontend/src/utils/DeviceStateMutator.ts
+++ b/frontend/src/utils/DeviceStateMutator.ts
@@ -1,3 +1,5 @@
+import { isTransitionState } from './stateTransitions.js'
+
 import type { Device } from '@/types'
 import { Maybe } from '@/types/common/types'
 
@@ -27,6 +29,9 @@ export class DeviceStateMutator {
 
     // load latest state from the server
     setStateAsPendingFromServer (newState: Maybe<string> = null) {
+        if (!newState && !isTransitionState(this.device.status)) {
+            return
+        }
         this.device.optimisticStateChange = false
         this.device.pendingStateChange = true
 
diff --git a/frontend/src/utils/InstanceStateMutator.ts b/frontend/src/utils/InstanceStateMutator.ts
index 510fe5bd32..a468c2dc8c 100644
--- a/frontend/src/utils/InstanceStateMutator.ts
+++ b/frontend/src/utils/InstanceStateMutator.ts
@@ -1,3 +1,5 @@
+import { isTransitionState } from './stateTransitions.js'
+
 import type { Instance } from '@/types'
 import { Maybe } from '@/types/common/types'
 
@@ -28,6 +30,9 @@ export class InstanceStateMutator {
 
     // load latest state from the server
     setStateAsPendingFromServer (newState: Maybe<string> = null) {
+        if (!newState && !isTransitionState(this.instance.meta?.state)) {
+            return
+        }
         this.instance.optimisticStateChange = false
         this.instance.pendingStateChange = true
 
diff --git a/frontend/src/utils/applyLiveState.ts b/frontend/src/utils/applyLiveState.ts
new file mode 100644
index 0000000000..1e61f36812
--- /dev/null
+++ b/frontend/src/utils/applyLiveState.ts
@@ -0,0 +1,22 @@
+type LiveStateTarget = {
+    status?: string
+    meta?: { state?: string } & Record<string, unknown>
+    optimisticStateChange?: boolean
+    pendingStateChange?: boolean
+}
+
+type ApplyLiveStateOptions = {
+    device?: boolean
+    clearFlags?: boolean
+}
+
+export function applyLiveState<T extends LiveStateTarget> (obj: T, state: string, { device = false, clearFlags = false }: ApplyLiveStateOptions = {}): T {
+    const next = device
+        ? { ...obj, status: state }
+        : { ...obj, status: state, meta: { ...(obj.meta || {}), state } }
+    if (clearFlags) {
+        next.optimisticStateChange = false
+        next.pendingStateChange = false
+    }
+    return next
+}
diff --git a/frontend/src/utils/stateTransitions.ts b/frontend/src/utils/stateTransitions.ts
new file mode 100644
index 0000000000..c0b564ebb2
--- /dev/null
+++ b/frontend/src/utils/stateTransitions.ts
@@ -0,0 +1,7 @@
+export const TRANSITION_STATES = ['loading', 'installing', 'starting', 'stopping', 'restarting', 'suspending', 'importing', 'rollback'] as const
+
+export type TransitionState = typeof TRANSITION_STATES[number]
+
+export function isTransitionState (state?: string | null): boolean {
+    return (TRANSITION_STATES as readonly string[]).includes(state ?? '')
+}
diff --git a/test/unit/forge/comms/authRoutesV2_spec.js b/test/unit/forge/comms/authRoutesV2_spec.js
index 2175f48742..894bac5cd1 100644
--- a/test/unit/forge/comms/authRoutesV2_spec.js
+++ b/test/unit/forge/comms/authRoutesV2_spec.js
@@ -1376,6 +1376,42 @@ describe('Broker Auth v2 API', async function () {
                     topic: teamUpdatedTopic
                 })
             })
+            it('allows a team member to subscribe to the team instance-state wildcard', async function () {
+                await allowRead({
+                    username: teamFrontendUsername,
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/p/+/state`
+                })
+            })
+            it('allows a team member to subscribe to the team device-state wildcard', async function () {
+                await allowRead({
+                    username: teamFrontendUsername,
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/d/+/state`
+                })
+            })
+            it('denies subscribe to another team\'s state wildcard', async function () {
+                await denyRead({
+                    username: teamFrontendUsername,
+                    topic: `ff/v1/${otherTeam.hashid}/p/+/state`
+                })
+                await denyRead({
+                    username: teamFrontendUsername,
+                    topic: `ff/v1/${otherTeam.hashid}/d/+/state`
+                })
+            })
+            it('denies state subscribe for a user who is not a member of the team', async function () {
+                const dave = await factory.createUser({ username: 'dave', name: 'Dave', email: 'dave@example.com', password: 'ddPassword1!' })
+                const daveUsername = `fe-team:${dave.hashid}:${TestObjects.ATeam.hashid}:session-1234567890`
+                await denyRead({
+                    username: daveUsername,
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/p/+/state`
+                })
+            })
+            it('denies fe-team from publishing to state (read-only client)', async function () {
+                await denyWrite({
+                    username: teamFrontendUsername,
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/p/+/state`
+                })
+            })
             it('denies fe-team from publishing (read-only client)', async function () {
                 await denyWrite({
                     username: teamFrontendUsername,
@@ -1392,6 +1428,16 @@ describe('Broker Auth v2 API', async function () {
                     topic: membershipTopic
                 })
             })
+            it('allows forge_platform to publish the reshaped instance/device state topics', async function () {
+                await allowWrite({
+                    username: 'forge_platform',
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/p/an-instance/state`
+                })
+                await allowWrite({
+                    username: 'forge_platform',
+                    topic: `ff/v1/${TestObjects.ATeam.hashid}/d/a-device/state`
+                })
+            })
             it('denies subscribe when the credential\'s team hash does not resolve to a team', async function () {
                 const teamLookupStub = sinon.stub(app.db.models.Team, 'byId').resolves(null)
                 try {
diff --git a/test/unit/forge/comms/devices_spec.js b/test/unit/forge/comms/devices_spec.js
index df915412d7..fb53a6f2d0 100644
--- a/test/unit/forge/comms/devices_spec.js
+++ b/test/unit/forge/comms/devices_spec.js
@@ -1,6 +1,8 @@
 const sleep = require('util').promisify(setTimeout)
 
 const should = require('should') // eslint-disable-line
+const sinon = require('sinon')
+
 const setup = require('../routes/setup')
 
 const FF_UTIL = require('flowforge-test-utils')
@@ -216,6 +218,77 @@ describe('DeviceCommsHandler', function () {
             payload.should.have.property('project', null)
             payload.should.have.property('snapshot', null)
         })
+
+        it('forwards a team status notification only when the device state changes', async function () {
+            const device = await app.factory.createDevice({ name: 'status-forward-device' }, TestObjects.ATeam)
+            const notifySpy = sinon.spy(app.comms.team, 'notifyDeviceState')
+            try {
+                // establish a known baseline regardless of the factory default state
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'stopped' }) })
+                await sleep(100)
+                notifySpy.resetHistory()
+
+                // state changes -> notifies with { teamHash, deviceHashid, state }
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'running' }) })
+                await sleep(100)
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([TestObjects.ATeam.hashid, device.hashid, 'running'])
+
+                // same state again -> no further notification
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'running' }) })
+                await sleep(100)
+                notifySpy.calledOnce.should.be.true()
+
+                // state changes again -> notifies again
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'stopped' }) })
+                await sleep(100)
+                notifySpy.calledTwice.should.be.true()
+                notifySpy.secondCall.args.should.eql([TestObjects.ATeam.hashid, device.hashid, 'stopped'])
+            } finally {
+                notifySpy.restore()
+            }
+        })
+
+        it('masks a transient stopped while restarting but surfaces settled states', async function () {
+            const device = await app.factory.createDevice({ name: 'restart-mask-device' }, TestObjects.ATeam)
+            const notifySpy = sinon.spy(app.comms.team, 'notifyDeviceState')
+            const setRestarting = async () => { device.state = 'restarting'; await device.save() }
+            try {
+                await setRestarting()
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'stopped' }) })
+                await sleep(100)
+                notifySpy.called.should.be.false()
+                await device.reload()
+                device.state.should.equal('restarting')
+
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'running' }) })
+                await sleep(100)
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([TestObjects.ATeam.hashid, device.hashid, 'running'])
+                await device.reload()
+                device.state.should.equal('running')
+
+                await setRestarting()
+                notifySpy.resetHistory()
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'crashed' }) })
+                await sleep(100)
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([TestObjects.ATeam.hashid, device.hashid, 'crashed'])
+                await device.reload()
+                device.state.should.equal('crashed')
+
+                await setRestarting()
+                notifySpy.resetHistory()
+                client.emit('status/device', { id: device.hashid, status: JSON.stringify({ state: 'warning' }) })
+                await sleep(100)
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([TestObjects.ATeam.hashid, device.hashid, 'warning'])
+                await device.reload()
+                device.state.should.equal('warning')
+            } finally {
+                notifySpy.restore()
+            }
+        })
     })
 
     describe('sendCommandAwaitReply', async function () {
diff --git a/test/unit/forge/db/controllers/Project_spec.js b/test/unit/forge/db/controllers/Project_spec.js
index f9d77922dd..f782513e68 100644
--- a/test/unit/forge/db/controllers/Project_spec.js
+++ b/test/unit/forge/db/controllers/Project_spec.js
@@ -1,6 +1,8 @@
 const crypto = require('crypto')
 
 const should = require('should') // eslint-disable-line
+const sinon = require('sinon')
+
 const { encryptCreds, decryptCreds } = require('../../../../lib/credentials')
 const setup = require('../setup')
 // const FF_UTIL = require('flowforge-test-utils')
@@ -12,7 +14,8 @@ describe('Project controller', function () {
     before(async function () {
         app = await setup({
             limits: {
-                instances: 50
+                instances: 50,
+                teams: 50
             }
         })
     })
@@ -508,22 +511,119 @@ describe('Project controller', function () {
         })
 
         it('should update non-definitive project states while removing definitive ones', async () => {
-            app.db.controllers.Project.setLatestProjectState('project-id', 'status')
+            // updateLatestProjectState loads the project (to broadcast), so use a real id like the launcher does
+            const team = await app.db.models.Team.create({ name: 'Latest State Team', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'latest-state-p1', type: '', url: '', state: 'running', TeamId: team.id })
+            const id = instance.id
+
+            app.db.controllers.Project.setLatestProjectState(id, 'status')
 
-            let tempResult = await app.db.controllers.Project.getLatestProjectState('project-id')
+            let tempResult = await app.db.controllers.Project.getLatestProjectState(id)
             should(tempResult).equal('status')
 
-            await app.db.controllers.Project.updateLatestProjectState('project-id', 'running')
-            tempResult = await app.db.controllers.Project.getLatestProjectState('project-id')
+            await app.db.controllers.Project.updateLatestProjectState(id, 'running')
+            tempResult = await app.db.controllers.Project.getLatestProjectState(id)
             should(tempResult).be.undefined()
 
-            await app.db.controllers.Project.updateLatestProjectState('project-id', 'status')
-            tempResult = await app.db.controllers.Project.getLatestProjectState('project-id')
+            await app.db.controllers.Project.updateLatestProjectState(id, 'status')
+            tempResult = await app.db.controllers.Project.getLatestProjectState(id)
             should(tempResult).equal('status')
 
-            await app.db.controllers.Project.updateLatestProjectState('project-id', 'stopped')
-            tempResult = await app.db.controllers.Project.getLatestProjectState('project-id')
+            await app.db.controllers.Project.updateLatestProjectState(id, 'stopped')
+            tempResult = await app.db.controllers.Project.getLatestProjectState(id)
             should(tempResult).equal('stopped')
         })
+
+        it('broadcasts a launcher-reported state change to the team channel, only on change', async function () {
+            const notifySpy = sinon.spy(app.comms.team, 'notifyInstanceState')
+            const team = await app.db.models.Team.create({ name: 'Cache Status Team', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'cache-status-p1', type: '', url: '', state: 'running', TeamId: team.id })
+            notifySpy.resetHistory() // ignore the create-time save
+            try {
+                // running -> stopped is a change
+                await app.db.controllers.Project.updateLatestProjectState(instance.id, 'stopped')
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([app.db.models.Team.encodeHashid(team.id), instance.id, 'stopped'])
+
+                // same state again -> no further notification
+                await app.db.controllers.Project.updateLatestProjectState(instance.id, 'stopped')
+                notifySpy.calledOnce.should.be.true()
+            } finally {
+                notifySpy.restore()
+            }
+        })
+
+        it('broadcasts inflight transition states, then reverts when cleared', async function () {
+            const notifySpy = sinon.spy(app.comms.team, 'notifyInstanceState')
+            const team = await app.db.models.Team.create({ name: 'Inflight Status Team', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'inflight-status-p1', type: '', url: '', state: 'running', TeamId: team.id })
+            const teamHash = app.db.models.Team.encodeHashid(team.id)
+            notifySpy.resetHistory() // ignore the create-time save
+            try {
+                // inflight wins over the db/latest state
+                await app.db.controllers.Project.setInflightState(instance, 'starting')
+                notifySpy.calledWith(teamHash, instance.id, 'starting').should.be.true()
+
+                // clearing reverts to the effective db state (running)
+                notifySpy.resetHistory()
+                await app.db.controllers.Project.clearInflightState(instance)
+                notifySpy.calledWith(teamHash, instance.id, 'running').should.be.true()
+            } finally {
+                notifySpy.restore()
+            }
+        })
+
+        it('serializes concurrent publishLiveState so a state is broadcast once', async function () {
+            const notifySpy = sinon.spy(app.comms.team, 'notifyInstanceState')
+            const team = await app.db.models.Team.create({ name: 'Serialize Status Team', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'serialize-status-p1', type: '', url: '', state: 'running', TeamId: team.id })
+            notifySpy.resetHistory() // ignore the create-time save (cached 'running')
+            try {
+                // make the effective state 'stopped' without publishing it
+                await app.db.controllers.Project.setLatestProjectState(instance.id, 'stopped')
+                // two concurrent publishes: without serialization both read the stale
+                // 'running' cache and broadcast 'stopped' twice; serialized, the second
+                // sees the first's write and skips
+                await Promise.all([
+                    app.db.controllers.Project.publishLiveState(instance),
+                    app.db.controllers.Project.publishLiveState(instance)
+                ])
+                notifySpy.calledOnce.should.be.true()
+                notifySpy.firstCall.args.should.eql([app.db.models.Team.encodeHashid(team.id), instance.id, 'stopped'])
+            } finally {
+                notifySpy.restore()
+            }
+        })
+
+        // start/restart hold a transition mask; the launcher reports definitive states only
+        async function makeInstance (name) {
+            const team = await app.db.models.Team.create({ name, TeamTypeId: 1 })
+            return app.db.models.Project.create({ name: `${name}-p`, type: '', url: '', state: 'running', TeamId: team.id })
+        }
+
+        for (const inflight of ['starting', 'restarting']) {
+            for (const outcome of ['running', 'safe', 'crashed']) {
+                it(`clears a ${inflight} mask when the launcher reports ${outcome}`, async function () {
+                    const instance = await makeInstance(`${inflight}-${outcome}`)
+                    await app.db.controllers.Project.setInflightState(instance, inflight)
+                    await app.db.controllers.Project.updateLatestProjectState(instance.id, outcome)
+                    should(await app.db.controllers.Project.getInflightState(instance)).be.undefined()
+                })
+            }
+
+            it(`keeps the ${inflight} mask on a transient stopped`, async function () {
+                const instance = await makeInstance(`${inflight}-stopped`)
+                await app.db.controllers.Project.setInflightState(instance, inflight)
+                await app.db.controllers.Project.updateLatestProjectState(instance.id, 'stopped')
+                should(await app.db.controllers.Project.getInflightState(instance)).equal(inflight)
+            })
+        }
+
+        it('does not clear a non-transition inflight (e.g. suspending) on a running report', async function () {
+            const instance = await makeInstance('suspending-running')
+            await app.db.controllers.Project.setInflightState(instance, 'suspending')
+            await app.db.controllers.Project.updateLatestProjectState(instance.id, 'running')
+            should(await app.db.controllers.Project.getInflightState(instance)).equal('suspending')
+        })
     })
 })
diff --git a/test/unit/forge/db/models/Project_spec.js b/test/unit/forge/db/models/Project_spec.js
index 06de3b979d..4b5161a25c 100644
--- a/test/unit/forge/db/models/Project_spec.js
+++ b/test/unit/forge/db/models/Project_spec.js
@@ -666,4 +666,41 @@ describe('Project model', function () {
             await team.destroy()
         })
     })
+
+    describe('Status change broadcast (afterSave hook)', function () {
+        let notifySpy
+        before(async function () {
+            await app.close()
+            app = await setup({ limits: { instances: 20 } })
+        })
+        after(async function () {
+            await app.close()
+            app = await setup()
+        })
+        beforeEach(function () {
+            notifySpy = sinon.spy(app.comms.team, 'notifyInstanceState')
+        })
+        afterEach(function () {
+            notifySpy.restore()
+        })
+
+        it('notifies the team channel when an instance state changes on save', async function () {
+            const team = await app.db.models.Team.create({ name: 'Broadcast Team', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'broadcast-p1', type: '', url: '', state: 'running', TeamId: team.id })
+            notifySpy.resetHistory() // ignore the create-time save
+            instance.state = 'suspended'
+            await instance.save()
+            notifySpy.calledOnce.should.be.true()
+            notifySpy.firstCall.args.should.eql([app.db.models.Team.encodeHashid(team.id), instance.id, 'suspended'])
+        })
+
+        it('does not notify when a save leaves state unchanged', async function () {
+            const team = await app.db.models.Team.create({ name: 'Broadcast Team 2', TeamTypeId: 1 })
+            const instance = await app.db.models.Project.create({ name: 'broadcast-p2', type: '', url: '', state: 'suspended', TeamId: team.id })
+            notifySpy.resetHistory()
+            instance.name = 'broadcast-p2-renamed' // name change is allowed while suspended
+            await instance.save()
+            notifySpy.called.should.be.false()
+        })
+    })
 })
diff --git a/test/unit/forge/routes/api/projectSnapshots_spec.js b/test/unit/forge/routes/api/projectSnapshots_spec.js
index c805f32df2..2023f6da1d 100644
--- a/test/unit/forge/routes/api/projectSnapshots_spec.js
+++ b/test/unit/forge/routes/api/projectSnapshots_spec.js
@@ -936,6 +936,49 @@ describe('Project Snapshots API', function () {
             rolledBackSettings.env.should.have.property('one', 'a')
             rolledBackSettings.env.should.have.property('two', 'b')
         })
+
+        it('holds a restarting mask through the bounce when rolling back a running instance', async function () {
+            const snapResponse = await createSnapshot(app.project.id, 'rollback-mask-snapshot', TestObjects.tokens.alice)
+            snapResponse.statusCode.should.equal(200)
+            const snapshot = snapResponse.json()
+
+            app.project.state = 'running'
+            await app.project.save()
+
+            const rollbackResponse = await app.inject({
+                method: 'POST',
+                url: `/api/v1/projects/${app.project.id}/actions/rollback`,
+                payload: { snapshot: snapshot.id },
+                cookies: { sid: TestObjects.tokens.alice }
+            })
+            rollbackResponse.statusCode.should.equal(200)
+
+            // the post-import bounce is masked as 'restarting' (cleared later by the launcher's running
+            // confirm), so live status reads running -> rollback -> restarting -> running with no stopped flash
+            ;(await app.db.controllers.Project.getInflightState(app.project)).should.equal('restarting')
+
+            await app.db.controllers.Project.clearInflightState(app.project)
+        })
+
+        it('does not bounce (no restarting mask) when rolling back a non-running instance', async function () {
+            const snapResponse = await createSnapshot(app.project.id, 'rollback-no-bounce-snapshot', TestObjects.tokens.alice)
+            snapResponse.statusCode.should.equal(200)
+            const snapshot = snapResponse.json()
+
+            app.project.state = 'suspended'
+            await app.project.save()
+
+            const rollbackResponse = await app.inject({
+                method: 'POST',
+                url: `/api/v1/projects/${app.project.id}/actions/rollback`,
+                payload: { snapshot: snapshot.id },
+                cookies: { sid: TestObjects.tokens.alice }
+            })
+            rollbackResponse.statusCode.should.equal(200)
+
+            // not running -> no restart bounce -> the inflight mask is cleared after import
+            should(await app.db.controllers.Project.getInflightState(app.project)).be.undefined()
+        })
     })
 
     describe('Get snapshot information', function () {
diff --git a/test/unit/forge/routes/api/project_spec.js b/test/unit/forge/routes/api/project_spec.js
index 149fd43a56..cfe6871021 100644
--- a/test/unit/forge/routes/api/project_spec.js
+++ b/test/unit/forge/routes/api/project_spec.js
@@ -3088,6 +3088,60 @@ describe('Project API', function () {
         })
     })
 
+    describe('Start action — mask clears on failure and crash recovery', async function () {
+        it('recovers a crashed instance on start (mask clears to running)', async function () {
+            const instance = await app.factory.createInstance(
+                { name: generateProjectName() },
+                app.application,
+                app.stack,
+                app.template,
+                app.projectType,
+                { start: false }
+            )
+            instance.state = 'crashed'
+            await instance.save()
+
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/v1/projects/${instance.id}/actions/start`,
+                cookies: { sid: TestObjects.tokens.alice }
+            })
+            response.statusCode.should.equal(200)
+            await instance.reload()
+            instance.state.should.equal('running')
+            should(await app.db.controllers.Project.getInflightState(instance)).be.undefined()
+        })
+
+        it('clears the starting mask when the driver fails to start', async function () {
+            const instance = await app.factory.createInstance(
+                { name: 'stub-fail-start' },
+                app.application,
+                app.stack,
+                app.template,
+                app.projectType,
+                { start: false }
+            )
+            instance.state = 'suspended'
+            await instance.save()
+
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/v1/projects/${instance.id}/actions/start`,
+                cookies: { sid: TestObjects.tokens.alice }
+            })
+            response.statusCode.should.equal(200)
+            // mask is held while starting
+            should(await app.db.controllers.Project.getInflightState(instance)).equal('starting')
+
+            // stub-fail-start rejects ~500ms in; the driver reverts to suspended and the mask must clear
+            // so the instance surfaces its real state rather than hanging on 'starting'
+            await sleep(800)
+            await instance.reload()
+            instance.state.should.equal('suspended')
+            should(await app.db.controllers.Project.getInflightState(instance)).be.undefined()
+        })
+    })
+
     describe('Set a project\'s state', async function () {
         let testProject
         before(async function () {
diff --git a/test/unit/frontend/stores/live-status.spec.js b/test/unit/frontend/stores/live-status.spec.js
new file mode 100644
index 0000000000..3fbcfd0fab
--- /dev/null
+++ b/test/unit/frontend/stores/live-status.spec.js
@@ -0,0 +1,76 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { useLiveStatusStore } from '@/stores/live-status'
+
+describe('live-status store', () => {
+    beforeEach(() => {
+        setActivePinia(createPinia())
+    })
+
+    it('starts empty and not live', () => {
+        const store = useLiveStatusStore()
+        expect(store.instanceStatuses).toEqual({})
+        expect(store.deviceStatuses).toEqual({})
+        expect(store.live).toBe(false)
+    })
+
+    describe('setInstanceStatus / setDeviceStatus', () => {
+        it('records instance status and exposes it via map and getter', () => {
+            const store = useLiveStatusStore()
+            store.setInstanceStatus('inst-1', 'running')
+            expect(store.instanceStatuses['inst-1']).toBe('running')
+            expect(store.getInstanceStatus('inst-1')).toBe('running')
+        })
+
+        it('records device status independently of instance status', () => {
+            const store = useLiveStatusStore()
+            store.setInstanceStatus('inst-1', 'running')
+            store.setDeviceStatus('dev-1', 'stopped')
+            expect(store.deviceStatuses['dev-1']).toBe('stopped')
+            expect(store.getDeviceStatus('dev-1')).toBe('stopped')
+            // the two maps don't bleed into each other
+            expect(store.instanceStatuses['dev-1']).toBeUndefined()
+            expect(store.deviceStatuses['inst-1']).toBeUndefined()
+        })
+
+        it('overwrites an existing id with the latest state', () => {
+            const store = useLiveStatusStore()
+            store.setInstanceStatus('inst-1', 'running')
+            store.setInstanceStatus('inst-1', 'suspended')
+            expect(store.instanceStatuses['inst-1']).toBe('suspended')
+        })
+
+        it('returns undefined for an unknown id', () => {
+            const store = useLiveStatusStore()
+            expect(store.getInstanceStatus('nope')).toBeUndefined()
+            expect(store.getDeviceStatus('nope')).toBeUndefined()
+        })
+    })
+
+    describe('setLive', () => {
+        it('toggles the live flag', () => {
+            const store = useLiveStatusStore()
+            store.setLive(true)
+            expect(store.live).toBe(true)
+            store.setLive(false)
+            expect(store.live).toBe(false)
+        })
+    })
+
+    describe('clear', () => {
+        it('resets both maps and the live flag (team-switch teardown)', () => {
+            const store = useLiveStatusStore()
+            store.setInstanceStatus('inst-1', 'running')
+            store.setDeviceStatus('dev-1', 'stopped')
+            store.setLive(true)
+
+            store.clear()
+
+            expect(store.instanceStatuses).toEqual({})
+            expect(store.deviceStatuses).toEqual({})
+            expect(store.live).toBe(false)
+            expect(store.getInstanceStatus('inst-1')).toBeUndefined()
+        })
+    })
+})
diff --git a/test/unit/frontend/subscribers/team-channel.subscriber.spec.js b/test/unit/frontend/subscribers/team-channel.subscriber.spec.js
index 8a7596461b..7dae63f4d1 100644
--- a/test/unit/frontend/subscribers/team-channel.subscriber.spec.js
+++ b/test/unit/frontend/subscribers/team-channel.subscriber.spec.js
@@ -6,12 +6,18 @@ const refreshTeam = vi.fn().mockResolvedValue(undefined)
 const onTeamChannelMembership = vi.fn().mockResolvedValue(undefined)
 const useContextStore = vi.fn(() => ({ refreshTeam, onTeamChannelMembership }))
 const useAccountAuthStore = vi.fn(() => ({ user: { id: 'user-hashid-1' }, getSessionId: () => 'session-test-id' }))
+const setInstanceStatus = vi.fn()
+const setDeviceStatus = vi.fn()
+const setLive = vi.fn()
+const clear = vi.fn()
+const useLiveStatusStore = vi.fn(() => ({ setInstanceStatus, setDeviceStatus, setLive, clear }))
 
 vi.mock('@/api/team.js', () => ({
     default: { getTeamCommsCreds: (...args) => getTeamCommsCreds(...args) }
 }))
 vi.mock('@/stores/context.js', () => ({ useContextStore }))
 vi.mock('@/stores/account-auth.js', () => ({ useAccountAuthStore }))
+vi.mock('@/stores/live-status', () => ({ useLiveStatusStore }))
 
 function makeTransport () {
     return {
@@ -45,6 +51,10 @@ describe('TeamChannelSubscriber', async () => {
         onTeamChannelMembership.mockClear()
         useContextStore.mockClear()
         useAccountAuthStore.mockClear().mockReturnValue({ user: { id: 'user-hashid-1' }, getSessionId: () => 'session-test-id' })
+        setInstanceStatus.mockClear()
+        setDeviceStatus.mockClear()
+        setLive.mockClear()
+        clear.mockClear()
         await destroyTeamChannelSubscriber()
     })
 
@@ -145,7 +155,7 @@ describe('TeamChannelSubscriber', async () => {
     })
 
     describe('subscribe on connect', () => {
-        test('subscribes to t/updated and membership topics with qos 1', async () => {
+        test('subscribes to t/updated, membership and the state wildcards with qos 1', async () => {
             const { subscriber, transport } = createSubscriber()
             let onConnect
             transport.connect.mockImplementation(async (_key, opts) => {
@@ -155,11 +165,39 @@ describe('TeamChannelSubscriber', async () => {
             await onConnect()
             expect(transport.subscribe).toHaveBeenCalledWith(
                 'team:team-1',
-                ['ff/v1/team-1/t/updated', 'ff/v1/team-1/u/user-hashid-1/membership'],
+                [
+                    'ff/v1/team-1/t/updated',
+                    'ff/v1/team-1/u/user-hashid-1/membership',
+                    'ff/v1/team-1/p/+/state',
+                    'ff/v1/team-1/d/+/state'
+                ],
                 { qos: 1 }
             )
         })
 
+        test('marks the status channel live once subscribed', async () => {
+            const { subscriber, transport } = createSubscriber()
+            let onConnect
+            transport.connect.mockImplementation(async (_key, opts) => {
+                onConnect = opts.onConnect
+            })
+            await subscriber.connect({ id: 'team-1' })
+            await onConnect()
+            expect(setLive).toHaveBeenCalledWith(true)
+        })
+
+        test('does not mark live when the subscribe fails', async () => {
+            const { subscriber, transport } = createSubscriber()
+            transport.subscribe.mockRejectedValue(new Error('subscribe failed'))
+            let onConnect
+            transport.connect.mockImplementation(async (_key, opts) => {
+                onConnect = opts.onConnect
+            })
+            await subscriber.connect({ id: 'team-1' })
+            await onConnect()
+            expect(setLive).not.toHaveBeenCalled()
+        })
+
         test('swallows subscribe errors (transport reconnect will retry)', async () => {
             const { subscriber, transport } = createSubscriber()
             transport.subscribe.mockRejectedValue(new Error('subscribe failed'))
@@ -215,6 +253,28 @@ describe('TeamChannelSubscriber', async () => {
             expect(refreshTeam).not.toHaveBeenCalled()
             expect(onTeamChannelMembership).not.toHaveBeenCalled()
         })
+
+        test('instance state routes id + state into setInstanceStatus', async () => {
+            const { onMessage } = await connectAndCaptureOnMessage()
+            onMessage('ff/v1/team-1/p/inst-1/state', Buffer.from(JSON.stringify({ id: 'inst-1', meta: { state: 'running' } })))
+            expect(setInstanceStatus).toHaveBeenCalledWith('inst-1', 'running')
+            expect(setDeviceStatus).not.toHaveBeenCalled()
+        })
+
+        test('device state routes id + state into setDeviceStatus', async () => {
+            const { onMessage } = await connectAndCaptureOnMessage()
+            onMessage('ff/v1/team-1/d/dev-1/state', Buffer.from(JSON.stringify({ id: 'dev-1', meta: { state: 'stopped' } })))
+            expect(setDeviceStatus).toHaveBeenCalledWith('dev-1', 'stopped')
+            expect(setInstanceStatus).not.toHaveBeenCalled()
+        })
+
+        test('ignores a state message missing id or state', async () => {
+            const { onMessage } = await connectAndCaptureOnMessage()
+            onMessage('ff/v1/team-1/p/inst-1/state', Buffer.from(JSON.stringify({ id: 'inst-1' })))
+            onMessage('ff/v1/team-1/d/dev-1/state', Buffer.from(JSON.stringify({ meta: { state: 'running' } })))
+            expect(setInstanceStatus).not.toHaveBeenCalled()
+            expect(setDeviceStatus).not.toHaveBeenCalled()
+        })
     })
 
     describe('disconnect / destroy', () => {
@@ -227,10 +287,19 @@ describe('TeamChannelSubscriber', async () => {
             expect(subscriber.isConnected()).toBe(false)
         })
 
+        test('disconnect clears the live-status store (no prior-team leak)', async () => {
+            const { subscriber, transport } = createSubscriber()
+            transport.connect.mockResolvedValue(undefined)
+            await subscriber.connect({ id: 'team-1' })
+            await subscriber.disconnect()
+            expect(clear).toHaveBeenCalledTimes(1)
+        })
+
         test('disconnect is a no-op when not connected', async () => {
             const { subscriber, transport } = createSubscriber()
             await subscriber.disconnect()
             expect(transport.disconnect).not.toHaveBeenCalled()
+            expect(clear).not.toHaveBeenCalled()
         })
 
         test('destroy disconnects the active client', async () => {
diff --git a/test/unit/frontend/utils/DeviceStateMutator.spec.js b/test/unit/frontend/utils/DeviceStateMutator.spec.js
new file mode 100644
index 0000000000..0ffc37106c
--- /dev/null
+++ b/test/unit/frontend/utils/DeviceStateMutator.spec.js
@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest'
+
+import { DeviceStateMutator } from '../../../../frontend/src/utils/DeviceStateMutator.ts'
+
+describe('DeviceStateMutator.setStateAsPendingFromServer', () => {
+    test('sets pending while the device is still transitioning', () => {
+        const device = { status: 'restarting', optimisticStateChange: true, pendingStateChange: false }
+        new DeviceStateMutator(device).setStateAsPendingFromServer()
+        expect(device.pendingStateChange).toBe(true)
+        expect(device.optimisticStateChange).toBe(false)
+    })
+
+    // the race the fix guards against: a live update settles + clears the flags before the action's HTTP .then() runs
+    test('no-ops once the device has already settled', () => {
+        const device = { status: 'running', optimisticStateChange: false, pendingStateChange: false }
+        new DeviceStateMutator(device).setStateAsPendingFromServer()
+        expect(device.pendingStateChange).toBe(false)
+    })
+})
diff --git a/test/unit/frontend/utils/InstanceStateMutator.spec.js b/test/unit/frontend/utils/InstanceStateMutator.spec.js
new file mode 100644
index 0000000000..b7ff305c71
--- /dev/null
+++ b/test/unit/frontend/utils/InstanceStateMutator.spec.js
@@ -0,0 +1,27 @@
+import { describe, expect, test } from 'vitest'
+
+import { InstanceStateMutator } from '../../../../frontend/src/utils/InstanceStateMutator.ts'
+
+describe('InstanceStateMutator.setStateAsPendingFromServer', () => {
+    test('sets pending while the instance is still transitioning', () => {
+        const instance = { meta: { state: 'starting' }, optimisticStateChange: true, pendingStateChange: false }
+        new InstanceStateMutator(instance).setStateAsPendingFromServer()
+        expect(instance.pendingStateChange).toBe(true)
+        expect(instance.optimisticStateChange).toBe(false)
+    })
+
+    // the race the fix guards against: a live update settles + clears the flags before the action's HTTP .then() runs
+    test('no-ops once a live update has already settled the state', () => {
+        const instance = { meta: { state: 'suspended' }, optimisticStateChange: false, pendingStateChange: false }
+        new InstanceStateMutator(instance).setStateAsPendingFromServer()
+        expect(instance.pendingStateChange).toBe(false)
+        expect(instance.optimisticStateChange).toBe(false)
+    })
+
+    test('still applies an explicit newState even when settled', () => {
+        const instance = { meta: { state: 'running' }, optimisticStateChange: false, pendingStateChange: false }
+        new InstanceStateMutator(instance).setStateAsPendingFromServer('stopping')
+        expect(instance.pendingStateChange).toBe(true)
+        expect(instance.meta.state).toBe('stopping')
+    })
+})
diff --git a/test/unit/frontend/utils/applyLiveState.spec.js b/test/unit/frontend/utils/applyLiveState.spec.js
new file mode 100644
index 0000000000..f94eb8a055
--- /dev/null
+++ b/test/unit/frontend/utils/applyLiveState.spec.js
@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vitest'
+
+import { applyLiveState } from '../../../../frontend/src/utils/applyLiveState.ts'
+
+describe('applyLiveState', () => {
+    test('instance: writes meta.state and a mirrored status', () => {
+        const out = applyLiveState({ id: 1, meta: { state: 'stopped', foo: 'bar' } }, 'running')
+        expect(out.meta.state).toBe('running')
+        expect(out.status).toBe('running')
+        expect(out.meta.foo).toBe('bar') // preserves other meta fields
+    })
+
+    test('device: writes status only, no meta', () => {
+        const out = applyLiveState({ id: 1, status: 'stopped' }, 'running', { device: true })
+        expect(out.status).toBe('running')
+        expect(out.meta).toBeUndefined()
+    })
+
+    test('clearFlags clears optimistic/pending', () => {
+        const out = applyLiveState({ meta: {}, optimisticStateChange: true, pendingStateChange: true }, 'running', { clearFlags: true })
+        expect(out.optimisticStateChange).toBe(false)
+        expect(out.pendingStateChange).toBe(false)
+    })
+
+    test('without clearFlags the flags are left untouched', () => {
+        const out = applyLiveState({ status: 'x', optimisticStateChange: true }, 'running', { device: true })
+        expect(out.optimisticStateChange).toBe(true)
+    })
+
+    test('returns a new object and preserves unrelated fields', () => {
+        const input = { id: 7, name: 'keep', meta: { state: 'stopped' } }
+        const out = applyLiveState(input, 'running')
+        expect(out).not.toBe(input)
+        expect(out.name).toBe('keep')
+    })
+})
diff --git a/test/unit/frontend/utils/stateTransitions.spec.js b/test/unit/frontend/utils/stateTransitions.spec.js
new file mode 100644
index 0000000000..4e2f1e6945
--- /dev/null
+++ b/test/unit/frontend/utils/stateTransitions.spec.js
@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'vitest'
+
+import { TRANSITION_STATES, isTransitionState } from '../../../../frontend/src/utils/stateTransitions.ts'
+
+describe('isTransitionState', () => {
+    test('true for every transition state', () => {
+        for (const state of TRANSITION_STATES) {
+            expect(isTransitionState(state)).toBe(true)
+        }
+    })
+
+    test('false for settled / terminal states', () => {
+        for (const state of ['running', 'stopped', 'suspended', 'safe', 'crashed', 'error', 'protected', 'warning', 'offline', 'unknown']) {
+            expect(isTransitionState(state)).toBe(false)
+        }
+    })
+
+    test('false for null / undefined / empty', () => {
+        expect(isTransitionState(null)).toBe(false)
+        expect(isTransitionState(undefined)).toBe(false)
+        expect(isTransitionState('')).toBe(false)
+    })
+})