tabby-tabbyspaces 0.0.1 → 0.1.0

package/src/components/workspaceList.component.pug

@@ -5,8 +5,23 @@
       i.fas.fa-plus
       |  New Workspace
 
+  //- Editor (above list)
+  workspace-editor(
+    *ngIf='editingWorkspace',
+    [workspace]='editingWorkspace',
+    [autoFocus]='isCreatingNew',
+    [hasUnsavedChanges]='hasUnsavedChanges',
+    (save)='onEditorSave($event)',
+    (cancel)='onEditorCancel()'
+  )
+
+  //- Workspace list
   .workspace-list(*ngIf='workspaces.length > 0')
-    .workspace-item(*ngFor='let workspace of workspaces')
+    .workspace-item(
+      *ngFor='let workspace of workspaces',
+      [class.selected]='isSelected(workspace)',
+      (click)='selectWorkspace(workspace)'
+    )
       .workspace-info
         .workspace-icon([style.color]='workspace.color')
           i.fas([class]='"fa-" + (workspace.icon || "columns")')
@@ -16,31 +31,27 @@
             span {{ getPaneCount(workspace) }} panes
             span.separator ·
             span {{ getOrientationLabel(workspace) }}
-            span.separator(*ngIf='workspace.isDefault') ·
-            span.badge.badge-primary(*ngIf='workspace.isDefault') default
+            span.separator(*ngIf='workspace.launchOnStartup') ·
+            span.badge.badge-primary(*ngIf='workspace.launchOnStartup') startup
 
       .workspace-actions
-        button.btn.btn-link(
+        button.btn.btn-link.open-btn(
           type='button',
-          title='Set as default',
-          (click)='setAsDefault(workspace)',
-          [class.active]='workspace.isDefault'
+          title='Open',
+          [disabled]='openingWorkspaceId === workspace.id',
+          (click)='openWorkspace($event, workspace)'
         )
-          i.fas.fa-star
-        button.btn.btn-link(type='button', title='Duplicate', (click)='duplicateWorkspace(workspace)')
+          i.fas(
+            [class.fa-external-link-alt]='openingWorkspaceId !== workspace.id',
+            [class.fa-spinner]='openingWorkspaceId === workspace.id',
+            [class.fa-spin]='openingWorkspaceId === workspace.id'
+          )
+        button.btn.btn-link(type='button', title='Duplicate', (click)='duplicateWorkspace($event, workspace)')
           i.fas.fa-copy
-        button.btn.btn-link(type='button', title='Edit', (click)='editWorkspace(workspace)')
-          i.fas.fa-edit
-        button.btn.btn-link.text-danger(type='button', title='Delete', (click)='deleteWorkspace(workspace)')
+        button.btn.btn-link.text-danger(type='button', title='Delete', (click)='deleteWorkspace($event, workspace)')
           i.fas.fa-trash
 
-  .workspace-empty(*ngIf='workspaces.length === 0')
+  //- Empty state
+  .workspace-empty(*ngIf='workspaces.length === 0 && !isCreatingNew')
     p No workspaces configured yet.
     p Click "New Workspace" to create your first split-layout workspace.
-
-workspace-editor(
-  *ngIf='showEditor',
-  [workspace]='editingWorkspace',
-  (save)='onEditorSave($event)',
-  (cancel)='closeEditor()'
-)

package/src/components/workspaceList.component.scss

@@ -1,6 +1,5 @@
 .workspace-list-container {
   padding: 20px;
-  max-width: 800px;
 }
 
 .workspace-list-header {
@@ -29,11 +28,19 @@
   background: var(--theme-bg-more);
   border-radius: 8px;
   border: 1px solid var(--theme-border);
-  transition: background 0.2s;
+  transition: background 0.2s, border-color 0.2s;
+  cursor: pointer;
 
   &:hover {
     background: var(--theme-bg-more-more);
   }
+
+  &.selected {
+    border-color: var(--theme-primary);
+    border-left-width: 3px;
+    background: var(--theme-bg-more-more);
+    box-shadow: 0 0 0 1px var(--theme-primary) inset;
+  }
 }
 
 .workspace-info {
@@ -84,15 +91,14 @@
     padding: 8px;
     color: var(--theme-fg-more);
     opacity: 0.7;
-    transition: opacity 0.2s;
+    transition: opacity 0.2s, color 0.2s;
 
     &:hover {
       opacity: 1;
     }
 
-    &.active {
-      color: gold;
-      opacity: 1;
+    &.open-btn:hover {
+      color: var(--theme-success, #10b981);
     }
 
     &.text-danger:hover {

package/src/components/workspaceList.component.ts

@@ -1,6 +1,7 @@
-import { Component, OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core'
-import { ConfigService } from 'tabby-core'
+import { Component, OnInit, OnDestroy, AfterViewInit, ChangeDetectorRef, ElementRef, NgZone } from '@angular/core'
+import { ConfigService, ProfilesService } from 'tabby-core'
 import { Subscription } from 'rxjs'
+import { StartupCommandService } from '../services/startupCommand.service'
 import { WorkspaceEditorService } from '../services/workspaceEditor.service'
 import {
   Workspace,
@@ -16,25 +17,58 @@ import {
   template: require('./workspaceList.component.pug'),
   styles: [require('./workspaceList.component.scss')],
 })
-export class WorkspaceListComponent implements OnInit, OnDestroy {
+export class WorkspaceListComponent implements OnInit, OnDestroy, AfterViewInit {
   workspaces: Workspace[] = []
+  selectedWorkspace: Workspace | null = null
   editingWorkspace: Workspace | null = null
-  showEditor = false
+  isCreatingNew = false
+  openingWorkspaceId: string | null = null
   private configSubscription: Subscription | null = null
 
   constructor(
     public config: ConfigService,
     private workspaceService: WorkspaceEditorService,
-    private cdr: ChangeDetectorRef
+    private profilesService: ProfilesService,
+    private startupService: StartupCommandService,
+    private cdr: ChangeDetectorRef,
+    private elementRef: ElementRef,
+    private zone: NgZone
   ) {}
 
   ngOnInit(): void {
     this.loadWorkspaces()
+    this.autoSelectFirst()
     this.configSubscription = this.config.changed$.subscribe(() => {
       this.loadWorkspaces()
     })
   }
 
+  ngAfterViewInit(): void {
+    // Hack: Override Tabby's settings-tab-body max-width restriction
+    setTimeout(() => {
+      const parent = this.elementRef.nativeElement.closest('settings-tab-body') as HTMLElement
+      if (parent) {
+        parent.style.maxWidth = '876px'
+      }
+    }, 0)
+  }
+
+  private autoSelectFirst(): void {
+    if (this.workspaces.length > 0 && !this.selectedWorkspace) {
+      this.selectWorkspace(this.workspaces[0])
+    }
+  }
+
+  selectWorkspace(workspace: Workspace): void {
+    this.isCreatingNew = false
+    this.selectedWorkspace = workspace
+    this.editingWorkspace = JSON.parse(JSON.stringify(workspace))
+  }
+
+  isSelected(workspace: Workspace): boolean {
+    return this.selectedWorkspace?.id === workspace.id
+  }
+
   ngOnDestroy(): void {
     this.configSubscription?.unsubscribe()
   }
@@ -49,8 +83,10 @@ export class WorkspaceListComponent implements OnInit, OnDestroy {
     const defaultProfileId = profiles[0]?.id || ''
     const workspace = createDefaultWorkspace()
     this.setProfileForAllPanes(workspace.root, defaultProfileId)
+    this.selectedWorkspace = null
     this.editingWorkspace = workspace
-    this.showEditor = true
+    this.isCreatingNew = true
+    this.cdr.detectChanges()
   }
 
   private setProfileForAllPanes(node: WorkspacePane | WorkspaceSplit, profileId: string): void {
@@ -62,49 +98,76 @@ export class WorkspaceListComponent implements OnInit, OnDestroy {
   }
 
   editWorkspace(workspace: Workspace): void {
-    this.editingWorkspace = JSON.parse(JSON.stringify(workspace))
-    this.showEditor = true
+    this.selectWorkspace(workspace)
   }
 
-  async duplicateWorkspace(workspace: Workspace): Promise<void> {
+  async duplicateWorkspace(event: MouseEvent, workspace: Workspace): Promise<void> {
+    event.stopPropagation()
     const clone = this.workspaceService.duplicateWorkspace(workspace)
     await this.workspaceService.addWorkspace(clone)
     this.loadWorkspaces()
+
+    // Select the duplicated workspace
+    const duplicated = this.workspaces.find((w) => w.id === clone.id)
+    if (duplicated) {
+      this.selectWorkspace(duplicated)
+    }
+    this.cdr.detectChanges()
   }
 
-  async deleteWorkspace(workspace: Workspace): Promise<void> {
-    console.log('[TabbySpaces] deleteWorkspace called', workspace.id)
+  async deleteWorkspace(event: MouseEvent, workspace: Workspace): Promise<void> {
+    event.stopPropagation()
     if (confirm(`Delete workspace "${workspace.name}"?`)) {
-      console.log('[TabbySpaces] confirm = true, calling service.deleteWorkspace')
+      const currentIndex = this.workspaces.findIndex((w) => w.id === workspace.id)
       await this.workspaceService.deleteWorkspace(workspace.id)
-      console.log('[TabbySpaces] service.deleteWorkspace done, calling loadWorkspaces')
       this.loadWorkspaces()
-      console.log('[TabbySpaces] loadWorkspaces done, workspaces:', this.workspaces.length)
+
+      // Select next workspace after deletion
+      if (this.workspaces.length > 0) {
+        const nextIndex = Math.min(currentIndex, this.workspaces.length - 1)
+        this.selectWorkspace(this.workspaces[nextIndex])
+      } else {
+        this.selectedWorkspace = null
+        this.editingWorkspace = null
+        this.isCreatingNew = false
+      }
+      this.cdr.detectChanges()
     }
   }
 
   async onEditorSave(workspace: Workspace): Promise<void> {
-    console.log('[TabbySpaces] onEditorSave called', workspace.id, workspace.name)
-    const existing = this.workspaces.find((w) => w.id === workspace.id)
-    console.log('[TabbySpaces] existing workspace?', !!existing)
-    if (existing) {
-      await this.workspaceService.updateWorkspace(workspace)
-    } else {
+    const isNew = !this.workspaces.find((w) => w.id === workspace.id)
+    if (isNew) {
       await this.workspaceService.addWorkspace(workspace)
+    } else {
+      await this.workspaceService.updateWorkspace(workspace)
     }
-    console.log('[TabbySpaces] save done, calling loadWorkspaces')
     this.loadWorkspaces()
-    console.log('[TabbySpaces] calling closeEditor')
-    this.closeEditor()
-    console.log('[TabbySpaces] closeEditor done, showEditor:', this.showEditor)
+    this.isCreatingNew = false
+
+    // Select the saved workspace
+    const saved = this.workspaces.find((w) => w.id === workspace.id)
+    if (saved) {
+      this.selectWorkspace(saved)
+    }
+    this.cdr.detectChanges()
   }
 
-  closeEditor(): void {
-    console.log('[TabbySpaces] closeEditor called, showEditor before:', this.showEditor)
-    this.showEditor = false
-    this.editingWorkspace = null
+  onEditorCancel(): void {
+    if (this.isCreatingNew) {
+      // Cancel new workspace creation - go back to first workspace or empty
+      this.isCreatingNew = false
+      if (this.workspaces.length > 0) {
+        this.selectWorkspace(this.workspaces[0])
+      } else {
+        this.selectedWorkspace = null
+        this.editingWorkspace = null
+      }
+    } else if (this.selectedWorkspace) {
+      // Reset to original workspace data
+      this.editingWorkspace = JSON.parse(JSON.stringify(this.selectedWorkspace))
+    }
     this.cdr.detectChanges()
-    console.log('[TabbySpaces] closeEditor done, showEditor after:', this.showEditor)
   }
 
   getPaneCount(workspace: Workspace): number {
@@ -115,10 +178,29 @@ export class WorkspaceListComponent implements OnInit, OnDestroy {
     return workspace.root.orientation === 'horizontal' ? 'horizontal' : 'vertical'
   }
 
-  async setAsDefault(workspace: Workspace): Promise<void> {
-    this.workspaces.forEach((w) => (w.isDefault = false))
-    workspace.isDefault = true
-    await this.workspaceService.saveWorkspaces(this.workspaces)
-    this.loadWorkspaces()
+  get hasUnsavedChanges(): boolean {
+    if (!this.editingWorkspace || !this.selectedWorkspace) return this.isCreatingNew
+    return JSON.stringify(this.editingWorkspace) !== JSON.stringify(this.selectedWorkspace)
+  }
+
+  async openWorkspace(event: MouseEvent, workspace: Workspace): Promise<void> {
+    event.stopPropagation()
+    if (this.openingWorkspaceId) return
+    this.openingWorkspaceId = workspace.id
+
+    try {
+      const commands = this.workspaceService.collectStartupCommands(workspace)
+      if (commands.length > 0) {
+        this.startupService.registerCommands(commands)
+      }
+
+      const profile = await this.workspaceService.generateTabbyProfile(workspace)
+      this.zone.run(() => {
+        this.profilesService.openNewTabForProfile(profile)
+      })
+    } finally {
+      this.openingWorkspaceId = null
+      this.cdr.detectChanges()
+    }
   }
 }

package/src/index.ts

@@ -8,6 +8,7 @@ import { WorkspaceEditorConfigProvider } from './providers/config.provider'
 import { WorkspaceEditorSettingsProvider } from './providers/settings.provider'
 import { WorkspaceToolbarProvider } from './providers/toolbar.provider'
 import { WorkspaceEditorService } from './services/workspaceEditor.service'
+import { StartupCommandService } from './services/startupCommand.service'
 
 import { WorkspaceListComponent } from './components/workspaceList.component'
 import { WorkspaceEditorComponent } from './components/workspaceEditor.component'
@@ -21,6 +22,7 @@ import { SplitPreviewComponent } from './components/splitPreview.component'
     { provide: SettingsTabProvider, useClass: WorkspaceEditorSettingsProvider, multi: true },
     { provide: ToolbarButtonProvider, useClass: WorkspaceToolbarProvider, multi: true },
     WorkspaceEditorService,
+    StartupCommandService,
   ],
   declarations: [
     WorkspaceListComponent,

package/src/models/workspace.model.ts

@@ -37,6 +37,7 @@ export interface TabbyRecoveryToken {
   tabTitle?: string
   tabCustomTitle?: string
   disableDynamicTitle?: boolean
+  cwd?: string
 }
 
 export interface TabbySplitLayoutProfile {
@@ -73,8 +74,7 @@ export interface Workspace {
   icon?: string
   color?: string
   root: WorkspaceSplit
-  isDefault?: boolean
-  hotkey?: string
+  launchOnStartup?: boolean
 }
 
 export function isWorkspaceSplit(node: WorkspacePane | WorkspaceSplit): node is WorkspaceSplit {
@@ -99,14 +99,41 @@ export function createDefaultSplit(orientation: 'horizontal' | 'vertical' = 'hor
   }
 }
 
-export function createDefaultWorkspace(name: string = 'New Workspace'): Workspace {
+// Color palette for workspaces
+const WORKSPACE_COLORS = [
+  '#3b82f6', // blue
+  '#10b981', // emerald
+  '#f59e0b', // amber
+  '#ef4444', // red
+  '#8b5cf6', // violet
+  '#ec4899', // pink
+  '#06b6d4', // cyan
+  '#f97316', // orange
+]
+
+// Icon list for workspaces
+const WORKSPACE_ICONS = [
+  'columns', 'terminal', 'code', 'folder', 'home', 'briefcase',
+  'cog', 'database', 'server', 'cloud', 'rocket', 'flask',
+  'bug', 'wrench', 'cube', 'layer-group', 'sitemap', 'project-diagram'
+]
+
+export function getRandomColor(): string {
+  return WORKSPACE_COLORS[Math.floor(Math.random() * WORKSPACE_COLORS.length)]
+}
+
+export function getRandomIcon(): string {
+  return WORKSPACE_ICONS[Math.floor(Math.random() * WORKSPACE_ICONS.length)]
+}
+
+export function createDefaultWorkspace(name: string = ''): Workspace {
   return {
     id: generateUUID(),
     name,
-    icon: 'columns',
-    color: '#3b82f6',
+    icon: getRandomIcon(),
+    color: getRandomColor(),
     root: createDefaultSplit(),
-    isDefault: false,
+    launchOnStartup: false,
   }
 }
 

package/src/providers/settings.provider.ts

@@ -1,12 +1,12 @@
 import { Injectable } from '@angular/core'
 import { SettingsTabProvider } from 'tabby-settings'
 import { WorkspaceListComponent } from '../components/workspaceList.component'
-import { CONFIG_KEY, DISPLAY_NAME } from '../build-config'
+import { CONFIG_KEY, DISPLAY_NAME, IS_DEV } from '../build-config'
 
 @Injectable()
 export class WorkspaceEditorSettingsProvider extends SettingsTabProvider {
   id = CONFIG_KEY
-  icon = 'columns'
+  icon = IS_DEV ? 'bolt' : 'th-large'
   title = DISPLAY_NAME
 
   getComponentType(): any {

package/src/providers/toolbar.provider.ts

@@ -1,8 +1,20 @@
 import { Injectable } from '@angular/core'
 import { ToolbarButtonProvider, ToolbarButton, ProfilesService, AppService } from 'tabby-core'
 import { WorkspaceEditorService } from '../services/workspaceEditor.service'
+import { StartupCommandService } from '../services/startupCommand.service'
 import { SettingsTabComponent } from 'tabby-settings'
-import { CONFIG_KEY, DISPLAY_NAME } from '../build-config'
+import { CONFIG_KEY, DISPLAY_NAME, IS_DEV } from '../build-config'
+
+const ICON_GRID = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="3" y="3" width="7" height="7"/>
+  <rect x="14" y="3" width="7" height="7"/>
+  <rect x="14" y="14" width="7" height="7"/>
+  <rect x="3" y="14" width="7" height="7"/>
+</svg>`
+
+const ICON_BOLT = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>
+</svg>`
 import { countPanes } from '../models/workspace.model'
 
 @Injectable()
@@ -10,20 +22,32 @@ export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
   constructor(
     private workspaceService: WorkspaceEditorService,
     private profilesService: ProfilesService,
-    private app: AppService
+    private app: AppService,
+    private startupService: StartupCommandService
   ) {
     super()
+    // Delay startup tasks to ensure Tabby config is loaded
+    setTimeout(() => {
+      // Cleanup orphaned profiles from previous plugin versions (one-time migration)
+      this.workspaceService.cleanupOrphanedProfiles()
+      // Launch workspaces marked for startup
+      this.launchStartupWorkspaces()
+    }, 500)
+  }
+
+  private async launchStartupWorkspaces(): Promise<void> {
+    const workspaces = this.workspaceService.getWorkspaces()
+    const startupWorkspaces = workspaces.filter(w => w.launchOnStartup)
+
+    for (const workspace of startupWorkspaces) {
+      await this.openWorkspace(workspace.id)
+    }
   }
 
   provide(): ToolbarButton[] {
     return [
       {
-        icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <rect x="3" y="3" width="7" height="7"/>
-          <rect x="14" y="3" width="7" height="7"/>
-          <rect x="14" y="14" width="7" height="7"/>
-          <rect x="3" y="14" width="7" height="7"/>
-        </svg>`,
+        icon: IS_DEV ? ICON_BOLT : ICON_GRID,
         title: DISPLAY_NAME,
         weight: 5,
         click: () => this.showWorkspaceSelector()
@@ -69,13 +93,20 @@ export class WorkspaceToolbarProvider extends ToolbarButtonProvider {
     this.app.openNewTabRaw({ type: SettingsTabComponent, inputs: { activeTab: CONFIG_KEY } })
   }
 
-  private openWorkspace(workspaceId: string): void {
+  private async openWorkspace(workspaceId: string): Promise<void> {
     const workspaces = this.workspaceService.getWorkspaces()
     const workspace = workspaces.find((w) => w.id === workspaceId)
 
     if (!workspace) return
 
-    const profile = this.workspaceService.generateTabbyProfile(workspace)
+    // Register startup commands BEFORE opening the workspace
+    // Commands will be sent via sendInput() when terminals open
+    const commands = this.workspaceService.collectStartupCommands(workspace)
+    if (commands.length > 0) {
+      this.startupService.registerCommands(commands)
+    }
+
+    const profile = await this.workspaceService.generateTabbyProfile(workspace)
     this.profilesService.openNewTabForProfile(profile)
   }
 }

package/src/services/startupCommand.service.ts

@@ -0,0 +1,142 @@
+import { Injectable } from '@angular/core'
+import { AppService, BaseTabComponent, SplitTabComponent } from 'tabby-core'
+import { BaseTerminalTabComponent } from 'tabby-terminal'
+import { Subscription, first, timer, switchMap } from 'rxjs'
+
+export interface PendingCommand {
+  paneId: string
+  command?: string
+  originalTitle: string
+}
+
+@Injectable()
+export class StartupCommandService {
+  private pendingCommands: Map<string, PendingCommand> = new Map()
+  private subscription: Subscription
+
+  constructor(private app: AppService) {
+    this.subscription = this.app.tabOpened$.subscribe((tab) => this.onTabOpened(tab))
+  }
+
+  registerCommands(commands: PendingCommand[]): void {
+    console.log('[TabbySpaces] Registering commands:', commands)
+    for (const cmd of commands) {
+      this.pendingCommands.set(cmd.paneId, cmd)
+    }
+  }
+
+  private onTabOpened(tab: BaseTabComponent): void {
+    console.log('[TabbySpaces] Tab opened:', {
+      type: tab.constructor.name,
+      title: tab.title,
+    })
+
+    // Handle SplitTabComponent - get all child terminal tabs
+    if (tab instanceof SplitTabComponent) {
+      console.log('[TabbySpaces] SplitTabComponent detected, waiting for children...')
+      // Wait for split tab to fully initialize its children
+      setTimeout(() => this.processChildTabs(tab), 300)
+      return
+    }
+
+    // Handle individual terminal tab (shouldn't happen for split-layout, but just in case)
+    if (tab instanceof BaseTerminalTabComponent) {
+      this.processTerminalTab(tab)
+    }
+  }
+
+  private processChildTabs(splitTab: SplitTabComponent): void {
+    // Get all nested tabs from the split container
+    const allTabs = splitTab.getAllTabs()
+    console.log('[TabbySpaces] Found child tabs:', allTabs.length)
+
+    for (const tab of allTabs) {
+      if (tab instanceof BaseTerminalTabComponent) {
+        this.processTerminalTab(tab)
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private processTerminalTab(terminalTab: BaseTerminalTabComponent<any>): void {
+    const paneId = terminalTab.customTitle || terminalTab.title
+    console.log('[TabbySpaces] Processing terminal tab:', {
+      title: terminalTab.title,
+      customTitle: terminalTab.customTitle,
+      paneId,
+      pendingKeys: [...this.pendingCommands.keys()],
+    })
+
+    const pending = this.pendingCommands.get(paneId)
+    if (!pending) {
+      console.log('[TabbySpaces] No matching command for paneId:', paneId)
+      return
+    }
+
+    this.pendingCommands.delete(paneId)
+
+    // Build startup command (cd + command)
+    const fullCommand = this.buildFullCommand(pending)
+    if (!fullCommand) {
+      console.log('[TabbySpaces] No command to send (no cwd or startup command)')
+      return
+    }
+
+    console.log('[TabbySpaces] Command matched, waiting for shell output...:', fullCommand)
+
+    // Wait for shell to emit first output (prompt), then send command
+    if (terminalTab.session?.output$) {
+      terminalTab.session.output$.pipe(
+        first(),                      // Wait for first output (shell prompt)
+        switchMap(() => timer(100))   // Small buffer after prompt renders
+      ).subscribe(() => {
+        console.log('[TabbySpaces] Shell ready, sending command:', fullCommand)
+        terminalTab.sendInput(fullCommand + '\r')
+
+        // Clear profile args to prevent native splits from re-running command
+        this.clearProfileArgs(terminalTab)
+
+        // Reset title - either to original or clear for dynamic shell title
+        if (pending.originalTitle) {
+          terminalTab.setTitle(pending.originalTitle)
+        } else {
+          terminalTab.customTitle = ''
+        }
+      })
+    } else {
+      console.log('[TabbySpaces] No session.output$, falling back to timeout')
+      // Fallback if session not available yet
+      setTimeout(() => {
+        terminalTab.sendInput(fullCommand + '\r')
+
+        // Clear profile args to prevent native splits from re-running command
+        this.clearProfileArgs(terminalTab)
+
+        if (pending.originalTitle) {
+          terminalTab.setTitle(pending.originalTitle)
+        } else {
+          terminalTab.customTitle = ''
+        }
+      }, 500)
+    }
+  }
+
+  private buildFullCommand(pending: PendingCommand): string | null {
+    return pending.command || null
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private clearProfileArgs(terminalTab: BaseTerminalTabComponent<any>): void {
+    // Clear args from profile to prevent native splits from re-running startup command
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const profile = (terminalTab as any).profile
+    if (profile?.options?.args) {
+      console.log('[TabbySpaces] Clearing profile args to prevent re-run on split')
+      profile.options.args = []
+    }
+  }
+
+  ngOnDestroy(): void {
+    this.subscription?.unsubscribe()
+  }
+}