fix(featureFlags): resolve linearToggleEnabled through resolveFlag (Comfy-Org#15135)

## ELI-5

Nightly builds always turned the linear toggle on, no matter what. That
"always on" check ran *before* the code that looks at `?ff=` URL
overrides, `ff:` localStorage overrides, remote config, and the server
flag — so on nightly none of those could ever turn it off. Now nightly
is the *default* value fed into the normal resolution chain, so it stays
on unless something explicitly says otherwise.

## Summary

`linearToggleEnabled` short-circuited with `if (isNightly) return true`
above its `resolveFlag(...)` call, so the session-override and
dev-override layers (which live inside `resolveFlag`) were silently
ignored on nightly builds. Passing `isNightly` as `resolveFlag`'s
default instead keeps nightly on by default while letting every override
layer work.

## Changes

- **What**: `linearToggleEnabled` now resolves through
`resolveFlag(LINEAR_TOGGLE_ENABLED,
remoteConfig.value.linear_toggle_enabled, isNightly)` with no
short-circuit. Tests updated for the new nightly behavior plus three new
cases (remote-config `false`, server-served `false`, session override
`false` over an enabled remote config).
- **Breaking**: none. Off nightly, `isNightly` is `false`, which is
byte-identical to the previous `false` default — production and stable
behavior is unchanged.

## Review Focus

Two intentional behavior deltas, both nightly-only: (1)
`?ff=linear_toggle_enabled:false` and the `ff:` localStorage dev
override now change the flag, so an employee can reproduce the
non-nightly experience; (2) an explicitly-served `false` from remote
config or the server flag now wins over the built-in nightly on. When
nothing is served, `getServerFeature(LINEAR_TOGGLE_ENABLED, true)`
returns the `true` default, so nightly stays on.

The default is deliberately `isNightly` alone, **not** `isNightly ||
import.meta.env.DEV` as in the neighbouring
`nodeLibraryEssentialsEnabled` getter — this flag has never defaulted on
in dev and that is preserved.

Judgment calls: the first existing test asserted
`expect(api.getServerFeature).not.toHaveBeenCalled()`, which pinned the
removed short-circuit; it is rewritten to assert the flag still resolves
`true` and that `getServerFeature` is called with
`(LINEAR_TOGGLE_ENABLED, true)`. `isNightly = false` was added to the
`session override precedence` block's `afterEach` so the new nightly
case there cannot leak into the auth-gated tests that follow.

Verification: all four new/changed tests were confirmed red against the
pre-change getter and green after (41 passed in
`useFeatureFlags.test.ts`, 23 in `useWorkflowActionsMenu.test.ts` — the
only non-test consumer). `pnpm typecheck`, oxfmt and eslint ran clean
via the pre-commit hook.

Co-authored-by: Christian Byrne <cbyrne@comfy.org>

Author: mattmillerai

src/composables/useFeatureFlags.test.ts

@@ -148,12 +148,23 @@ describe('useFeatureFlags', () => {
   })
 
   describe('linearToggleEnabled', () => {
+    afterEach(() => {
+      vi.mocked(distributionTypes).isNightly = false
+      remoteConfig.value = {}
+    })
+
     it('should return true when isNightly is true', () => {
       vi.mocked(distributionTypes).isNightly = true
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (_path, defaultValue) => defaultValue
+      )
 
       const { flags } = useFeatureFlags()
       expect(flags.linearToggleEnabled).toBe(true)
-      expect(api.getServerFeature).not.toHaveBeenCalled()
+      expect(api.getServerFeature).toHaveBeenCalledWith(
+        ServerFeatureFlag.LINEAR_TOGGLE_ENABLED,
+        true
+      )
     })
 
     it('should check remote config and server feature when isNightly is false', () => {
@@ -182,6 +193,30 @@ describe('useFeatureFlags', () => {
       const { flags } = useFeatureFlags()
       expect(flags.linearToggleEnabled).toBe(false)
     })
+
+    it('lets a remote config false turn off the nightly default', () => {
+      vi.mocked(distributionTypes).isNightly = true
+      remoteConfig.value = { linear_toggle_enabled: false }
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (_path, defaultValue) => defaultValue
+      )
+
+      const { flags } = useFeatureFlags()
+      expect(flags.linearToggleEnabled).toBe(false)
+    })
+
+    it('lets a served server false turn off the nightly default', () => {
+      vi.mocked(distributionTypes).isNightly = true
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (path, defaultValue) =>
+          path === ServerFeatureFlag.LINEAR_TOGGLE_ENABLED
+            ? false
+            : defaultValue
+      )
+
+      const { flags } = useFeatureFlags()
+      expect(flags.linearToggleEnabled).toBe(false)
+    })
   })
 
   describe('nodeLibraryEssentialsEnabled', () => {
@@ -595,6 +630,7 @@ describe('useFeatureFlags', () => {
     afterEach(() => {
       vi.mocked(getSessionOverride).mockReset()
       vi.mocked(distributionTypes).isCloud = false
+      vi.mocked(distributionTypes).isNightly = false
       remoteConfigState.value = 'unloaded'
       cachedBillingControlEnabled.value = undefined
       remoteConfig.value = {}
@@ -627,6 +663,18 @@ describe('useFeatureFlags', () => {
       expect(flags.workflowSharingEnabled).toBe(false)
     })
 
+    it('turns the linear toggle off against an enabled remote config', () => {
+      vi.mocked(distributionTypes).isNightly = true
+      vi.mocked(getSessionOverride).mockImplementation((flagKey) =>
+        flagKey === ServerFeatureFlag.LINEAR_TOGGLE_ENABLED ? false : undefined
+      )
+      remoteConfig.value = { linear_toggle_enabled: true }
+      vi.mocked(api.getServerFeature).mockReturnValue(true)
+
+      const { flags } = useFeatureFlags()
+      expect(flags.linearToggleEnabled).toBe(false)
+    })
+
     it('turns the node library essentials tab off against an enabled remote config', () => {
       vi.mocked(getSessionOverride).mockImplementation((flagKey) =>
         flagKey === ServerFeatureFlag.NODE_LIBRARY_ESSENTIALS_ENABLED

src/composables/useFeatureFlags.ts

@@ -127,12 +127,10 @@ export function useFeatureFlags() {
       )
     },
     get linearToggleEnabled() {
-      if (isNightly) return true
-
       return resolveFlag(
         ServerFeatureFlag.LINEAR_TOGGLE_ENABLED,
         remoteConfig.value.linear_toggle_enabled,
-        false
+        isNightly
       )
     },
     get partnerNodeGovernanceEnabled() {