fix(worktrees): pass worktree path to tree actions and move title buttons into the view

VS Code invokes view/item/context (including inline) commands with the tree
element itself as args[0], not TreeItem.command.arguments. Every action in
WorktreeTreeActionCommand (open/terminal/copyWip/remove/copyPath/reveal/
addToWorkspace) declared its argument as a path string, so remove threw
"paths[0] argument must be of type string" via path.resolve(), and the other
actions silently misbehaved on the object. resolveWorktreeArg() normalizes
string/Uri/tree-item shapes before they reach any git or fs call.

Also moves "Move to New Worktree" and "Remove Multiple Worktrees" out of the
view/title toolbar (they had no icon, so VS Code rendered them as text and
crowded out the "GIT SMART CHECKOUT: WORKTREES" header) into a labelled
action-row section at the top of the tree itself.

Author: Test

package.json

@@ -233,6 +233,7 @@
       {
         "command": "git-smart-checkout.worktree.open",
         "title": "Open Worktree in New Window",
+        "icon": "$(folder-opened)",
         "category": "GSC"
       },
       {
@@ -329,16 +330,6 @@
           "when": "view == git-smart-checkout.worktrees",
           "group": "navigation@1"
         },
-        {
-          "command": "git-smart-checkout.moveToNewWorktree",
-          "when": "view == git-smart-checkout.worktrees",
-          "group": "navigation@2"
-        },
-        {
-          "command": "git-smart-checkout.removeMultipleWorktrees",
-          "when": "view == git-smart-checkout.worktrees && git-smart-checkout.hasMultipleRemovableWorktrees",
-          "group": "navigation@3"
-        },
         {
           "command": "git-smart-checkout.prCancelCloneMenu",
           "when": "view == git-smart-checkout.prClone && git-smart-checkout.isCloning == true && git-smart-checkout.isConflict == true",

src/commands/utils/resolveWorktreeArg.ts

@@ -0,0 +1,40 @@
+import * as vscode from 'vscode';
+
+export interface ResolvedWorktreeArg {
+  worktreePath: string;
+  repositoryPath?: string;
+}
+
+/**
+ * `view/item/context` (including `inline`) commands are invoked by VS Code with the tree
+ * element itself as the first argument, not `TreeItem.command.arguments` (those only apply
+ * to the row's default click command). Normalizes whatever shape shows up — a plain string,
+ * a Uri, or a WorktreeTreeItem — into a path string.
+ */
+export function resolveWorktreeArg(arg: unknown, repositoryPath?: string): ResolvedWorktreeArg | undefined {
+  if (typeof arg === 'string') {
+    return arg ? { worktreePath: arg, repositoryPath } : undefined;
+  }
+  if (arg instanceof vscode.Uri) {
+    return { worktreePath: arg.fsPath, repositoryPath };
+  }
+  if (isWorktreeTreeItemLike(arg)) {
+    return { worktreePath: arg.worktree.path, repositoryPath: arg.repositoryPath ?? repositoryPath };
+  }
+  return undefined;
+}
+
+function isWorktreeTreeItemLike(
+  arg: unknown
+): arg is { worktree: { path: string }; repositoryPath?: string } {
+  if (typeof arg !== 'object' || arg === null) {
+    return false;
+  }
+  const candidate = arg as { worktree?: unknown; repositoryPath?: unknown };
+  return (
+    typeof candidate.worktree === 'object' &&
+    candidate.worktree !== null &&
+    typeof (candidate.worktree as { path?: unknown }).path === 'string' &&
+    (candidate.repositoryPath === undefined || typeof candidate.repositoryPath === 'string')
+  );
+}

src/commands/utils/worktreeRemoval.ts

@@ -27,6 +27,9 @@ export function isSameOrChildPath(candidatePath: string, parentPath: string): bo
 }
 
 export function normalizePathForComparison(targetPath: string): string {
+  if (typeof targetPath !== 'string') {
+    return '';
+  }
   try {
     return fs.realpathSync.native(targetPath);
   } catch {

src/commands/worktreeTreeActionCommand.ts

@@ -5,6 +5,7 @@ import { RemoveWorktreeCommand } from './removeWorktreeCommand';
 import { VscodeGitProvider } from '../common/git/vscodeGitProvider';
 import { LoggingService } from '../logging/loggingService';
 import { addToWorkspace } from './utils/worktreeCompletionActions';
+import { resolveWorktreeArg } from './utils/resolveWorktreeArg';
 import { BaseCommand } from './command';
 
 export type WorktreeTreeAction =
@@ -31,8 +32,12 @@ export class WorktreeTreeActionCommand extends BaseCommand {
     super(logService);
   }
 
-  async execute(worktreePath?: string, repositoryPath?: string): Promise<void> {
-    if (!worktreePath) return;
+  async execute(arg?: unknown, repositoryPathArg?: string): Promise<void> {
+    const resolved = resolveWorktreeArg(arg, repositoryPathArg);
+    if (!resolved) {
+      return;
+    }
+    const { worktreePath, repositoryPath } = resolved;
 
     switch (this.action) {
       case 'open':

src/test/unit/resolveWorktreeArg.test.ts

@@ -0,0 +1,50 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+import { resolveWorktreeArg } from '../../commands/utils/resolveWorktreeArg';
+
+describe('resolveWorktreeArg', () => {
+  it('passes through a plain string path', () => {
+    assert.deepStrictEqual(resolveWorktreeArg('/repo/feature', '/repo'), {
+      worktreePath: '/repo/feature',
+      repositoryPath: '/repo',
+    });
+  });
+
+  it('extracts fsPath from a Uri', () => {
+    const uri = vscode.Uri.file('/repo/feature');
+    assert.deepStrictEqual(resolveWorktreeArg(uri, '/repo'), {
+      worktreePath: '/repo/feature',
+      repositoryPath: '/repo',
+    });
+  });
+
+  it('extracts the path from a WorktreeTreeItem-shaped object, the argument VS Code actually sends for inline/context-menu commands', () => {
+    const fakeTreeItem = {
+      worktree: { path: '/repo/feature' },
+      repositoryPath: '/repo',
+      contextValue: 'worktree linked clean',
+    };
+    assert.deepStrictEqual(resolveWorktreeArg(fakeTreeItem), {
+      worktreePath: '/repo/feature',
+      repositoryPath: '/repo',
+    });
+  });
+
+  it('falls back to a separately passed repositoryPath when the tree item has none', () => {
+    const fakeTreeItem = { worktree: { path: '/repo/feature' } };
+    assert.deepStrictEqual(resolveWorktreeArg(fakeTreeItem, '/repo'), {
+      worktreePath: '/repo/feature',
+      repositoryPath: '/repo',
+    });
+  });
+
+  it('returns undefined for unrecognized shapes', () => {
+    assert.strictEqual(resolveWorktreeArg(undefined), undefined);
+    assert.strictEqual(resolveWorktreeArg(null), undefined);
+    assert.strictEqual(resolveWorktreeArg(''), undefined);
+    assert.strictEqual(resolveWorktreeArg(42), undefined);
+    assert.strictEqual(resolveWorktreeArg({}), undefined);
+    assert.strictEqual(resolveWorktreeArg({ worktree: {} }), undefined);
+  });
+});

src/test/unit/worktreeTreeDataProvider.test.ts

@@ -1,6 +1,11 @@
 import * as assert from 'assert';
 import * as os from 'os';
-import { WorktreeTreeDataProvider, WorktreeTreeItem } from '../../view/WorktreeTreeDataProvider';
+import {
+  WorktreeActionTreeItem,
+  WorktreeRepositoryTreeItem,
+  WorktreeTreeDataProvider,
+  WorktreeTreeItem,
+} from '../../view/WorktreeTreeDataProvider';
 import { PRReviewWorktreeStore } from '../../services/prReviewWorktreeStore';
 import { mockLogService } from '../e2e/helpers/mockLogService';
 
@@ -74,6 +79,35 @@ describe('WorktreeTreeItem', () => {
   });
 });
 
+describe('WorktreeRepositoryTreeItem', () => {
+  it('uses a contextValue that does not collide with the \\bworktree\\b menu matcher', () => {
+    const item = new WorktreeRepositoryTreeItem('/repo', []);
+    assert.strictEqual(item.contextValue, 'worktreeRepository');
+    assert.ok(!/\bworktree\b/.test(item.contextValue));
+  });
+});
+
+describe('WorktreeTreeDataProvider.getChildren action rows', () => {
+  function makeProvider() {
+    const store = { getForRepository: async () => [] } as unknown as PRReviewWorktreeStore;
+    return new WorktreeTreeDataProvider(mockLogService, store);
+  }
+
+  it('lists a "Move to New Worktree" action row before any worktrees, with no "Remove Multiple" row when there are none to remove', async () => {
+    const provider = makeProvider();
+    const children = await provider.getChildren();
+
+    const actionRows = children.filter((child) => child instanceof WorktreeActionTreeItem);
+    assert.strictEqual(actionRows.length, 1);
+    assert.strictEqual(actionRows[0].label, 'Move to New Worktree…');
+    assert.strictEqual(
+      (actionRows[0].command as { command: string }).command,
+      'git-smart-checkout.moveToNewWorktree'
+    );
+    assert.ok(!/\bworktree\b/.test(String(actionRows[0].contextValue)));
+  });
+});
+
 describe('WorktreeTreeDataProvider.refreshDebounced', () => {
   function makeProvider() {
     const store = { getForRepository: async () => [] } as unknown as PRReviewWorktreeStore;

src/view/WorktreeTreeDataProvider.ts

@@ -92,12 +92,26 @@ export class WorktreeRepositoryTreeItem extends vscode.TreeItem {
   constructor(public readonly repositoryPath: string, public readonly children: WorktreeTreeItem[]) {
     super(path.basename(repositoryPath) || repositoryPath, vscode.TreeItemCollapsibleState.Expanded);
     this.description = repositoryPath;
-    this.contextValue = 'worktree.repository';
+    this.contextValue = 'worktreeRepository';
     this.iconPath = new vscode.ThemeIcon('repo');
   }
 }
 
-type WorktreeNode = WorktreeTreeItem | WorktreeRepositoryTreeItem;
+/**
+ * Full-width action row rendered at the top of the tree, replacing the text buttons that
+ * used to live in the view/title toolbar (VS Code renders title-bar buttons without an
+ * icon as text, which crowded out the view header).
+ */
+export class WorktreeActionTreeItem extends vscode.TreeItem {
+  constructor(label: string, icon: string, command: string) {
+    super(label, vscode.TreeItemCollapsibleState.None);
+    this.iconPath = new vscode.ThemeIcon(icon);
+    this.contextValue = 'worktreeAction';
+    this.command = { command, title: label };
+  }
+}
+
+type WorktreeNode = WorktreeTreeItem | WorktreeRepositoryTreeItem | WorktreeActionTreeItem;
 
 const DEFAULT_DEBOUNCE_MS = 2000;
 
@@ -119,17 +133,39 @@ export class WorktreeTreeDataProvider implements vscode.TreeDataProvider<Worktre
     return item;
   }
 
-  async getChildren(element?: WorktreeRepositoryTreeItem): Promise<WorktreeNode[]> {
+  async getChildren(element?: WorktreeNode): Promise<WorktreeNode[]> {
     if (!this.loaded) {
       await this.load();
     }
-    if (element) {
+    if (element instanceof WorktreeRepositoryTreeItem) {
       return element.children;
     }
-    if (this.repositories.length > 1) {
-      return this.repositories;
+    if (element) {
+      return [];
+    }
+    const nodes = this.repositories.length > 1 ? this.repositories : this.items;
+    return [...this.getActionItems(), ...nodes];
+  }
+
+  private getActionItems(): WorktreeActionTreeItem[] {
+    const removableCount = this.items.filter((item) => !item.isMain).length;
+    const actions = [
+      new WorktreeActionTreeItem(
+        'Move to New Worktree…',
+        'new-folder',
+        'git-smart-checkout.moveToNewWorktree'
+      ),
+    ];
+    if (removableCount >= 2) {
+      actions.push(
+        new WorktreeActionTreeItem(
+          'Remove Multiple Worktrees…',
+          'trash',
+          'git-smart-checkout.removeMultipleWorktrees'
+        )
+      );
     }
-    return this.items;
+    return actions;
   }
 
   /** Reloads immediately. Used for explicit user-triggered refreshes. */