opencode-worktree 0.3.5 → 0.4.0

package/README.md

@@ -8,12 +8,14 @@ Terminal UI for managing git worktrees and launching your preferred coding tool
 - Worktree metadata display: last edited time, dirty status, remote tracking
 - Status indicators: `[main]` for main worktree, `[*]` for uncommitted changes, `[local]` for local-only branches
 - Create new worktrees directly from the TUI
+- **Create branch from worktree**: create a new branch from any worktree's current commit, with optional checkout
 - Post-create hooks: automatically run commands (e.g., `npm install`) after creating a worktree
 - Open worktree folder in file manager or custom editor
 - Unlink worktrees (remove directory, keep branch)
 - Delete worktrees and local branches (never remote)
 - Multi-select delete mode for batch deletion
 - **Customizable launch command**: use `opencode`, `cursor`, `claude`, `code`, or any CLI tool
+- **Global configuration**: settings stored in `~/.config/opencode-worktree/config.json` with per-repo overrides
 - Refresh list on demand
 - Update notifications when new versions are available
 
@@ -47,10 +49,18 @@ opencode-worktree /path/to/your/repo
 - `o`: open worktree folder in file manager or custom editor (configurable)
 - `d`: enter multi-select delete mode (press again to confirm deletion)
 - `n`: create new worktree
+- `b`: create a new branch from selected worktree's current commit
 - `c`: edit configuration (hooks, open command, launch command)
 - `r`: refresh list
 - `q` or `Esc`: quit (or cancel dialogs/modes)
 
+### Create branch from worktree
+
+1. Select a worktree and press `b`
+2. Enter a name for the new branch
+3. The branch is created starting from the worktree's current commit
+4. Choose whether to checkout the new branch in the worktree
+
 ### Multi-select delete mode
 
 1. Press `d` to enter selection mode
@@ -60,7 +70,27 @@ opencode-worktree /path/to/your/repo
 
 ## Configuration
 
-You can configure per-repository settings by creating a `.opencode-worktree.json` file in your repository root, or by pressing `c` in the TUI.
+Configuration is stored globally at `~/.config/opencode-worktree/config.json` with support for default settings and per-repository overrides. Press `c` in the TUI to edit settings.
+
+Repositories are identified by their git remote URL (e.g., `github.com/user/repo`).
+
+### Configuration structure
+
+```json
+{
+  "default": {
+    "postCreateHook": "",
+    "openCommand": "",
+    "launchCommand": "opencode"
+  },
+  "repos": {
+    "github.com/user/repo": {
+      "postCreateHook": "npm install",
+      "launchCommand": "cursor"
+    }
+  }
+}
+```
 
 ### Configuration options
 
@@ -70,107 +100,58 @@ You can configure per-repository settings by creating a `.opencode-worktree.json
 | `openCommand` | Command for opening worktree folders (`o` key) | system default |
 | `launchCommand` | Command to launch when selecting a worktree (`Enter` key) | `opencode` |
 
-### Example configuration
+### Example per-repo configuration
+
+When you edit config in the TUI, settings are saved under the repo's key (derived from git remote URL):
 
 ```json
 {
-  "postCreateHook": "npm install",
-  "openCommand": "code",
-  "launchCommand": "cursor"
+  "default": {
+    "launchCommand": "opencode"
+  },
+  "repos": {
+    "github.com/myorg/frontend": {
+      "postCreateHook": "npm install",
+      "openCommand": "code",
+      "launchCommand": "cursor"
+    },
+    "github.com/myorg/backend": {
+      "postCreateHook": "go mod download",
+      "launchCommand": "zed"
+    }
+  }
 }
 ```
 
-### First-time setup
-
-When you first run `opencode-worktree` in a repository without a configuration file, you'll be prompted to configure settings. You can also skip this step and configure later by pressing `c`.
-
 ### Editing configuration
 
-Press `c` at any time to edit your configuration. Use `Tab` to switch between fields.
+Press `c` at any time to edit your configuration. The config editor title shows which repository you're configuring (e.g., "Config: github.com/user/repo"). Use `Tab` to switch between fields.
+
+**Note:** Repositories without a git remote will use default settings. The TUI shows a warning when editing config for repos without a remote.
 
 ### Post-create hooks
 
 Run a command automatically after creating a new worktree. Useful for installing dependencies.
 
-```json
-{
-  "postCreateHook": "npm install"
-}
-```
-
 The hook output is streamed to the TUI in real-time. If the hook fails, you can choose to open the tool anyway or cancel.
 
-**Examples:**
-
-```json
-{
-  "postCreateHook": "bun install"
-}
-```
-
-```json
-{
-  "postCreateHook": "npm install && npm run setup"
-}
-```
+**Examples:** `npm install`, `bun install`, `npm install && npm run setup`
 
 ### Custom open command
 
 Use a custom command when pressing `o` to open worktree folders. Useful for opening in your preferred IDE.
 
-```json
-{
-  "openCommand": "webstorm"
-}
-```
-
-**Examples:**
-
-```json
-{
-  "openCommand": "code"
-}
-```
+**Examples:** `code`, `webstorm`, `idea`
 
 ### Custom launch command
 
 Use a different tool instead of `opencode` when pressing `Enter` to open a worktree. This allows you to use any CLI-based coding tool.
 
-```json
-{
-  "launchCommand": "cursor"
-}
-```
-
-**Examples:**
+**Examples:** `cursor`, `claude`, `code`, `zed`
 
-```json
-{
-  "launchCommand": "claude"
-}
-```
+### Migration from v0.3.x
 
-```json
-{
-  "launchCommand": "code"
-}
-```
-
-```json
-{
-  "launchCommand": "zed"
-}
-```
-
-### Full configuration example
-
-```json
-{
-  "postCreateHook": "npm install",
-  "openCommand": "code",
-  "launchCommand": "cursor"
-}
-```
+Previous versions stored config in `.opencode-worktree.json` files in each repository. These files are now ignored. Your settings will need to be reconfigured via the TUI (`c` key), which will save them to the new global config location.
 
 ## Update notifications
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worktree",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",

package/src/config.ts

@@ -1,79 +1,213 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
+import { getRepoKey } from "./git.js";
+import type { Config, GlobalConfig, LoadRepoConfigResult } from "./types.js";
 
-export type Config = {
-  postCreateHook?: string;
-  openCommand?: string; // Custom command to open worktree folder (e.g., "webstorm", "code")
-  launchCommand?: string; // Custom command to launch instead of opencode (e.g., "cursor", "claude")
+// Re-export Config type for backwards compatibility
+export type { Config } from "./types.js";
+
+const CONFIG_DIR = join(homedir(), ".config", "opencode-worktree");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+/**
+ * Get the path to the global config directory
+ */
+export const getGlobalConfigDir = (): string => {
+  return CONFIG_DIR;
 };
 
-const CONFIG_FILENAME = ".opencode-worktree.json";
+/**
+ * Get the path to the global config file
+ */
+export const getGlobalConfigPath = (): string => {
+  return CONFIG_FILE;
+};
 
 /**
- * Get the path to the config file for a repo
+ * Get the default configuration values
  */
-export const getConfigPath = (repoRoot: string): string => {
-  return join(repoRoot, CONFIG_FILENAME);
+export const getDefaultConfig = (): Config => {
+  return {
+    postCreateHook: "",
+    openCommand: "",
+    launchCommand: "opencode",
+  };
 };
 
 /**
- * Check if a config file exists for the repo
+ * Create an empty global config structure
  */
-export const configExists = (repoRoot: string): boolean => {
-  return existsSync(getConfigPath(repoRoot));
+const createEmptyGlobalConfig = (): GlobalConfig => {
+  return {
+    default: getDefaultConfig(),
+    repos: {},
+  };
 };
 
 /**
- * Load per-repo configuration from .opencode-worktree.json in the repo root
+ * Ensure the config directory exists
  */
-export const loadRepoConfig = (repoRoot: string): Config => {
-  const configPath = getConfigPath(repoRoot);
+const ensureConfigDir = (): boolean => {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
 
-  if (!existsSync(configPath)) {
-    return {};
+/**
+ * Load the entire global config file
+ */
+export const loadGlobalConfig = (): GlobalConfig => {
+  if (!existsSync(CONFIG_FILE)) {
+    return createEmptyGlobalConfig();
   }
 
   try {
-    const content = readFileSync(configPath, "utf8");
+    const content = readFileSync(CONFIG_FILE, "utf8");
     const parsed = JSON.parse(content);
 
-    // Validate the config structure
+    // Validate and normalize the config structure
     if (typeof parsed !== "object" || parsed === null) {
-      return {};
+      return createEmptyGlobalConfig();
     }
 
-    const config: Config = {};
+    const globalConfig: GlobalConfig = {
+      default: { ...getDefaultConfig() },
+      repos: {},
+    };
 
-    if (typeof parsed.postCreateHook === "string") {
-      config.postCreateHook = parsed.postCreateHook;
+    // Parse default config
+    if (typeof parsed.default === "object" && parsed.default !== null) {
+      if (typeof parsed.default.postCreateHook === "string") {
+        globalConfig.default.postCreateHook = parsed.default.postCreateHook;
+      }
+      if (typeof parsed.default.openCommand === "string") {
+        globalConfig.default.openCommand = parsed.default.openCommand;
+      }
+      if (typeof parsed.default.launchCommand === "string") {
+        globalConfig.default.launchCommand = parsed.default.launchCommand;
+      }
     }
 
-    if (typeof parsed.openCommand === "string") {
-      config.openCommand = parsed.openCommand;
-    }
+    // Parse repos config
+    if (typeof parsed.repos === "object" && parsed.repos !== null) {
+      for (const [key, value] of Object.entries(parsed.repos)) {
+        if (typeof value === "object" && value !== null) {
+          const repoConfig: Partial<Config> = {};
+          const v = value as Record<string, unknown>;
+
+          if (typeof v.postCreateHook === "string") {
+            repoConfig.postCreateHook = v.postCreateHook;
+          }
+          if (typeof v.openCommand === "string") {
+            repoConfig.openCommand = v.openCommand;
+          }
+          if (typeof v.launchCommand === "string") {
+            repoConfig.launchCommand = v.launchCommand;
+          }
 
-    if (typeof parsed.launchCommand === "string") {
-      config.launchCommand = parsed.launchCommand;
+          // Only add if there are actual values
+          if (Object.keys(repoConfig).length > 0) {
+            globalConfig.repos[key] = repoConfig;
+          }
+        }
+      }
     }
 
-    return config;
+    return globalConfig;
   } catch {
     // If we can't read or parse the config, return empty
-    return {};
+    return createEmptyGlobalConfig();
   }
 };
 
 /**
- * Save configuration to .opencode-worktree.json in the repo root
+ * Save the entire global config file
  */
-export const saveRepoConfig = (repoRoot: string, config: Config): boolean => {
-  const configPath = getConfigPath(repoRoot);
+export const saveGlobalConfig = (config: GlobalConfig): boolean => {
+  if (!ensureConfigDir()) {
+    return false;
+  }
 
   try {
     const content = JSON.stringify(config, null, 2) + "\n";
-    writeFileSync(configPath, content, "utf8");
+    writeFileSync(CONFIG_FILE, content, "utf8");
     return true;
   } catch {
     return false;
   }
 };
+
+/**
+ * Load configuration for a specific repository
+ * Merges default config with repo-specific overrides
+ * Returns the config and the repo key (null if no remote)
+ */
+export const loadRepoConfig = (repoRoot: string): LoadRepoConfigResult => {
+  const repoKey = getRepoKey(repoRoot);
+  const globalConfig = loadGlobalConfig();
+
+  // Start with default config
+  const config: Config = { ...globalConfig.default };
+
+  // If we have a repo key, merge in repo-specific config
+  if (repoKey && globalConfig.repos[repoKey]) {
+    const repoConfig = globalConfig.repos[repoKey];
+
+    if (repoConfig.postCreateHook !== undefined) {
+      config.postCreateHook = repoConfig.postCreateHook;
+    }
+    if (repoConfig.openCommand !== undefined) {
+      config.openCommand = repoConfig.openCommand;
+    }
+    if (repoConfig.launchCommand !== undefined) {
+      config.launchCommand = repoConfig.launchCommand;
+    }
+  }
+
+  return { config, repoKey };
+};
+
+/**
+ * Save configuration for a specific repository
+ * Only saves values that differ from the default
+ * Returns false if there's no remote (can't save repo-specific config)
+ */
+export const saveRepoConfig = (repoRoot: string, config: Config): boolean => {
+  const repoKey = getRepoKey(repoRoot);
+
+  if (!repoKey) {
+    // No remote - can't save repo-specific config
+    return false;
+  }
+
+  const globalConfig = loadGlobalConfig();
+
+  // Calculate which values differ from default
+  const repoConfig: Partial<Config> = {};
+
+  if (config.postCreateHook !== globalConfig.default.postCreateHook) {
+    repoConfig.postCreateHook = config.postCreateHook;
+  }
+  if (config.openCommand !== globalConfig.default.openCommand) {
+    repoConfig.openCommand = config.openCommand;
+  }
+  if (config.launchCommand !== globalConfig.default.launchCommand) {
+    repoConfig.launchCommand = config.launchCommand;
+  }
+
+  // Update or remove the repo entry
+  if (Object.keys(repoConfig).length > 0) {
+    globalConfig.repos[repoKey] = repoConfig;
+  } else {
+    // All values match default, remove the entry
+    delete globalConfig.repos[repoKey];
+  }
+
+  return saveGlobalConfig(globalConfig);
+};

package/src/git.ts

@@ -1,6 +1,71 @@
 import { execFileSync } from "node:child_process";
 import { WorktreeInfo } from "./types.js";
 
+/**
+ * Get the remote origin URL for a repository
+ */
+export const getRemoteOriginUrl = (repoRoot: string): string | null => {
+  try {
+    const output = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Normalize a git remote URL to a consistent key format
+ * Examples:
+ *   git@github.com:user/repo.git → github.com/user/repo
+ *   https://github.com/user/repo.git → github.com/user/repo
+ *   ssh://git@github.com/user/repo.git → github.com/user/repo
+ */
+export const normalizeRemoteUrl = (url: string): string => {
+  let normalized = url.trim();
+
+  // Remove .git suffix
+  if (normalized.endsWith(".git")) {
+    normalized = normalized.slice(0, -4);
+  }
+
+  // Handle SSH format: git@github.com:user/repo
+  const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+
+  // Handle SSH URL format: ssh://git@github.com/user/repo
+  const sshUrlMatch = normalized.match(/^ssh:\/\/git@([^/]+)\/(.+)$/);
+  if (sshUrlMatch) {
+    return `${sshUrlMatch[1]}/${sshUrlMatch[2]}`;
+  }
+
+  // Handle HTTPS format: https://github.com/user/repo
+  const httpsMatch = normalized.match(/^https?:\/\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+
+  // Fallback: return as-is (shouldn't happen for valid URLs)
+  return normalized;
+};
+
+/**
+ * Get the normalized repo key for a repository (for config lookup)
+ * Returns null if no remote origin is configured
+ */
+export const getRepoKey = (repoRoot: string): string | null => {
+  const remoteUrl = getRemoteOriginUrl(repoRoot);
+  if (!remoteUrl) {
+    return null;
+  }
+  return normalizeRemoteUrl(remoteUrl);
+};
+
 export const resolveRepoRoot = (cwd: string): string | null => {
   try {
     const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {
@@ -280,3 +345,69 @@ export const deleteWorktree = (
     return { success: false, error, step: "branch" };
   }
 };
+
+export type CreateBranchResult =
+  | { success: true }
+  | { success: false; error: string };
+
+/**
+ * Create a new branch from a specific commit
+ */
+export const createBranchFromCommit = (
+  repoRoot: string,
+  branchName: string,
+  commitHash: string,
+): CreateBranchResult => {
+  try {
+    execFileSync("git", ["branch", branchName, commitHash], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error };
+  }
+};
+
+export type CheckoutResult =
+  | { success: true }
+  | { success: false; error: string };
+
+/**
+ * Checkout a branch in a specific worktree
+ * Note: This changes the branch the worktree is tracking
+ */
+export const checkoutBranch = (
+  worktreePath: string,
+  branchName: string,
+): CheckoutResult => {
+  try {
+    execFileSync("git", ["checkout", branchName], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error };
+  }
+};
+
+/**
+ * Get the current HEAD commit hash for a worktree
+ */
+export const getHeadCommit = (worktreePath: string): string | null => {
+  try {
+    const output = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+};

package/src/types.ts

@@ -8,3 +8,29 @@ export type WorktreeInfo = {
   isOnRemote: boolean;
   lastModified: Date | null;
 };
+
+/**
+ * Per-repo configuration options
+ */
+export type Config = {
+  postCreateHook?: string;
+  openCommand?: string; // Custom command to open worktree folder (e.g., "webstorm", "code")
+  launchCommand?: string; // Custom command to launch instead of opencode (e.g., "cursor", "claude")
+};
+
+/**
+ * Global configuration structure stored at ~/.config/opencode-worktree/config.json
+ * Contains default settings and per-repo overrides keyed by normalized git remote URL
+ */
+export type GlobalConfig = {
+  default: Config;
+  repos: Record<string, Partial<Config>>;
+};
+
+/**
+ * Result of loading repo config, includes the repo key for display purposes
+ */
+export type LoadRepoConfigResult = {
+  config: Config;
+  repoKey: string | null; // null means no remote origin configured
+};

package/src/ui.ts

@@ -13,9 +13,12 @@ import {
 import { checkForUpdate } from "./update-check.js";
 import { basename } from "node:path";
 import {
+  checkoutBranch,
+  createBranchFromCommit,
   createWorktree,
   deleteWorktree,
   getDefaultWorktreesDir,
+  getHeadCommit,
   hasUncommittedChanges,
   isMainWorktree,
   listWorktrees,
@@ -24,7 +27,7 @@ import {
 } from "./git.js";
 import { isCommandAvailable, launchCommand, openInFileManager } from "./opencode.js";
 import { WorktreeInfo } from "./types.js";
-import { loadRepoConfig, saveRepoConfig, configExists, type Config } from "./config.js";
+import { loadRepoConfig, saveRepoConfig, type Config } from "./config.js";
 import { runPostCreateHook, type HookResult } from "./hooks.js";
 
 type StatusLevel = "info" | "warning" | "error" | "success";
@@ -106,7 +109,16 @@ class WorktreeSelector {
   private configOpenInput: InputRenderable | null = null;
   private configLaunchInput: InputRenderable | null = null;
   private configActiveField: "hook" | "open" | "launch" = "hook";
-  private isFirstTimeSetup = false;
+  private repoKey: string | null = null; // Normalized git remote URL for config lookup
+
+  // Branch creation state
+  private isCreatingBranch = false;
+  private branchCreateContainer: BoxRenderable | null = null;
+  private branchNameInput: InputRenderable | null = null;
+  private sourceWorktree: WorktreeInfo | null = null;
+  private pendingBranchName: string | null = null;
+  private isAskingCheckout = false;
+  private checkoutSelect: SelectRenderable | null = null;
 
   constructor(
     private renderer: CliRenderer,
@@ -115,7 +127,11 @@ class WorktreeSelector {
   ) {
     // Load worktrees first to get initial options
     this.repoRoot = resolveRepoRoot(this.targetPath);
-    this.repoConfig = this.repoRoot ? loadRepoConfig(this.repoRoot) : {};
+    if (this.repoRoot) {
+      const { config, repoKey } = loadRepoConfig(this.repoRoot);
+      this.repoConfig = config;
+      this.repoKey = repoKey;
+    }
     this.opencodeAvailable = isCommandAvailable(this.repoConfig.launchCommand || "opencode");
     this.worktreeOptions = this.buildInitialOptions();
 
@@ -195,7 +211,7 @@ class WorktreeSelector {
       left: 2,
       top: 20,
       content:
-        "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit",
+        "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit",
       fg: "#64748B",
     });
     this.renderer.root.add(this.instructions);
@@ -216,11 +232,6 @@ class WorktreeSelector {
     });
 
     this.selectElement.focus();
-
-    // Check for first-time setup
-    if (this.repoRoot && !configExists(this.repoRoot)) {
-      this.showFirstTimeSetup();
-    }
   }
 
   private getInitialStatusMessage(): string {
@@ -265,7 +276,7 @@ class WorktreeSelector {
         this.selectElement.visible = true;
         this.selectElement.focus();
         this.instructions.content =
-          "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+          "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
         return;
       }
       this.cleanup(true);
@@ -353,6 +364,24 @@ class WorktreeSelector {
       return;
     }
 
+    // Handle branch creation mode
+    if (this.isCreatingBranch) {
+      if (key.name === "escape") {
+        this.hideBranchCreateInput();
+        return;
+      }
+      return;
+    }
+
+    // Handle checkout confirmation mode
+    if (this.isAskingCheckout) {
+      if (key.name === "escape") {
+        this.hideCheckoutConfirm();
+        return;
+      }
+      return;
+    }
+
     if (key.name === "q" || key.name === "escape") {
       this.cleanup(true);
       return;
@@ -386,6 +415,12 @@ class WorktreeSelector {
       this.showConfigEditor();
       return;
     }
+
+    // 'b' for creating a new branch from selected worktree
+    if (key.name === "b") {
+      this.showBranchCreateInput();
+      return;
+    }
   }
 
   private handleSelection(value: SelectionValue): void {
@@ -412,9 +447,8 @@ class WorktreeSelector {
       return;
     }
 
-    // Load config to check for custom open command
-    const config = this.repoRoot ? loadRepoConfig(this.repoRoot) : {};
-    const customCommand = config.openCommand;
+    // Use the already-loaded config's openCommand
+    const customCommand = this.repoConfig.openCommand;
 
     const success = openInFileManager(worktree.path, customCommand);
     if (success) {
@@ -497,7 +531,7 @@ class WorktreeSelector {
 
     this.selectElement.visible = true;
     this.instructions.content =
-      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
     this.selectElement.focus();
     this.loadWorktrees(selectWorktreePath);
   }
@@ -523,11 +557,10 @@ class WorktreeSelector {
     if (result.success) {
       this.setStatus(`Worktree created at ${result.path}`, "success");
       
-      // Check for post-create hook
-      const config = loadRepoConfig(this.repoRoot);
-      if (config.postCreateHook) {
+      // Check for post-create hook (use already-loaded config)
+      if (this.repoConfig.postCreateHook) {
         this.pendingWorktreePath = result.path;
-        this.runHook(result.path, config.postCreateHook);
+        this.runHook(result.path, this.repoConfig.postCreateHook);
       } else {
         // No hook, launch command directly
         this.hideCreateWorktreeInput();
@@ -692,7 +725,7 @@ class WorktreeSelector {
       this.selectElement.visible = true;
       this.selectElement.focus();
       this.instructions.content =
-        "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+        "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
     }
   }
 
@@ -716,11 +749,6 @@ class WorktreeSelector {
 
   // ========== Config Editor Methods ==========
 
-  private showFirstTimeSetup(): void {
-    this.isFirstTimeSetup = true;
-    this.showConfigEditor();
-  }
-
   private showConfigEditor(): void {
     if (!this.repoRoot) {
       this.setStatus("No git repository found.", "error");
@@ -732,12 +760,18 @@ class WorktreeSelector {
     this.selectElement.visible = false;
     this.selectElement.blur();
 
-    // Load existing config to pre-fill
-    const existingConfig = loadRepoConfig(this.repoRoot);
-
-    const title = this.isFirstTimeSetup
-      ? "First-time Setup: Project Configuration"
-      : "Edit Project Configuration";
+    // Build title showing repo key
+    let title: string;
+    if (this.repoKey) {
+      // Truncate if too long for the box
+      const maxKeyLen = 50;
+      const displayKey = this.repoKey.length > maxKeyLen
+        ? "..." + this.repoKey.slice(-maxKeyLen + 3)
+        : this.repoKey;
+      title = `Config: ${displayKey}`;
+    } else {
+      title = "Config: [no remote]";
+    }
 
     this.configContainer = new BoxRenderable(this.renderer, {
       id: "config-container",
@@ -773,7 +807,7 @@ class WorktreeSelector {
       top: 2,
       width: 72,
       placeholder: "npm install",
-      value: existingConfig.postCreateHook || "",
+      value: this.repoConfig.postCreateHook || "",
       focusedBackgroundColor: "#1E293B",
       backgroundColor: "#1E293B",
     });
@@ -797,7 +831,7 @@ class WorktreeSelector {
       top: 5,
       width: 72,
       placeholder: "open (default)",
-      value: existingConfig.openCommand || "",
+      value: this.repoConfig.openCommand || "",
       focusedBackgroundColor: "#1E293B",
       backgroundColor: "#1E293B",
     });
@@ -821,30 +855,38 @@ class WorktreeSelector {
       top: 8,
       width: 72,
       placeholder: "opencode (default)",
-      value: existingConfig.launchCommand || "",
+      value: this.repoConfig.launchCommand || "",
       focusedBackgroundColor: "#1E293B",
       backgroundColor: "#1E293B",
     });
     this.configContainer.add(this.configLaunchInput);
 
-    // Help text
+    // Help text - show warning if no remote
+    let helpContent: string;
+    if (this.repoKey) {
+      helpContent = "Tab to switch fields • Leave empty to use defaults";
+    } else {
+      helpContent = "No remote - config won't be saved for this repo";
+    }
+
     const helpText = new TextRenderable(this.renderer, {
       id: "config-help",
       position: "absolute",
       left: 1,
       top: 10,
-      content: "Tab to switch fields • Leave empty to use defaults",
-      fg: "#64748B",
+      content: helpContent,
+      fg: this.repoKey ? "#64748B" : "#F59E0B",
     });
     this.configContainer.add(helpText);
 
     this.instructions.content = "Tab switch • Enter save • Esc cancel";
-    this.setStatus(
-      this.isFirstTimeSetup
-        ? "Welcome! Configure your project settings."
-        : "Edit project configuration.",
-      "info"
-    );
+    
+    // Show warning if no remote
+    if (this.repoKey) {
+      this.setStatus("Edit project configuration.", "info");
+    } else {
+      this.setStatus("Warning: No git remote. Config changes won't be saved.", "warning");
+    }
 
     // Delay focus to prevent the triggering keypress from being captured
     setTimeout(() => {
@@ -855,7 +897,6 @@ class WorktreeSelector {
 
   private hideConfigEditor(): void {
     this.isEditingConfig = false;
-    this.isFirstTimeSetup = false;
 
     if (this.configHookInput) {
       this.configHookInput.blur();
@@ -877,7 +918,7 @@ class WorktreeSelector {
 
     this.selectElement.visible = true;
     this.instructions.content =
-      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
     
     // Delay focus to prevent the Enter keypress from triggering a selection
     setTimeout(() => {
@@ -935,6 +976,279 @@ class WorktreeSelector {
     this.hideConfigEditor();
   }
 
+  // ========== Branch Creation Methods ==========
+
+  private showBranchCreateInput(): void {
+    const worktree = this.getSelectedWorktree();
+    if (!worktree) {
+      this.setStatus("Select a worktree to create a branch from.", "warning");
+      return;
+    }
+
+    if (!this.repoRoot) {
+      this.setStatus("No git repository found.", "error");
+      return;
+    }
+
+    this.isCreatingBranch = true;
+    this.sourceWorktree = worktree;
+    this.selectElement.visible = false;
+    this.selectElement.blur();
+
+    const sourceName = worktree.branch || basename(worktree.path);
+
+    this.branchCreateContainer = new BoxRenderable(this.renderer, {
+      id: "branch-create-container",
+      position: "absolute",
+      left: 2,
+      top: 3,
+      width: 76,
+      height: 7,
+      borderStyle: "single",
+      borderColor: "#38BDF8",
+      title: `New Branch from: ${sourceName}`,
+      titleAlignment: "center",
+      backgroundColor: "#0F172A",
+      border: true,
+    });
+    this.renderer.root.add(this.branchCreateContainer);
+
+    const inputLabel = new TextRenderable(this.renderer, {
+      id: "branch-name-label",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      content: "Branch name:",
+      fg: "#E2E8F0",
+    });
+    this.branchCreateContainer.add(inputLabel);
+
+    this.branchNameInput = new InputRenderable(this.renderer, {
+      id: "branch-name-input",
+      position: "absolute",
+      left: 14,
+      top: 1,
+      width: 58,
+      placeholder: "feature/new-branch",
+      focusedBackgroundColor: "#1E293B",
+      backgroundColor: "#1E293B",
+    });
+    this.branchCreateContainer.add(this.branchNameInput);
+
+    const helpText = new TextRenderable(this.renderer, {
+      id: "branch-create-help",
+      position: "absolute",
+      left: 1,
+      top: 3,
+      content: `Branch will start from commit: ${worktree.head.slice(0, 8)}`,
+      fg: "#64748B",
+    });
+    this.branchCreateContainer.add(helpText);
+
+    this.branchNameInput.on(InputRenderableEvents.CHANGE, (value: string) => {
+      this.handleBranchCreate(value);
+    });
+
+    this.instructions.content = "Enter to create • Esc to cancel";
+    this.setStatus("Enter a name for the new branch.", "info");
+
+    this.branchNameInput.focus();
+    this.renderer.requestRender();
+  }
+
+  private hideBranchCreateInput(): void {
+    this.isCreatingBranch = false;
+    this.sourceWorktree = null;
+
+    if (this.branchNameInput) {
+      this.branchNameInput.blur();
+    }
+
+    if (this.branchCreateContainer) {
+      this.renderer.root.remove(this.branchCreateContainer.id);
+      this.branchCreateContainer = null;
+      this.branchNameInput = null;
+    }
+
+    this.selectElement.visible = true;
+    this.instructions.content =
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
+    this.selectElement.focus();
+    this.renderer.requestRender();
+  }
+
+  private handleBranchCreate(branchName: string): void {
+    const trimmed = branchName.trim();
+    if (!trimmed) {
+      this.setStatus("Branch name cannot be empty.", "error");
+      return;
+    }
+
+    if (!this.repoRoot || !this.sourceWorktree) {
+      this.setStatus("No source worktree selected.", "error");
+      return;
+    }
+
+    const commitHash = this.sourceWorktree.head;
+    if (!commitHash) {
+      this.setStatus("Could not determine source commit.", "error");
+      return;
+    }
+
+    this.setStatus(`Creating branch '${trimmed}'...`, "info");
+    this.renderer.requestRender();
+
+    const result = createBranchFromCommit(this.repoRoot, trimmed, commitHash);
+
+    if (result.success) {
+      this.pendingBranchName = trimmed;
+      // Hide the input and show checkout confirmation
+      if (this.branchNameInput) {
+        this.branchNameInput.blur();
+      }
+      if (this.branchCreateContainer) {
+        this.renderer.root.remove(this.branchCreateContainer.id);
+        this.branchCreateContainer = null;
+        this.branchNameInput = null;
+      }
+      this.isCreatingBranch = false;
+      
+      this.showCheckoutConfirm(trimmed);
+    } else {
+      this.setStatus(`Failed to create branch: ${result.error}`, "error");
+    }
+  }
+
+  private showCheckoutConfirm(branchName: string): void {
+    if (!this.sourceWorktree) {
+      this.setStatus("No source worktree.", "error");
+      this.hideBranchCreateInput();
+      return;
+    }
+
+    this.isAskingCheckout = true;
+
+    const sourceName = this.sourceWorktree.branch || basename(this.sourceWorktree.path);
+
+    this.branchCreateContainer = new BoxRenderable(this.renderer, {
+      id: "checkout-confirm-container",
+      position: "absolute",
+      left: 2,
+      top: 3,
+      width: 76,
+      height: 8,
+      borderStyle: "single",
+      borderColor: "#10B981",
+      title: `Branch '${branchName}' Created`,
+      titleAlignment: "center",
+      backgroundColor: "#0F172A",
+      border: true,
+    });
+    this.renderer.root.add(this.branchCreateContainer);
+
+    const infoText = new TextRenderable(this.renderer, {
+      id: "checkout-info",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      content: `Checkout '${branchName}' in worktree '${sourceName}'?`,
+      fg: "#E2E8F0",
+    });
+    this.branchCreateContainer.add(infoText);
+
+    this.checkoutSelect = new SelectRenderable(this.renderer, {
+      id: "checkout-select",
+      position: "absolute",
+      left: 1,
+      top: 3,
+      width: 72,
+      height: 3,
+      options: [
+        {
+          name: "Yes, checkout the new branch",
+          description: "Switch this worktree to the new branch",
+          value: "checkout",
+        },
+        {
+          name: "No, keep current branch",
+          description: "Branch created but worktree stays on current branch",
+          value: "keep",
+        },
+      ],
+      backgroundColor: "#0F172A",
+      focusedBackgroundColor: "#1E293B",
+      selectedBackgroundColor: "#1E3A5F",
+      textColor: "#E2E8F0",
+      selectedTextColor: "#38BDF8",
+      descriptionColor: "#94A3B8",
+      selectedDescriptionColor: "#E2E8F0",
+      showDescription: true,
+      wrapSelection: true,
+    });
+    this.branchCreateContainer.add(this.checkoutSelect);
+
+    this.checkoutSelect.on(
+      SelectRenderableEvents.ITEM_SELECTED,
+      (_index: number, option: SelectOption) => {
+        this.handleCheckoutChoice(option.value as string);
+      }
+    );
+
+    this.instructions.content = "↑/↓ select • Enter confirm • Esc cancel";
+    this.setStatus(`Branch '${branchName}' created successfully!`, "success");
+
+    this.checkoutSelect.focus();
+    this.renderer.requestRender();
+  }
+
+  private hideCheckoutConfirm(): void {
+    this.isAskingCheckout = false;
+    this.pendingBranchName = null;
+    this.sourceWorktree = null;
+
+    if (this.checkoutSelect) {
+      this.checkoutSelect.blur();
+      this.checkoutSelect = null;
+    }
+
+    if (this.branchCreateContainer) {
+      this.renderer.root.remove(this.branchCreateContainer.id);
+      this.branchCreateContainer = null;
+    }
+
+    this.selectElement.visible = true;
+    this.instructions.content =
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
+    this.selectElement.focus();
+    this.loadWorktrees();
+    this.renderer.requestRender();
+  }
+
+  private handleCheckoutChoice(choice: string): void {
+    if (choice === "checkout" && this.pendingBranchName && this.sourceWorktree) {
+      this.setStatus(`Checking out '${this.pendingBranchName}'...`, "info");
+      this.renderer.requestRender();
+
+      const result = checkoutBranch(this.sourceWorktree.path, this.pendingBranchName);
+
+      if (result.success) {
+        this.setStatus(
+          `Switched to branch '${this.pendingBranchName}'.`,
+          "success"
+        );
+      } else {
+        this.setStatus(`Failed to checkout: ${result.error}`, "error");
+      }
+    } else {
+      this.setStatus(
+        `Branch '${this.pendingBranchName}' created (not checked out).`,
+        "success"
+      );
+    }
+
+    this.hideCheckoutConfirm();
+  }
+
   private loadWorktrees(selectWorktreePath?: string): void {
     this.repoRoot = resolveRepoRoot(this.targetPath);
     if (!this.repoRoot) {
@@ -1242,7 +1556,7 @@ class WorktreeSelector {
 
     this.selectElement.visible = true;
     this.instructions.content =
-      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
     this.selectElement.focus();
     this.loadWorktrees();
   }
@@ -1371,7 +1685,7 @@ class WorktreeSelector {
 
     this.loadWorktrees();
     this.instructions.content =
-      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • b branch • c config • q quit";
     this.renderer.requestRender();
   }