@jhorst11/wt 2.0.0 → 2.0.2

package/README.md

@@ -107,6 +107,9 @@ Create `<repo>/.wt/config.json`:
     "post-create": [
       "npm install",
       "cp $WT_SOURCE/.env .env"
+    ],
+    "pre-destroy": [
+      "npm run clean"
     ]
   }
 }
@@ -120,16 +123,49 @@ Create `<repo>/.wt/config.json`:
 | `worktreesDir` | `string` | `~/projects/worktrees` | Directory where worktrees are created |
 | `branchPrefix` | `string` | `""` | Prefix for branch names (e.g., "username/") |
 | `hooks.post-create` | `string[]` | `[]` | Shell commands to run after creating a worktree |
+| `hooks.pre-destroy` | `string[]` | `[]` | Shell commands to run before removing a worktree |
 
 **Hook environment variables** (available in hook commands):
 
 | Variable | Description |
 |----------|-------------|
 | `WT_SOURCE` | Absolute path to the main repository |
-| `WT_BRANCH` | Branch name of the new worktree |
-| `WT_PATH` | Absolute path to the new worktree (also the cwd) |
+| `WT_BRANCH` | Branch name of the worktree |
+| `WT_PATH` | Absolute path to the worktree (also the cwd) |
+| `WT_NAME` | Worktree name (directory name, e.g. `feature-a`) |
+| `WT_COLOR` | Hex color assigned to this worktree (e.g. `#E53935`), for UI/theming |
 
-Hook commands run with cwd set to the new worktree path. If a hook command fails, a warning is shown but the worktree creation still succeeds.
+Each new worktree is assigned a unique color from a fixed palette (stored in `<repo>/.wt/worktree-colors.json`). In supported terminals (iTerm2, WezTerm, Ghostty, Kitty, Windows Terminal, Alacritty), the tab color is set to that worktree's color when you create a worktree or run `wt go <name>`. Colors also appear as indicators (●) throughout the CLI UI.
+
+Hook commands run with cwd set to the worktree path. To run a Node script that lives in the main repo (e.g. `<repo>/.wt/scripts/foo.js`), use `WT_SOURCE`: `node "$WT_SOURCE/.wt/scripts/foo.js"` — `./scripts/foo.js` would look inside the worktree, not the main repo. If a hook command fails, a warning is shown but the operation continues (worktree creation still succeeds; worktree removal still proceeds after pre-destroy).
+
+#### Worktree Color Configuration
+
+Override automatic colors or provide a custom palette:
+
+**Manual color assignment** (`.wt/config.json`):
+
+```json
+{
+  "worktreeColors": {
+    "feature-auth": "#FF5733",
+    "feature-payments": "#33FF57"
+  }
+}
+```
+
+**Custom color palette** (`.wt/config.json`):
+
+```json
+{
+  "colorPalette": [
+    "#FF6B6B", "#4ECDC4", "#45B7D1", "#FFA07A",
+    "#98D8C8", "#F7DC6F", "#BB8FCE", "#85C1E2"
+  ]
+}
+```
+
+Colors are stored per-repository in `.wt/worktree-colors.json` and support hierarchical configuration (global → repo → directory overrides).
 
 ## How It Works
 

package/bin/wt.js

@@ -20,12 +20,13 @@ const { version } = require('../package.json');
 program
   .name('wt')
   .description('🌳 Beautiful interactive git worktree manager')
-  .version(version);
+  .version(version)
+  .option('--verbose', 'Show full hook command output (default: show command name with spinner only)');
 
 program
   .command('new', { isDefault: false })
   .description('Create a new worktree interactively')
-  .action(createWorktreeFlow);
+  .action((_args, cmd) => createWorktreeFlow({ verbose: !!cmd.parent?.opts?.()?.verbose }));
 
 program
   .command('list')
@@ -37,12 +38,12 @@ program
   .command('remove')
   .alias('rm')
   .description('Remove a worktree interactively')
-  .action(removeWorktreeFlow);
+  .action((_args, cmd) => removeWorktreeFlow({ verbose: !!cmd.parent?.opts?.()?.verbose }));
 
 program
   .command('merge')
   .description('Merge a worktree branch back to main')
-  .action(mergeWorktreeFlow);
+  .action((_args, cmd) => mergeWorktreeFlow({ verbose: !!cmd.parent?.opts?.()?.verbose }));
 
 program
   .command('home')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhorst11/wt",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "🌳 Beautiful interactive git worktree manager",
   "type": "module",
   "bin": {

package/src/commands.js

@@ -18,9 +18,13 @@ import {
   colors,
   icons,
   formatBranchChoice,
+  formatWorktreeChoice,
+  setTabColor,
+  resetTabColor,
+  colorIndicator,
 } from './ui.js';
 import { showCdHint } from './setup.js';
-import { resolveConfig, loadConfig, runHooks } from './config.js';
+import { resolveConfig, loadConfig, runHooks, assignWorktreeColor, getWorktreeColor, removeWorktreeColor } from './config.js';
 import {
   isGitRepo,
   getRepoRoot,
@@ -39,6 +43,7 @@ import {
   getMainBranch,
   hasUncommittedChanges,
   deleteBranch,
+  getCurrentWorktreeInfo,
 } from './git.js';
 
 function isUserCancellation(err) {
@@ -71,12 +76,18 @@ export async function mainMenu() {
   const currentBranch = await getCurrentBranch();
   const config = resolveConfig(process.cwd(), repoRoot);
   const worktrees = await getWorktreesInBase(repoRoot, config);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
 
   const branchDisplay = currentBranch && currentBranch !== 'HEAD'
     ? colors.branch(currentBranch)
     : colors.warning('detached HEAD');
   subheading(`  📍 ${colors.path(repoRoot)}`);
   subheading(`  🌿 ${branchDisplay}`);
+  if (currentWt) {
+    const wtColor = getWorktreeColor(repoRoot, currentWt.name);
+    const colorDot = colorIndicator(wtColor);
+    subheading(`  ${colorDot} ${colors.highlight(currentWt.name)}`);
+  }
   spacer();
 
   const choices = [
@@ -162,14 +173,17 @@ export async function mainMenu() {
   }
 }
 
-export async function createWorktreeFlow() {
-  showMiniLogo();
+export async function createWorktreeFlow(options = {}) {
   await ensureGitRepo();
+  const repoRoot = await getRepoRoot();
+  const config = resolveConfig(process.cwd(), repoRoot);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
 
   heading(`${icons.plus} Create New Worktree`);
 
   const currentBranch = await getCurrentBranch();
-  const repoRoot = await getRepoRoot();
   const isDetached = !currentBranch || currentBranch === 'HEAD';
 
   try {
@@ -321,6 +335,10 @@ export async function createWorktreeFlow() {
     info(`Branch:   ${colors.branch(branchName)}`);
     info(`Base:     ${colors.muted(baseBranch || 'HEAD')}`);
     info(`Path:     ${colors.path(getWorktreesBase(repoRoot, config) + '/' + worktreeName)}`);
+    const postCreateHooks = config.hooks?.['post-create'];
+    if (postCreateHooks?.length) {
+      info(`Hooks:    ${colors.muted(`post-create (${postCreateHooks.length} command${postCreateHooks.length === 1 ? '' : 's'})`)}`);
+    }
     divider();
     spacer();
 
@@ -354,7 +372,11 @@ export async function createWorktreeFlow() {
       spinner.succeed(colors.success('Worktree created!'));
       spacer();
 
-      success(`Created worktree at ${colors.path(result.path)}`);
+      const worktreeColor = assignWorktreeColor(repoRoot, worktreeName);
+      setTabColor(worktreeColor);
+
+      const colorDot = colorIndicator(worktreeColor);
+      success(`${colorDot} Created worktree at ${colors.path(result.path)}`);
       if (result.branchCreated) {
         success(`Created new branch ${colors.branch(branchName)}`);
       } else if (result.branchSource === 'updated-from-remote') {
@@ -364,7 +386,7 @@ export async function createWorktreeFlow() {
       }
 
       // Run post-create hooks
-      const hookCommands = repoConfig.hooks?.['post-create'];
+      const hookCommands = config.hooks?.['post-create'];
       if (hookCommands && hookCommands.length > 0) {
         spacer();
         const hookSpinner = ora({
@@ -372,11 +394,19 @@ export async function createWorktreeFlow() {
           color: 'magenta',
         }).start();
 
-        const hookResults = runHooks('post-create', repoConfig, {
-          source: repoRoot,
-          path: result.path,
-          branch: branchName,
-        });
+        const hookResults = await runHooks(
+          'post-create',
+          config,
+          { source: repoRoot, path: result.path, branch: branchName, name: worktreeName, color: worktreeColor },
+          {
+            verbose: options.verbose,
+            onCommandStart: (cmd, i, total) => {
+              hookSpinner.text = total > 1
+                ? `Running post-create hooks... (${i}/${total}: ${cmd})`
+                : `Running post-create hooks... (${cmd})`;
+            },
+          }
+        );
 
         const failed = hookResults.filter((r) => !r.success);
         if (failed.length === 0) {
@@ -385,6 +415,7 @@ export async function createWorktreeFlow() {
           hookSpinner.warn(colors.warning(`${failed.length} of ${hookResults.length} hook${hookResults.length === 1 ? '' : 's'} failed`));
           for (const f of failed) {
             warning(`Hook failed: ${colors.muted(f.command)}`);
+            if (f.error) info(colors.muted(f.error));
           }
         }
       }
@@ -400,13 +431,14 @@ export async function createWorktreeFlow() {
 }
 
 export async function listWorktrees() {
-  showMiniLogo();
   await ensureGitRepo();
-
   const repoRoot = await getRepoRoot();
   const config = resolveConfig(process.cwd(), repoRoot);
   const worktrees = await getWorktreesInBase(repoRoot, config);
   const currentPath = process.cwd();
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
 
   heading(`${icons.folder} Worktrees`);
 
@@ -423,7 +455,8 @@ export async function listWorktrees() {
 
   for (const wt of worktrees) {
     const isCurrent = currentPath === wt.path || currentPath.startsWith(wt.path + '/');
-    worktreeItem(wt.name, wt.path, isCurrent);
+    const wtColor = getWorktreeColor(repoRoot, wt.name);
+    worktreeItem(wt.name, wt.path, isCurrent, wtColor);
     const branchDisplay = wt.branch === 'unknown'
       ? colors.warning('detached HEAD')
       : colors.branch(wt.branch);
@@ -436,14 +469,16 @@ export async function listWorktrees() {
   spacer();
 }
 
-export async function removeWorktreeFlow() {
-  showMiniLogo();
+export async function removeWorktreeFlow(options = {}) {
   await ensureGitRepo();
+  const repoRoot = await getRepoRoot();
+  const config = resolveConfig(process.cwd(), repoRoot);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
 
   heading(`${icons.trash} Remove Worktree`);
 
-  const repoRoot = await getRepoRoot();
-  const config = resolveConfig(process.cwd(), repoRoot);
   const worktrees = await getWorktreesInBase(repoRoot, config);
   const currentPath = process.cwd();
 
@@ -459,8 +494,9 @@ export async function removeWorktreeFlow() {
     const choices = worktrees.map((wt) => {
       const isCurrent = currentPath === wt.path || currentPath.startsWith(wt.path + '/');
       const currentLabel = isCurrent ? colors.warning(' (you are here)') : '';
+      const wtColor = getWorktreeColor(repoRoot, wt.name);
       return {
-        name: `${icons.folder}  ${colors.highlight(wt.name)} ${colors.muted(`→ ${wt.branch}`)}${currentLabel}`,
+        name: formatWorktreeChoice(wt, wtColor) + currentLabel,
         value: wt,
         description: wt.path,
       };
@@ -491,7 +527,13 @@ export async function removeWorktreeFlow() {
     }
 
     spacer();
-    warning(`This will remove: ${colors.path(selected.path)}`);
+    const selectedColor = getWorktreeColor(repoRoot, selected.name);
+    const colorDot = colorIndicator(selectedColor);
+    warning(`${colorDot} This will remove: ${colors.path(selected.path)}`);
+    const preDestroyHooks = config.hooks?.['pre-destroy'];
+    if (preDestroyHooks?.length) {
+      info(`Hooks:    ${colors.muted(`pre-destroy (${preDestroyHooks.length} command${preDestroyHooks.length === 1 ? '' : 's'}) will run first`)}`);
+    }
     spacer();
 
     const confirmed = await confirm({
@@ -505,6 +547,42 @@ export async function removeWorktreeFlow() {
       return;
     }
 
+    // Run pre-destroy hooks
+    const preDestroyCommands = config.hooks?.['pre-destroy'];
+    if (preDestroyCommands && preDestroyCommands.length > 0) {
+      spacer();
+      const hookSpinner = ora({
+        text: 'Running pre-destroy hooks...',
+        color: 'magenta',
+      }).start();
+
+      const hookResults = await runHooks(
+        'pre-destroy',
+        config,
+        { source: repoRoot, path: selected.path, branch: selected.branch, name: selected.name, color: getWorktreeColor(repoRoot, selected.name) },
+        {
+          verbose: options.verbose,
+          onCommandStart: (cmd, i, total) => {
+            hookSpinner.text = total > 1
+              ? `Running pre-destroy hooks... (${i}/${total}: ${cmd})`
+              : `Running pre-destroy hooks... (${cmd})`;
+          },
+        }
+      );
+
+      const failed = hookResults.filter((r) => !r.success);
+      if (failed.length === 0) {
+        hookSpinner.succeed(colors.success(`Ran ${hookResults.length} pre-destroy hook${hookResults.length === 1 ? '' : 's'}`));
+      } else {
+        hookSpinner.warn(colors.warning(`${failed.length} of ${hookResults.length} hook${hookResults.length === 1 ? '' : 's'} failed`));
+        for (const f of failed) {
+          warning(`Hook failed: ${colors.muted(f.command)}`);
+          if (f.error) info(colors.muted(f.error));
+        }
+      }
+      spacer();
+    }
+
     const spinner = ora({
       text: 'Removing worktree...',
       color: 'yellow',
@@ -536,7 +614,10 @@ export async function removeWorktreeFlow() {
 
       spinner.succeed(colors.success('Worktree removed!'));
       spacer();
-      success(`Removed ${colors.highlight(selected.name)}`);
+      const removedColor = getWorktreeColor(repoRoot, selected.name);
+      const removedColorDot = colorIndicator(removedColor);
+      removeWorktreeColor(repoRoot, selected.name);
+      success(`${removedColorDot} Removed ${colors.highlight(selected.name)}`);
 
       if (isInsideSelected) {
         spacer();
@@ -556,15 +637,17 @@ export async function removeWorktreeFlow() {
   }
 }
 
-export async function mergeWorktreeFlow() {
-  showMiniLogo();
+export async function mergeWorktreeFlow(options = {}) {
   await ensureGitRepo();
+  const repoRoot = await getRepoRoot();
+  const config = resolveConfig(process.cwd(), repoRoot);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
 
   heading(`🔀 Merge Worktree`);
 
-  const repoRoot = await getRepoRoot();
   const mainPath = await getMainRepoPath();
-  const config = resolveConfig(process.cwd(), repoRoot);
   const worktrees = await getWorktreesInBase(repoRoot, config);
   const currentPath = process.cwd();
   const isAtHome = currentPath === mainPath;
@@ -579,11 +662,14 @@ export async function mergeWorktreeFlow() {
 
   try {
     // Select worktree to merge
-    const wtChoices = worktrees.map((wt) => ({
-      name: `${icons.folder}  ${colors.highlight(wt.name)} ${colors.muted(`→ ${wt.branch}`)}`,
-      value: wt,
-      description: wt.path,
-    }));
+    const wtChoices = worktrees.map((wt) => {
+      const wtColor = getWorktreeColor(repoRoot, wt.name);
+      return {
+        name: formatWorktreeChoice(wt, wtColor),
+        value: wt,
+        description: wt.path,
+      };
+    });
 
     wtChoices.push({
       name: `${colors.muted(icons.cross + '  Cancel')}`,
@@ -682,7 +768,9 @@ export async function mergeWorktreeFlow() {
     // Confirm merge
     spacer();
     divider();
-    info(`From: ${colors.highlight(selectedWt.branch)} ${colors.muted(`(${selectedWt.name})`)}`);
+    const selectedColor = getWorktreeColor(repoRoot, selectedWt.name);
+    const selectedColorDot = colorIndicator(selectedColor);
+    info(`${selectedColorDot} From: ${colors.highlight(selectedWt.branch)} ${colors.muted(`(${selectedWt.name})`)}`);
     info(`Into: ${colors.branch(targetBranch)}`);
     divider();
     spacer();
@@ -719,6 +807,42 @@ export async function mergeWorktreeFlow() {
       });
 
       if (cleanup) {
+        // Run pre-destroy hooks before removing the worktree
+        const preDestroyCommands = config.hooks?.['pre-destroy'];
+        if (preDestroyCommands && preDestroyCommands.length > 0) {
+          spacer();
+          const hookSpinner = ora({
+            text: 'Running pre-destroy hooks...',
+            color: 'magenta',
+          }).start();
+
+          const hookResults = await runHooks(
+            'pre-destroy',
+            config,
+            { source: repoRoot, path: selectedWt.path, branch: selectedWt.branch, name: selectedWt.name, color: getWorktreeColor(repoRoot, selectedWt.name) },
+            {
+              verbose: options.verbose,
+              onCommandStart: (cmd, i, total) => {
+                hookSpinner.text = total > 1
+                  ? `Running pre-destroy hooks... (${i}/${total}: ${cmd})`
+                  : `Running pre-destroy hooks... (${cmd})`;
+              },
+            }
+          );
+
+          const failed = hookResults.filter((r) => !r.success);
+          if (failed.length === 0) {
+            hookSpinner.succeed(colors.success(`Ran ${hookResults.length} pre-destroy hook${hookResults.length === 1 ? '' : 's'}`));
+          } else {
+            hookSpinner.warn(colors.warning(`${failed.length} of ${hookResults.length} hook${hookResults.length === 1 ? '' : 's'} failed`));
+            for (const f of failed) {
+              warning(`Hook failed: ${colors.muted(f.command)}`);
+              if (f.error) info(colors.muted(f.error));
+            }
+          }
+          spacer();
+        }
+
         const cleanupSpinner = ora({
           text: 'Cleaning up...',
           color: 'yellow',
@@ -726,6 +850,7 @@ export async function mergeWorktreeFlow() {
 
         try {
           await removeWorktree(selectedWt.path, false, mainPath);
+          removeWorktreeColor(repoRoot, selectedWt.name);
           cleanupSpinner.succeed(colors.success('Worktree removed'));
 
           // Ask about deleting branch
@@ -764,8 +889,12 @@ export async function mergeWorktreeFlow() {
 }
 
 export async function goHome() {
-  showMiniLogo();
   await ensureGitRepo();
+  const repoRoot = await getRepoRoot();
+  const config = resolveConfig(process.cwd(), repoRoot);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
 
   const mainPath = await getMainRepoPath();
   const currentPath = process.cwd();
@@ -792,16 +921,18 @@ export async function goHome() {
   spacer();
   success(`Heading home... ${icons.home}`);
   console.log(`  ${colors.muted('Path:')} ${colors.path(mainPath)}`);
-
+  resetTabColor();
   showCdHint(mainPath);
 }
 
 export async function goToWorktree(name) {
-  showMiniLogo();
   await ensureGitRepo();
-
   const repoRoot = await getRepoRoot();
   const config = resolveConfig(process.cwd(), repoRoot);
+  const currentWt = await getCurrentWorktreeInfo(repoRoot, config);
+  const wtColor = currentWt ? getWorktreeColor(repoRoot, currentWt.name) : null;
+  showMiniLogo(currentWt ? { ...currentWt, color: wtColor } : null);
+
   const worktrees = await getWorktreesInBase(repoRoot, config);
 
   if (worktrees.length === 0) {
@@ -847,8 +978,9 @@ export async function goToWorktree(name) {
       const choices = worktrees.map((wt) => {
         const isCurrent = currentPath === wt.path || currentPath.startsWith(wt.path + '/');
         const currentLabel = isCurrent ? colors.muted(' (current)') : '';
+        const wtColor = getWorktreeColor(repoRoot, wt.name);
         return {
-          name: `${icons.folder}  ${colors.highlight(wt.name)} ${colors.muted(`→ ${wt.branch}`)}${currentLabel}`,
+          name: formatWorktreeChoice(wt, wtColor) + currentLabel,
           value: wt,
           description: wt.path,
         };
@@ -876,8 +1008,12 @@ export async function goToWorktree(name) {
   }
 
   spacer();
-  success(`Jumping to ${colors.highlight(selected.name)}`);
+  const selectedColor = getWorktreeColor(repoRoot, selected.name);
+  const selectedColorDot = colorIndicator(selectedColor);
+  success(`${selectedColorDot} Jumping to ${colors.highlight(selected.name)}`);
   console.log(`  ${colors.muted('Path:')} ${colors.path(selected.path)}`);
 
+  if (selectedColor) setTabColor(selectedColor);
+
   showCdHint(selected.path);
 }

package/src/config.js

@@ -1,10 +1,117 @@
-import { readFileSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 import { homedir } from 'os';
+import { once } from 'events';
 
 const CONFIG_DIR = '.wt';
 const CONFIG_FILE = 'config.json';
+const WORKTREE_COLORS_FILE = 'worktree-colors.json';
+
+/** Distinct hex colors (with #) for worktree tab/UI; cycle through for unique assignment. */
+export const WORKTREE_COLORS_PALETTE = [
+  '#E53935', '#D81B60', '#8E24AA', '#5E35B1', '#3949AB', '#1E88E5', '#039BE5', '#00ACC1',
+  '#00897B', '#43A047', '#7CB342', '#C0CA33', '#FDD835', '#FFB300', '#FB8C00', '#F4511E',
+];
+
+function getWorktreeColorsPath(repoRoot) {
+  return join(repoRoot, CONFIG_DIR, WORKTREE_COLORS_FILE);
+}
+
+/**
+ * Load worktree name → hex color map from repo's .wt/worktree-colors.json.
+ * @returns {Record<string, string>}
+ */
+export function loadWorktreeColors(repoRoot) {
+  const path = getWorktreeColorsPath(repoRoot);
+  try {
+    const raw = readFileSync(path, 'utf8');
+    const data = JSON.parse(raw);
+    if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
+      const out = {};
+      for (const [name, hex] of Object.entries(data)) {
+        if (typeof name === 'string' && typeof hex === 'string' && /^#[0-9A-Fa-f]{6}$/.test(hex)) {
+          out[name] = hex;
+        }
+      }
+      return out;
+    }
+  } catch {
+    // file missing or invalid
+  }
+  return {};
+}
+
+/**
+ * Save worktree name → hex color map to repo's .wt/worktree-colors.json.
+ */
+export function saveWorktreeColors(repoRoot, mapping) {
+  const dir = join(repoRoot, CONFIG_DIR);
+  const path = getWorktreeColorsPath(repoRoot);
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(mapping, null, 2) + '\n', 'utf8');
+  } catch {
+    // ignore write errors (e.g. read-only repo)
+  }
+}
+
+/**
+ * Assign a unique color to a new worktree. Checks config overrides first, then
+ * uses first palette color not used by existing worktrees.
+ * Persists and returns the hex color (e.g. "#E53935").
+ */
+export function assignWorktreeColor(repoRoot, worktreeName) {
+  const current = loadWorktreeColors(repoRoot);
+
+  // Check if already assigned
+  let hex = current[worktreeName];
+  if (hex) return hex;
+
+  // Check config override
+  const config = resolveConfig(process.cwd(), repoRoot);
+  if (config.worktreeColors?.[worktreeName]) {
+    hex = config.worktreeColors[worktreeName];
+    current[worktreeName] = hex;
+    saveWorktreeColors(repoRoot, current);
+    return hex;
+  }
+
+  // Auto-assign from palette (prefer custom palette if configured)
+  const palette = config.colorPalette || WORKTREE_COLORS_PALETTE;
+  const usedColors = new Set(Object.values(current));
+
+  for (const c of palette) {
+    if (!usedColors.has(c)) {
+      hex = c;
+      break;
+    }
+  }
+
+  hex = hex || palette[usedColors.size % palette.length];
+  current[worktreeName] = hex;
+  saveWorktreeColors(repoRoot, current);
+  return hex;
+}
+
+/**
+ * Get the assigned hex color for a worktree, or null if none.
+ */
+export function getWorktreeColor(repoRoot, worktreeName) {
+  const current = loadWorktreeColors(repoRoot);
+  return current[worktreeName] ?? null;
+}
+
+/**
+ * Remove a worktree's color assignment so the color can be reused.
+ */
+export function removeWorktreeColor(repoRoot, worktreeName) {
+  const current = loadWorktreeColors(repoRoot);
+  if (worktreeName in current) {
+    delete current[worktreeName];
+    saveWorktreeColors(repoRoot, current);
+  }
+}
 
 /**
  * Load configuration from .wt/config.json or config.json at the given directory.
@@ -21,6 +128,8 @@ export function loadConfig(dirPath) {
     worktreesDir: undefined,
     branchPrefix: undefined,
     hooks: {},
+    worktreeColors: {},
+    colorPalette: undefined,
   };
 
   let raw;
@@ -70,6 +179,23 @@ export function loadConfig(dirPath) {
     }
   }
 
+  if (typeof parsed.worktreeColors === 'object' && parsed.worktreeColors !== null && !Array.isArray(parsed.worktreeColors)) {
+    for (const [name, hex] of Object.entries(parsed.worktreeColors)) {
+      if (typeof name === 'string' && typeof hex === 'string' && /^#[0-9A-Fa-f]{6}$/.test(hex)) {
+        result.worktreeColors[name] = hex;
+      }
+    }
+  }
+
+  if (Array.isArray(parsed.colorPalette)) {
+    const validColors = parsed.colorPalette.filter(hex =>
+      typeof hex === 'string' && /^#[0-9A-Fa-f]{6}$/.test(hex)
+    );
+    if (validColors.length > 0) {
+      result.colorPalette = validColors;
+    }
+  }
+
   return result;
 }
 
@@ -219,37 +345,80 @@ export function resolveConfig(cwd = process.cwd(), repoRoot, globalConfigPath) {
   };
 }
 
+const HOOK_TIMEOUT_MS = 300_000; // 5 minutes per command
+
 /**
  * Run hook commands sequentially. Each command runs with cwd set to `wtPath`
  * and receives WT_SOURCE, WT_BRANCH, and WT_PATH as environment variables.
  *
+ * Options:
+ * - verbose: if true, stream stdout/stderr to the terminal; if false, suppress output and only report results.
+ * - onCommandStart(cmd, index, total): called before each command (e.g. to update a spinner).
+ *
  * Returns an array of { command, success, error? } results.
  * Hook failures are non-fatal — they produce warnings but don't throw.
  */
-export function runHooks(hookName, config, { source, path: wtPath, branch }) {
+export async function runHooks(hookName, config, { source, path: wtPath, branch, name: wtName, color: wtColor }, options = {}) {
   const commands = config.hooks?.[hookName];
   if (!commands || commands.length === 0) return [];
 
+  const { verbose = false, onCommandStart } = options;
+  const total = commands.length;
+
   const env = {
     ...process.env,
     WT_SOURCE: source,
     WT_BRANCH: branch,
     WT_PATH: wtPath,
+    ...(wtName !== undefined && { WT_NAME: wtName }),
+    ...(wtColor !== undefined && wtColor !== null && { WT_COLOR: wtColor }),
   };
 
   const results = [];
 
-  for (const cmd of commands) {
-    try {
-      execSync(cmd, {
-        cwd: wtPath,
-        env,
-        stdio: 'pipe',
-        timeout: 300_000, // 5 minute timeout per command
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    if (typeof onCommandStart === 'function') {
+      onCommandStart(cmd, i + 1, total);
+    }
+
+    const child = spawn(cmd, [], {
+      shell: true,
+      cwd: wtPath,
+      env,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    const stderrChunks = [];
+    if (verbose) {
+      child.stdout.pipe(process.stdout);
+      child.stderr.on('data', (chunk) => {
+        process.stderr.write(chunk);
+        stderrChunks.push(chunk);
       });
-      results.push({ command: cmd, success: true });
+    } else {
+      child.stdout.on('data', () => {}); // consume to avoid blocking the child
+      child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+    }
+
+    const timeoutId = setTimeout(() => {
+      child.kill('SIGTERM');
+    }, HOOK_TIMEOUT_MS);
+
+    try {
+      const [code, signal] = await once(child, 'exit');
+      clearTimeout(timeoutId);
+      if (code === 0 && !signal) {
+        results.push({ command: cmd, success: true });
+      } else {
+        const stderr = Buffer.concat(stderrChunks).toString().trim();
+        const detail = stderr || (signal ? `Killed by ${signal}` : `Exited with code ${code}`);
+        results.push({ command: cmd, success: false, error: detail });
+      }
     } catch (err) {
-      results.push({ command: cmd, success: false, error: err.message });
+      clearTimeout(timeoutId);
+      const stderr = Buffer.concat(stderrChunks).toString().trim();
+      results.push({ command: cmd, success: false, error: stderr || err.message });
     }
   }
 

package/src/git.js

@@ -395,3 +395,22 @@ export async function deleteBranch(branchName, force = false, cwd = process.cwd(
   await git.branch([flag, branchName]);
   return { success: true };
 }
+
+/**
+ * Get information about the current worktree if user is inside one.
+ * Returns the worktree object with name, path, and branch if inside a worktree.
+ * Returns null if in main repository or error occurs.
+ * @param {string} repoRoot - Git repository root
+ * @param {object} config - Configuration object from resolveConfig()
+ * @returns {Promise<object|null>} Worktree info object or null
+ */
+export async function getCurrentWorktreeInfo(repoRoot, config) {
+  const currentPath = process.cwd();
+  const worktrees = await getWorktreesInBase(repoRoot, config);
+
+  const currentWt = worktrees.find(wt =>
+    currentPath === wt.path || currentPath.startsWith(wt.path + '/')
+  );
+
+  return currentWt || null;
+}

package/src/ui.js

@@ -55,8 +55,13 @@ export function showLogo() {
   console.log(logo);
 }
 
-export function showMiniLogo() {
-  console.log(`\n  ${icons.tree} ${wtGradient('worktree')} ${colors.muted(`v${version}`)}\n`);
+export function showMiniLogo(worktreeInfo = null) {
+  console.log(`\n  ${icons.tree} ${wtGradient('worktree')} ${colors.muted(`v${version}`)}`);
+  if (worktreeInfo) {
+    const colorDot = colorIndicator(worktreeInfo.color);
+    console.log(`  ${colorDot} ${colors.highlight(worktreeInfo.name)} ${colors.muted(`→ ${worktreeInfo.branch}`)}`);
+  }
+  console.log('');
 }
 
 export function success(message) {
@@ -96,10 +101,12 @@ export function branchItem(name, isCurrent = false, isRemote = false) {
   console.log(`  ${prefix} ${icon} ${branchName}${typeLabel}`);
 }
 
-export function worktreeItem(name, path, isCurrent = false) {
+export function worktreeItem(name, path, isCurrent = false, color = null) {
   const prefix = isCurrent ? colors.success(icons.pointer) : ' ';
   const nameDisplay = isCurrent ? colors.success.bold(name) : colors.highlight(name);
-  console.log(`  ${prefix} ${icons.folder} ${nameDisplay}`);
+  const colorDot = colorIndicator(color);
+  const displayName = colorDot ? `${colorDot} ${nameDisplay}` : nameDisplay;
+  console.log(`  ${prefix} ${icons.folder} ${displayName}`);
   console.log(`      ${colors.muted(path)}`);
 }
 
@@ -111,14 +118,162 @@ export function spacer() {
   console.log('');
 }
 
+/**
+ * Convert hex color to chalk color function.
+ * Falls back to gray for invalid hex.
+ * @param {string} hex - Hex color like "#E53935" or "E53935"
+ * @returns {Function} Chalk color function
+ */
+export function hexToChalk(hex) {
+  if (!hex) return chalk.gray;
+  const clean = hex.replace(/^#/, '');
+  if (!/^[0-9A-Fa-f]{6}$/.test(clean)) return chalk.gray;
+  return chalk.hex(clean);
+}
+
+/**
+ * Create a colored circle indicator (●) for visual color display.
+ * Returns empty string if hex is null/invalid.
+ * @param {string} hex - Hex color like "#E53935"
+ * @returns {string} Colored circle character or empty string
+ */
+export function colorIndicator(hex) {
+  if (!hex) return '';
+  const color = hexToChalk(hex);
+  return color('●'); // U+25CF filled circle
+}
+
+/**
+ * Convert hex to RGB components for terminal sequences.
+ * @param {string} hex - Hex color like "#E53935"
+ * @returns {{r: number, g: number, b: number}} RGB components 0-255
+ */
+export function hexToRgb(hex) {
+  const clean = hex.replace(/^#/, '');
+  return {
+    r: parseInt(clean.slice(0, 2), 16),
+    g: parseInt(clean.slice(2, 4), 16),
+    b: parseInt(clean.slice(4, 6), 16),
+  };
+}
+
+/**
+ * Create a colored divider using the specified hex color.
+ * Falls back to muted color if hex is invalid.
+ * @param {string} hex - Hex color like "#E53935"
+ */
+export function coloredDivider(hex) {
+  const color = hex ? hexToChalk(hex) : colors.muted;
+  console.log(color('  ─'.repeat(20)));
+}
+
+/**
+ * Detect terminal type for appropriate color sequences.
+ * Checks TERM_PROGRAM, TERM, WT_SESSION, and COLORTERM env vars.
+ * @returns {string} Terminal type: 'iterm2' | 'wezterm' | 'alacritty' |
+ *                   'kitty' | 'ghostty' | 'windows-terminal' | 'vscode' |
+ *                   'osc-generic' | 'unsupported'
+ */
+export function detectTerminal() {
+  const termProgram = process.env.TERM_PROGRAM || '';
+  const term = process.env.TERM || '';
+  const colorTerm = process.env.COLORTERM || '';
+
+  if (termProgram === 'iTerm.app') return 'iterm2';
+  if (termProgram === 'WezTerm') return 'wezterm';
+  if (termProgram === 'ghostty') return 'ghostty';
+  if (termProgram === 'vscode') return 'vscode';
+  if (process.env.WT_SESSION) return 'windows-terminal';
+  if (term.includes('kitty')) return 'kitty';
+  if (termProgram.includes('Alacritty') || term.includes('alacritty')) return 'alacritty';
+
+  // Generic OSC support for truecolor terminals
+  if (colorTerm === 'truecolor' || colorTerm === '24bit') return 'osc-generic';
+
+  return 'unsupported';
+}
+
+/**
+ * Set terminal tab color (supports multiple terminal types).
+ * Works with iTerm2, WezTerm, Kitty, Alacritty, Windows Terminal.
+ * No-op if stdout is not a TTY or terminal is unsupported.
+ * @param {string} hex - Hex color like "#E53935" or "E53935"
+ */
+export function setTabColor(hex) {
+  if (!process.stdout.isTTY || !hex) return;
+
+  const terminal = detectTerminal();
+  const rgb = hex.replace(/^#/, '');
+
+  if (!/^[0-9A-Fa-f]{6}$/.test(rgb)) return;
+
+  switch (terminal) {
+    case 'iterm2':
+    case 'osc-generic':
+      process.stdout.write(`\x1b]1337;SetColors=tab=${rgb}\x07`);
+      break;
+    case 'wezterm':
+      // WezTerm uses base64-encoded user vars
+      const b64 = Buffer.from(rgb).toString('base64');
+      process.stdout.write(`\x1b]1337;SetUserVar=tab_color=${b64}\x07`);
+      break;
+    case 'kitty':
+      process.stdout.write(`\x1b]30001;rgb:${rgb}\x07`);
+      break;
+    case 'alacritty':
+      // Background color as fallback
+      const r = rgb.slice(0, 2);
+      const g = rgb.slice(2, 4);
+      const b = rgb.slice(4, 6);
+      process.stdout.write(`\x1b]10;rgb:${r}/${g}/${b}\x07`);
+      break;
+    case 'windows-terminal':
+      process.stdout.write(`\x1b]9;4;1;${rgb}\x07`);
+      break;
+    // 'ghostty', 'vscode' and 'unsupported' - no-op
+  }
+}
+
+/**
+ * Reset terminal tab color to default.
+ * Gracefully handles multiple terminal types.
+ */
+export function resetTabColor() {
+  if (!process.stdout.isTTY) return;
+
+  const terminal = detectTerminal();
+
+  switch (terminal) {
+    case 'iterm2':
+    case 'osc-generic':
+      process.stdout.write('\x1b]1337;SetColors=tab=default\x07');
+      break;
+    case 'wezterm':
+      const b64 = Buffer.from('').toString('base64');
+      process.stdout.write(`\x1b]1337;SetUserVar=tab_color=${b64}\x07`);
+      break;
+    case 'kitty':
+      process.stdout.write('\x1b]30001;rgb:000000\x07');
+      break;
+    case 'alacritty':
+      process.stdout.write('\x1b]10;rgb:00/00/00\x07');
+      break;
+    case 'windows-terminal':
+      process.stdout.write('\x1b]9;4;0\x07');
+      break;
+  }
+}
+
 export function formatBranchChoice(branch, type = 'local') {
   const icon = type === 'remote' ? icons.remote : icons.local;
   const typeLabel = type === 'remote' ? chalk.dim(' (remote)') : '';
   return `${icon}  ${branch}${typeLabel}`;
 }
 
-export function formatWorktreeChoice(wt) {
-  return `${icons.folder}  ${colors.highlight(wt.name)} ${colors.muted(`→ ${wt.branch}`)}`;
+export function formatWorktreeChoice(wt, color = null) {
+  const colorDot = colorIndicator(color);
+  const prefix = colorDot ? `${colorDot} ` : '';
+  return `${prefix}${icons.folder}  ${colors.highlight(wt.name)} ${colors.muted(`→ ${wt.branch}`)}`;
 }
 
 export function showHelp() {