       @disposables.add @onDidMoveToItemArea =>
         @setReadOnly(true)
 
+    @disposables.add(@registerCommands())
+
+    # Depends on ui.grammar and commands bound to @editorElement, so have to come last
+    @providerPanel = new ProviderPanel(this, showSearchOption: @provider.showSearchOption)
+
+    @constructor.register(this)
+    @disposables.add new Disposable =>
+      @constructor.unregister(this)
+
+  start: ->
+    # When initial getItems() take very long time, it means refresh get delayed.
+    # In this case, user see modified icon(mark) on tab.
+    # Explicitly setting modified start here prevent this
+    @setModifiedState(false)
+
+    if isNarrowEditor(@provider.editor)
+      exNarrowEditor = @provider.editor
+      # Invoked from another narrow-editor(= ex-narrow-editor).
+      # Rebind provider's editor to behaves like it invoked from normal-editor.
+      @provider.bindEditor(@constructor.get(exNarrowEditor).provider.editor)
+
+    pane = getAdjacentPaneOrSplit(@provider.getPane(), split: settings.get('directionToOpen'))
+    # pane.activate() unless pane.isActive()
+
+    # [NOTE] When new item is activated, existing PENDING item is destroyed.
+    # So existing PENDING narrow-editor is destroyed at this timing.
+    # And PENDING narrow-editor's provider's editor have foucsed.
+    # So pane.activate must be called AFTER activateItem
+    pane.activateItem(@editor, {@pending})
+    pane.activate()
+
+    @grammar.activate()
+    @insertQuery(@query)
+    @providerPanel.show()
+
     @disposables.add(
       @registerCommands()
       @observeChange()
       @observeCursorMove()
       @observeStopChangingActivePaneItem()
     )
-    # Depends on ui.grammar and commands bound to @editorElement, so have to come last
-    @providerPanel = new ProviderPanel(this, showSearchOption: @provider.showSearchOption)
-
-    @constructor.register(this)
-    @disposables.add new Disposable =>
-      @constructor.unregister(this)
-
-  start: ->
-    # When initial getItems() take very long time, it means refresh get delayed.
-    # In this case, user see modified icon(mark) on tab.
-    # Explicitly setting modified start here prevent this
-    @setModifiedState(false)
-
-    providerPane = @provider.getPane()
-    if isNarrowEditor(@provider.editor)
-      # If narrow is invoked from narrow-editor, open in same pane.
-      pane = providerPane
-    else
-      pane = getAdjacentPaneOrSplit(providerPane, split: settings.get('directionToOpen'))
-
-    pane.activate() unless pane.isActive()
-    pane.activateItem(@editor, {@pending})
-
-    @grammar.activate()
-    if @query
-      @insertQuery(@query)
-    else
-      @withIgnoreChange => @insertQuery()
-    @providerPanel.show()
+
     @moveToPrompt()
     @refresh().then =>
-      @activateProviderPane() unless @activate
+      if @activate
+        @preview() if @query and @autoPreview
+      else
+        @activateProviderPane()
 
   observeStopChangingActivePaneItem: ->
     atom.workspace.onDidStopChangingActivePaneItem (item) =>
-      @provider.needRestoreEditorState = false
+      if item isnt @editor
+        # When item other than narrow-editor was activated,
+        # No longer restore editor's state.
+        # This guard is necessary since initial narrow-editor open fire this event.
+        @provider.needRestoreEditorState = false
       return if not isTextEditor(item) or isNarrowEditor(item)
       return if paneForItem(item) is @getPane()
       @startSyncToEditor(item)


  syncToEditor: (editor) ->
    return if @preventSyncToEditor
    return if @isActive()
    if item = @findClosestItemForEditor(editor)
      @selectItem(item)
      {row} = @editor.getCursorBufferPosition()


    @syncSubcriptions?.dispose()
    @syncSubcriptions = new CompositeDisposable
    @syncToEditor(editor)

    ignoreColumnChange = @provider.ignoreSideMovementOnSyncToEditor

    @syncSubcriptions.add editor.onDidChangeCursorPosition (event) =>
      return unless isActiveEditor(editor)
      return if event.textChanged
      return if ignoreColumnChange and (event.oldBufferPosition.row is event.newBufferPosition.row)
      @syncToEditor(editor)

    @syncSubcriptions.add @onDidRefresh =>
      @syncToEditor(editor)

    # Avoid refresh while active, important to update-real-file don't cause auto-refresh.
    refresh = => @refresh(force: true) unless @isActive()

    if @provider.boundToEditor
      @syncSubcriptions.add editor.onDidStopChanging(refresh)
    else
      @syncSubcriptions.add editor.onDidSave(refresh)
