@zenobius/pi-worktrees 0.4.0-next.8 → 0.5.0

package/README.md

@@ -15,7 +15,8 @@ When you’re doing multiple feature branches, hotfixes, or experiments, `git wo
 
 `pi-worktrees` gives you a guided interface inside Pi:
 
-- Create feature worktrees with consistent branch naming (`feature/<name>`)
+- Create branch-first worktrees (`/worktree create <branch>`) with predictable naming
+- Optionally generate branch names via explicit opt-in (`/worktree create --generate ...`)
 - List and inspect active worktrees
 - Remove worktrees safely (with confirmations)
 - Prune stale worktree references
@@ -59,14 +60,15 @@ pi install npm:@zenobius/pi-worktrees
 
 ```text
 /worktree init
-/worktree create auth-refactor
+/worktree create feature/auth-refactor
+/worktree create hotfix/login-timeout --name login-timeout
 /worktree list
 ```
 
 3. Optional: jump into it from your shell using the printed path:
 
 ```text
-/worktree cd auth-refactor
+/worktree cd feature-auth-refactor
 ```
 
 ## Quick start
@@ -75,11 +77,12 @@ In Pi:
 
 ```text
 /worktree init
-/worktree create auth-refactor
+/worktree create feature/auth-refactor
+/worktree create spike/new-parser --name parser-spike
 /worktree list
 /worktree status
-/worktree cd auth-refactor
-/worktree remove auth-refactor
+/worktree cd feature-auth-refactor
+/worktree remove feature-auth-refactor
 /worktree prune
 ```
 
@@ -114,7 +117,7 @@ This creates a new Zellij tab with Neovim and Pi running in the new worktree pat
 | `/worktree settings` | Show all current settings |
 | `/worktree settings <key>` | Get one setting (`worktreeRoot`, `parentDir` alias, `onCreate`) |
 | `/worktree settings <key> <value>` | Set one setting |
-| `/worktree create <feature-name>` | Create a new worktree + branch `feature/<feature-name>` |
+| `/worktree create <branch> [--name <worktree-name>]`<br/>`/worktree create --generate [--name <worktree-name>] <prompt-or-name>` | Create a new worktree from `<branch>` (default mode) or generate one via configured `branchNameGenerator` (opt-in with `--generate`) |
 | `/worktree list` | List all worktrees (`/worktree ls` alias) |
 | `/worktree status` | Show current repo/worktree status |
 | `/worktree cd <name>` | Print matching worktree path |
@@ -133,11 +136,12 @@ Settings live in `~/.pi/agent/pi-worktrees-settings.json`.
   "worktrees": {
     "github.com/org/repo": {
       "worktreeRoot": "~/work/org/repo.worktrees",
-      "onCreate": ["mise install", "bun install"]
+      "onCreate": ["mise install", "bun install"],
     },
     "github.com/org/*": {
       "worktreeRoot": "~/work/org/shared.worktrees",
-      "onCreate": "mise setup"
+      "onCreate": "mise setup",
+      "branchNameGenerator": "pi -p \"branch name for $PI_WORKTREE_PROMPT\" --model local/model"
     }
   },
   "matchingStrategy": "fail-on-tie",
@@ -168,6 +172,7 @@ Settings live in `~/.pi/agent/pi-worktrees-settings.json`.
 | `onCreateCmdDisplayPendingColor` | `string` | `dim` | Pi theme color name for pending/running command lines. |
 | `onCreateCmdDisplaySuccessColor` | `string` | `success` | Pi theme color name for successful command lines. |
 | `onCreateCmdDisplayErrorColor` | `string` | `error` | Pi theme color name for failed command lines. |
+| `worktrees[*].branchNameGenerator` | `string` | unset | Optional command used only by `/worktree create --generate ...`. Must print exactly one branch name to stdout. Receives `$PI_WORKTREE_PROMPT` env var and supports `{{prompt}}` / `{prompt}` token replacement. |
 | `worktree` (legacy) | `WorktreeSettings` | n/a | Legacy fallback shape; migrated automatically. |
 
 ### Matching model
@@ -231,6 +236,63 @@ Where new worktrees are created.
 
 > Backward compatibility: `parentDir` is still accepted as a deprecated alias for `worktreeRoot`.
 > The extension will migrate existing `parentDir` values to `worktreeRoot` automatically.
+### Create command naming contract
+
+`/worktree create` is branch-first:
+
+- Required first argument is the **branch name** to create.
+- Default worktree folder name is `slugify(branch)`.
+- Optional `--name <worktree-name>` overrides the derived folder name.
+
+### Optional branch generator (safe opt-in)
+
+Generator mode is **never automatic**. You must pass `--generate` explicitly:
+
+```text
+/worktree create --generate login-flow
+/worktree create --generate --name ui-login login-flow
+```
+
+Safety behavior:
+- Branch-first remains default source of truth.
+- `branchNameGenerator` is ignored unless `--generate` is present.
+- Generator command runs with a strict 5s timeout.
+- On timeout, non-zero exit, empty stdout, or invalid branch output: command fails and no worktree is created.
+- When a generated branch is used, Pi emits a provenance message before creation.
+Examples:
+
+```text
+/worktree create feature/login
+# branch: feature/login, worktree folder: feature-login
+
+/worktree create feature/login --name ui-login
+# branch: feature/login, worktree folder: ui-login
+```
+
+### Migration from legacy `<feature-name>` usage
+
+Old mental model:
+
+```text
+/worktree create login
+# previously implied branch feature/login
+```
+
+Current behavior:
+
+```text
+/worktree create login
+# branch: login, worktree folder: login
+```
+
+To preserve old semantics explicitly:
+
+```text
+/worktree create feature/login --name login
+```
+
+Current releases emit a warning when legacy-style single tokens are detected without `--name`.
+
 ### Template variables
 
 Available in `worktreeRoot` and `onCreate` values:
@@ -290,14 +352,14 @@ This extension does not apply a separate ad-hoc deprecation mechanism.
   |                 v
   |             [Save settings] -----------------> [Idle]
   |
-  +--> [create <name>] --> [Validate repo/name/branch/path]
+  +--> [create <branch> [--name <worktree-name>]] --> [Validate repo/name/branch/path]
   |                           |fail
   |                           v
   |                         [Error] -------------> [Idle]
   |                           |
   |                          pass
   |                           v
-  |                    [git worktree add -b feature/<name>]
+  |                    [git worktree add -b <branch> <worktreePath>]
   |                           |fail
   |                           v
   |                         [Error] -------------> [Idle]
@@ -384,8 +446,8 @@ This extension does not apply a separate ad-hoc deprecation mechanism.
 ### `Not in a git repository`
 Run commands from inside a git repo (or one of its worktrees).
 
-### `Branch 'feature/<name>' already exists`
-Choose another feature name or delete/rename the branch.
+### `Branch '<branch>' already exists`
+Choose another branch name or delete/rename the existing branch.
 
 ### Can’t remove worktree due to changes
 Use `/worktree remove <name>`, then confirm the force remove prompt.

package/dist/cmds/cmdList.d.ts

@@ -1,2 +1,2 @@
-import { CmdHandler } from '../types.ts';
+import type { CmdHandler } from '../types.ts';
 export declare const cmdList: CmdHandler;

package/dist/cmds/cmdPrune.d.ts

@@ -1,2 +1,3 @@
 import type { ExtensionCommandContext } from '@mariozechner/pi-coding-agent';
-export declare function cmdPrune(_args: string, ctx: ExtensionCommandContext): Promise<void>;
+import type { CommandDeps } from '../types.ts';
+export declare function cmdPrune(_args: string, ctx: ExtensionCommandContext, deps: CommandDeps): Promise<void>;

package/dist/cmds/createArgs.d.ts

@@ -0,0 +1,21 @@
+interface CreateCommandArgsBase {
+    worktreeName: string;
+    explicitName: boolean;
+}
+export interface CreateCommandBranchArgs extends CreateCommandArgsBase {
+    generate: false;
+    branch: string;
+    showLegacyWarning: boolean;
+}
+export interface CreateCommandGenerateArgs extends CreateCommandArgsBase {
+    generate: true;
+    generatorInput: string;
+    showLegacyWarning: false;
+}
+export type CreateCommandArgs = CreateCommandBranchArgs | CreateCommandGenerateArgs;
+export interface CreateCommandArgError {
+    error: string;
+}
+export declare function slugifyBranch(branch: string): string;
+export declare function parseCreateCommandArgs(args: string): CreateCommandArgs | CreateCommandArgError;
+export {};

package/dist/cmds/shared.d.ts

@@ -19,8 +19,11 @@ export interface OnCreateHookOptions {
     cmdDisplaySuccessColor?: string;
     cmdDisplayErrorColor?: string;
 }
+export declare function sanitizePathPart(value: string): string;
+export declare function resolveLogfilePath(template: string, values: Record<'sessionId' | 'name' | 'timestamp', string>): string;
 /**
- * Runs post-create hooks sequentially.
+ * Runs hook commands sequentially.
  * Stops at first failure and reports the failing command.
  */
+export declare function runHook(createdCtx: WorktreeCreatedContext, hookValue: WorktreeSettingsConfig['onCreate'] | undefined, hookName: 'onCreate' | 'onSwitch' | 'onBeforeRemove', notify: (msg: string, type: 'info' | 'error' | 'warning') => void, options?: OnCreateHookOptions): Promise<OnCreateResult>;
 export declare function runOnCreateHook(createdCtx: WorktreeCreatedContext, settings: WorktreeSettingsConfig, notify: (msg: string, type: 'info' | 'error' | 'warning') => void, options?: OnCreateHookOptions): Promise<OnCreateResult>;

package/dist/index.js

@@ -24,11 +24,14 @@ import {
   Union,
   Integer as TypeInteger
 } from "typebox";
-var OnCreateSchema = Union([TypeString(), TypeArray(TypeString())]);
+var HookCommandsSchema = Union([TypeString(), TypeArray(TypeString())]);
 var WorktreeSettingsSchema = TypeObject({
   worktreeRoot: Optional(TypeString()),
   parentDir: Optional(TypeString()),
-  onCreate: Optional(OnCreateSchema)
+  onCreate: Optional(HookCommandsSchema),
+  onSwitch: Optional(HookCommandsSchema),
+  onBeforeRemove: Optional(HookCommandsSchema),
+  branchNameGenerator: Optional(TypeString())
 }, {
   $id: "WorktreeSettingsConfig",
   additionalProperties: false
@@ -73,7 +76,7 @@ function globToRegExp(pattern) {
   const doubleStarReplaced = escaped.replace(/\*\*/g, "::DOUBLE_STAR::");
   const singleStarReplaced = doubleStarReplaced.replace(/\*/g, "[^/]*");
   const regexBody = singleStarReplaced.replace(/::DOUBLE_STAR::/g, ".*");
-  return new RegExp(`^${regexBody}$`, "i");
+  return new RegExp(regexBody, "i");
 }
 function globMatch(input, pattern) {
   return globToRegExp(pattern).test(input);
@@ -340,11 +343,17 @@ async function cmdCd(args, ctx, deps) {
 }
 
 // src/cmds/cmdCreate.ts
-import { join as join3 } from "path";
+import { basename as basename3, join as join3 } from "path";
 
 // src/cmds/shared.ts
 import { appendFileSync as appendFileSync2, writeFileSync } from "fs";
 import { spawn } from "child_process";
+function sanitizePathPart(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+function resolveLogfilePath(template, values) {
+  return template.replace(/\{\{sessionId\}\}|\{sessionId\}/g, values.sessionId).replace(/\{\{name\}\}|\{name\}/g, values.name).replace(/\{\{timestamp\}\}|\{timestamp\}/g, values.timestamp);
+}
 var ANSI = {
   reset: "\x1B[0m",
   gray: "\x1B[90m",
@@ -411,8 +420,8 @@ function getDisplayLines(text, maxLines) {
   }
   return lines.slice(-maxLines);
 }
-function formatCommandList(commands, states, outputs, commandDisplay, logPath, displayOutputMaxLines = 5) {
-  const lines = ["onCreate steps:"];
+function formatCommandList(commands, states, outputs, commandDisplay, hookName, logPath, displayOutputMaxLines = 5) {
+  const lines = [`${hookName} steps:`];
   for (const [index, command] of commands.entries()) {
     const state = states[index];
     lines.push(formatCommandLine(command, state, commandDisplay));
@@ -483,18 +492,18 @@ function runCommand(command, cwd, onOutput) {
     });
   });
 }
-async function runOnCreateHook(createdCtx, settings, notify, options) {
-  if (!settings.onCreate) {
+async function runHook(createdCtx, hookValue, hookName, notify, options) {
+  if (!hookValue) {
     return { success: true, executed: [] };
   }
-  const commandTemplates = Array.isArray(settings.onCreate) ? settings.onCreate : [settings.onCreate];
+  const commandTemplates = Array.isArray(hookValue) ? hookValue : [hookValue];
   const commands = commandTemplates.map((template) => expandTemplate(template, createdCtx));
   const executed = [];
   const commandStates = commands.map(() => "pending");
   const commandOutputs = commands.map(() => ({ stdout: "", stderr: "" }));
   if (options?.logPath) {
     writeFileSync(options.logPath, [
-      `# pi-worktree onCreate log`,
+      `# pi-worktree ${hookName} log`,
       `# worktree: ${createdCtx.path}`,
       `# branch: ${createdCtx.branch}`,
       ""
@@ -510,13 +519,13 @@ async function runOnCreateHook(createdCtx, settings, notify, options) {
     successColor: options?.cmdDisplaySuccessColor ?? "success",
     errorColor: options?.cmdDisplayErrorColor ?? "error"
   };
-  notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, undefined, displayOutputMaxLines), "info");
+  notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, undefined, displayOutputMaxLines), "info");
   for (const [index, command] of commands.entries()) {
     commandStates[index] = "running";
-    notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, undefined, displayOutputMaxLines), "info");
+    notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, undefined, displayOutputMaxLines), "info");
     const result = await runCommand(command, createdCtx.path, (stream, chunk) => {
       commandOutputs[index][stream] += chunk;
-      notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, undefined, displayOutputMaxLines), "info");
+      notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, undefined, displayOutputMaxLines), "info");
     });
     if (options?.logPath) {
       appendCommandLog(options.logPath, command, result);
@@ -524,8 +533,8 @@ async function runOnCreateHook(createdCtx, settings, notify, options) {
     executed.push(command);
     if (!result.success) {
       commandStates[index] = "failed";
-      notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, options?.logPath, displayOutputMaxLines), "error");
-      notify(`onCreate failed (exit ${result.code}): ${result.stderr.slice(0, 200)}${options?.logPath ? `
+      notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, options?.logPath, displayOutputMaxLines), "error");
+      notify(`${hookName} failed (exit ${result.code}): ${result.stderr.slice(0, 200)}${options?.logPath ? `
 log: ${options.logPath}` : ""}`, "error");
       return {
         success: false,
@@ -538,11 +547,14 @@ log: ${options.logPath}` : ""}`, "error");
       };
     }
     commandStates[index] = "success";
-    notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, undefined, displayOutputMaxLines), "info");
+    notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, undefined, displayOutputMaxLines), "info");
   }
-  notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, options?.logPath, displayOutputMaxLines), "info");
+  notify(formatCommandList(commands, commandStates, commandOutputs, commandDisplay, hookName, options?.logPath, displayOutputMaxLines), "info");
   return { success: true, executed };
 }
+async function runOnCreateHook(createdCtx, settings, notify, options) {
+  return runHook(createdCtx, settings.onCreate, "onCreate", notify, options);
+}
 
 // src/services/config/config.ts
 import { createConfigService } from "@zenobius/pi-extension-config";
@@ -949,29 +961,297 @@ var DefaultWorktreeSettings = {
 };
 var DefaultLogfileTemplate = DEFAULT_LOGFILE_TEMPLATE;
 
-// src/cmds/cmdCreate.ts
-function sanitizePathPart(value) {
-  return value.replace(/[^a-zA-Z0-9._-]/g, "-");
+// src/cmds/createArgs.ts
+var SIMPLE_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+var BRANCH_FIRST_USAGE = "/worktree create <branch> [--name <worktree-name>]";
+var GENERATE_USAGE = "/worktree create --generate [--name <worktree-name>] <prompt-or-name>";
+var CREATE_USAGE = `Usage: ${BRANCH_FIRST_USAGE} OR ${GENERATE_USAGE}`;
+function slugifyBranch(branch) {
+  return branch.toLowerCase().replace(/[\s/_.]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
 }
-function resolveLogfilePath(template, values) {
-  return template.replace(/\{\{sessionId\}\}|\{sessionId\}/g, values.sessionId).replace(/\{\{name\}\}|\{name\}/g, values.name).replace(/\{\{timestamp\}\}|\{timestamp\}/g, values.timestamp);
+function isValidWorktreeName(name) {
+  return SIMPLE_NAME_PATTERN.test(name);
+}
+function isLegacyStyleToken(token) {
+  if (!token) {
+    return false;
+  }
+  if (token.includes("/")) {
+    return false;
+  }
+  return SIMPLE_NAME_PATTERN.test(token);
+}
+function parseCreateCommandArgs(args) {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) {
+    return { error: CREATE_USAGE };
+  }
+  let explicitName;
+  let useGenerator = false;
+  const positional = [];
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--name") {
+      if (explicitName) {
+        return { error: "Duplicate --name option. Provide it only once." };
+      }
+      const value = tokens[index + 1];
+      if (!value || value.startsWith("--")) {
+        return {
+          error: `Missing value for --name. ${CREATE_USAGE}`
+        };
+      }
+      explicitName = value;
+      index += 1;
+      continue;
+    }
+    if (token === "--generate") {
+      if (useGenerator) {
+        return { error: "Duplicate --generate option. Provide it only once." };
+      }
+      useGenerator = true;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      return {
+        error: `Unknown argument: ${token}. ${CREATE_USAGE}`
+      };
+    }
+    positional.push(token);
+  }
+  if (positional.length !== 1) {
+    return {
+      error: `Expected exactly one ${useGenerator ? "<prompt-or-name>" : "<branch>"}. ${CREATE_USAGE}`
+    };
+  }
+  if (explicitName && !isValidWorktreeName(explicitName)) {
+    return {
+      error: "Invalid worktree name for --name. Use only letters, numbers, '.', '_' or '-' (no '/')."
+    };
+  }
+  const sourceToken = positional[0];
+  const derivedName = slugifyBranch(sourceToken);
+  if (!explicitName && !derivedName) {
+    return {
+      error: "Derived worktree name is empty after slugify. Use a source with letters/numbers or pass --name <worktree-name>."
+    };
+  }
+  if (useGenerator) {
+    return {
+      generate: true,
+      generatorInput: sourceToken,
+      worktreeName: explicitName ?? derivedName,
+      explicitName: Boolean(explicitName),
+      showLegacyWarning: false
+    };
+  }
+  return {
+    generate: false,
+    branch: sourceToken,
+    worktreeName: explicitName ?? derivedName,
+    explicitName: Boolean(explicitName),
+    showLegacyWarning: !explicitName && isLegacyStyleToken(sourceToken)
+  };
+}
+
+// src/services/branchNameGenerator.ts
+import { spawn as spawn2 } from "child_process";
+var BRANCH_NAME_GENERATOR_TIMEOUT_MS = 5000;
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function renderCommand(template, input) {
+  const quotedInput = shellQuote(input);
+  return template.replace(/\{\{prompt\}\}|\{prompt\}/g, quotedInput);
+}
+async function validateBranchName(branchName, cwd) {
+  const checker = spawn2("git", ["check-ref-format", "--branch", branchName], {
+    cwd,
+    shell: false,
+    stdio: "ignore"
+  });
+  return new Promise((resolve2) => {
+    checker.on("close", (code) => resolve2(code === 0));
+    checker.on("error", () => resolve2(false));
+  });
+}
+async function generateBranchName(params) {
+  const timeoutMs = params.timeoutMs ?? BRANCH_NAME_GENERATOR_TIMEOUT_MS;
+  if (!params.commandTemplate?.trim()) {
+    return {
+      ok: false,
+      code: "missing-config",
+      message: "No branchNameGenerator configured for this repository. Set worktrees.<pattern>.branchNameGenerator or run '/worktree create <branch>' without --generate."
+    };
+  }
+  const command = renderCommand(params.commandTemplate, params.input);
+  const result = await new Promise((resolve2) => {
+    const child = spawn2(command, {
+      cwd: params.cwd,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PI_WORKTREE_PROMPT: params.input
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+    const timer = globalThis.setTimeout(() => {
+      if (done) {
+        return;
+      }
+      done = true;
+      child.kill("SIGKILL");
+      resolve2({ kind: "timeout" });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      globalThis.clearTimeout(timer);
+      resolve2({ kind: "spawn-error", error: error.message });
+    });
+    child.on("close", (code) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      globalThis.clearTimeout(timer);
+      resolve2({ kind: "success", stdout, stderr, code: code ?? 1 });
+    });
+  });
+  if (result.kind === "timeout") {
+    return {
+      ok: false,
+      code: "timeout",
+      message: `branchNameGenerator timed out after ${timeoutMs}ms. Make it faster or run '/worktree create <branch>' manually.`
+    };
+  }
+  if (result.kind === "spawn-error") {
+    return {
+      ok: false,
+      code: "spawn-error",
+      message: `Failed to run branchNameGenerator command: ${result.error}`
+    };
+  }
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    return {
+      ok: false,
+      code: "non-zero-exit",
+      message: `branchNameGenerator exited with code ${result.code}.${stderr ? ` stderr: ${stderr}` : ""}`
+    };
+  }
+  const branchName = result.stdout.trim();
+  if (!branchName) {
+    return {
+      ok: false,
+      code: "empty-output",
+      message: "branchNameGenerator produced empty output. Ensure the command prints exactly one branch name to stdout."
+    };
+  }
+  const valid = await validateBranchName(branchName, params.cwd);
+  if (!valid) {
+    return {
+      ok: false,
+      code: "invalid-output",
+      message: `branchNameGenerator output is not a valid branch name: '${branchName}'. Fix the command output or run '/worktree create <branch>' manually.`
+    };
+  }
+  return {
+    ok: true,
+    branchName,
+    command: params.commandTemplate
+  };
+}
+
+// src/cmds/cmdCreate.ts
 async function cmdCreate(args, ctx, deps) {
-  const featureName = args.trim();
-  if (!featureName) {
-    ctx.ui.notify("Usage: /worktree create <feature-name>", "error");
+  const parsed = parseCreateCommandArgs(args);
+  if ("error" in parsed) {
+    ctx.ui.notify(parsed.error, "error");
     return;
   }
+  const worktreeName = parsed.worktreeName;
   if (!isGitRepo(ctx.cwd)) {
     ctx.ui.notify("Not in a git repository", "error");
     return;
   }
   const current = deps.configService.current(ctx);
-  const worktreePath = join3(current.parentDir, featureName);
-  const branchName = `feature/${featureName}`;
-  const existing = listWorktrees(ctx.cwd);
-  if (existing.some((worktree) => worktree.path === worktreePath)) {
-    ctx.ui.notify(`Worktree already exists at: ${worktreePath}`, "error");
+  let branchName = parsed.generate ? "" : parsed.branch;
+  if (parsed.generate) {
+    const generated = await generateBranchName({
+      commandTemplate: current.branchNameGenerator,
+      input: parsed.generatorInput,
+      cwd: ctx.cwd
+    });
+    if (!generated.ok) {
+      ctx.ui.notify(generated.message, "error");
+      return;
+    }
+    branchName = generated.branchName;
+    ctx.ui.notify(`Using generated branch '${branchName}' from branchNameGenerator (input: '${parsed.generatorInput}').`, "info");
+  }
+  if (!parsed.generate && parsed.showLegacyWarning) {
+    ctx.ui.notify(`Legacy create style detected: '/worktree create <feature-name>' is deprecated. '${branchName}' is now treated as the branch name. If you want old semantics, run '/worktree create feature/${branchName}' (optionally '--name ${branchName}').`, "warning");
+  }
+  const worktreePath = join3(current.parentDir, worktreeName);
+  const existingWorktree = listWorktrees(ctx.cwd).find((worktree) => worktree.path === worktreePath || basename3(worktree.path) === worktreeName || worktree.branch === branchName);
+  if (existingWorktree) {
+    if (!ctx.hasUI) {
+      ctx.ui.notify(`Worktree already exists at: ${worktreePath}`, "error");
+      return;
+    }
+    const confirmMessage = current.onSwitch ? `Path: ${existingWorktree.path}
+Branch: ${existingWorktree.branch}
+
+Switch to this worktree and run onSwitch?` : `Path: ${existingWorktree.path}
+Branch: ${existingWorktree.branch}
+
+Switch to this worktree?`;
+    const shouldSwitch = await ctx.ui.confirm("Worktree already exists", confirmMessage);
+    if (!shouldSwitch) {
+      ctx.ui.notify("Cancelled", "info");
+      return;
+    }
+    const existingCtx = {
+      path: existingWorktree.path,
+      name: basename3(existingWorktree.path),
+      branch: existingWorktree.branch,
+      ...current
+    };
+    const sessionId2 = sanitizePathPart(ctx.sessionManager?.getSessionId?.() || "session");
+    const safeName2 = sanitizePathPart(existingCtx.name);
+    const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
+    const logPath2 = resolveLogfilePath(current.logfile ?? DefaultLogfileTemplate, {
+      sessionId: sessionId2,
+      name: safeName2,
+      timestamp: timestamp2
+    });
+    const result = await runHook(existingCtx, current.onSwitch, "onSwitch", ctx.ui.notify.bind(ctx.ui), {
+      logPath: logPath2,
+      displayOutputMaxLines: current.onCreateDisplayOutputMaxLines,
+      cmdDisplayPending: current.onCreateCmdDisplayPending,
+      cmdDisplaySuccess: current.onCreateCmdDisplaySuccess,
+      cmdDisplayError: current.onCreateCmdDisplayError,
+      cmdDisplayPendingColor: current.onCreateCmdDisplayPendingColor,
+      cmdDisplaySuccessColor: current.onCreateCmdDisplaySuccessColor,
+      cmdDisplayErrorColor: current.onCreateCmdDisplayErrorColor
+    });
+    if (!result.success) {
+      ctx.ui.notify("onSwitch failed", "error");
+      return;
+    }
+    ctx.ui.notify(`Worktree path: ${existingWorktree.path}`, "info");
     return;
   }
   try {
@@ -980,21 +1260,25 @@ async function cmdCreate(args, ctx, deps) {
     return;
   } catch {}
   ensureExcluded(ctx.cwd, current.parentDir);
-  ctx.ui.notify(`Creating worktree: ${featureName}`, "info");
+  const stopBusy = deps.statusService.busy(ctx, `Creating worktree: ${worktreeName}...`);
   try {
     git(["worktree", "add", "-b", branchName, worktreePath], current.mainWorktree);
+    stopBusy();
+    deps.statusService.positive(ctx, `Created: ${worktreeName}`);
   } catch (err) {
+    stopBusy();
+    deps.statusService.critical(ctx, `Failed to create worktree`);
     ctx.ui.notify(`Failed to create worktree: ${err.message}`, "error");
     return;
   }
   const createdCtx = {
     path: worktreePath,
-    name: featureName,
+    name: worktreeName,
     branch: branchName,
     ...current
   };
   const sessionId = sanitizePathPart(ctx.sessionManager?.getSessionId?.() || "session");
-  const safeName = sanitizePathPart(featureName);
+  const safeName = sanitizePathPart(worktreeName);
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const logPath = resolveLogfilePath(current.logfile ?? DefaultLogfileTemplate, {
     sessionId,
@@ -1100,6 +1384,12 @@ ${finalConfig}`, "info");
 }
 
 // src/cmds/cmdList.ts
+import { basename as basename4 } from "path";
+function formatWorktreeOption(worktree) {
+  const markers = [worktree.isMain ? "[main]" : "", worktree.isCurrent ? "[current]" : ""].filter(Boolean).join(" ");
+  return `${worktree.branch}${markers ? " " + markers : ""}
+  ${worktree.path}`;
+}
 var cmdList = async (_args, ctx, deps) => {
   if (!isGitRepo(ctx.cwd)) {
     ctx.ui.notify("Not in a git repository", "error");
@@ -1110,17 +1400,18 @@ var cmdList = async (_args, ctx, deps) => {
     ctx.ui.notify("No worktrees found", "info");
     return;
   }
-  const lines = worktrees.map((worktree) => {
-    const markers = [worktree.isMain ? "[main]" : "", worktree.isCurrent ? "[current]" : ""].filter(Boolean).join(" ");
-    return `${worktree.branch}${markers ? " " + markers : ""}
+  if (!ctx.hasUI) {
+    const lines = worktrees.map((worktree) => {
+      const markers = [worktree.isMain ? "[main]" : "", worktree.isCurrent ? "[current]" : ""].filter(Boolean).join(" ");
+      return `${worktree.branch}${markers ? " " + markers : ""}
     ${worktree.path}`;
-  });
-  const configured = Array.from(deps.configService.worktrees.entries()).map(([pattern, settings]) => {
-    return `${pattern}
+    });
+    const configured = Array.from(deps.configService.worktrees.entries()).map(([pattern, settings]) => {
+      return `${pattern}
     ${settings.worktreeRoot ?? settings.parentDir}
     ${settings.onCreate}`;
-  });
-  ctx.ui.notify(`Worktrees:
+    });
+    ctx.ui.notify(`Worktrees:
 
 ${lines.join(`
 
@@ -1131,10 +1422,69 @@ Configured:
 ${configured.join(`
 
 `)}`, "info");
+    return;
+  }
+  const options = worktrees.map(formatWorktreeOption);
+  const byOption = new Map(options.map((option, index) => [option, worktrees[index]]));
+  const selected = await ctx.ui.select("Select worktree to switch to", options);
+  if (selected === undefined) {
+    ctx.ui.notify("Cancelled", "info");
+    return;
+  }
+  const target = byOption.get(selected);
+  if (!target) {
+    ctx.ui.notify("Invalid selection", "error");
+    return;
+  }
+  const current = deps.configService.current({ cwd: target.path });
+  if (!current.onSwitch) {
+    ctx.ui.notify(`No onSwitch configured for: ${target.path}`, "info");
+    return;
+  }
+  const sessionId = sanitizePathPart(ctx.sessionManager?.getSessionId?.() || "session");
+  const safeName = sanitizePathPart(basename4(target.path));
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const logPath = resolveLogfilePath(current.logfile ?? DefaultLogfileTemplate, {
+    sessionId,
+    name: safeName,
+    timestamp
+  });
+  const createdCtx = {
+    path: target.path,
+    name: basename4(target.path),
+    branch: target.branch,
+    project: current.project,
+    mainWorktree: current.mainWorktree
+  };
+  const stopBusy = deps.statusService.busy(ctx, `Running onSwitch for ${target.branch}...`);
+  try {
+    const result = await runHook(createdCtx, current.onSwitch, "onSwitch", ctx.ui.notify.bind(ctx.ui), {
+      logPath,
+      displayOutputMaxLines: current.onCreateDisplayOutputMaxLines,
+      cmdDisplayPending: current.onCreateCmdDisplayPending,
+      cmdDisplaySuccess: current.onCreateCmdDisplaySuccess,
+      cmdDisplayError: current.onCreateCmdDisplayError,
+      cmdDisplayPendingColor: current.onCreateCmdDisplayPendingColor,
+      cmdDisplaySuccessColor: current.onCreateCmdDisplaySuccessColor,
+      cmdDisplayErrorColor: current.onCreateCmdDisplayErrorColor
+    });
+    if (!result.success) {
+      stopBusy();
+      deps.statusService.critical(ctx, `onSwitch failed`);
+      ctx.ui.notify(`onSwitch failed`, "error");
+      return;
+    }
+    stopBusy();
+    deps.statusService.positive(ctx, `onSwitch complete: ${target.branch}`);
+  } catch (err) {
+    stopBusy();
+    deps.statusService.critical(ctx, `onSwitch failed`);
+    ctx.ui.notify(`onSwitch failed: ${err.message}`, "error");
+  }
 };
 
 // src/cmds/cmdPrune.ts
-async function cmdPrune(_args, ctx) {
+async function cmdPrune(_args, ctx, deps) {
   if (!isGitRepo(ctx.cwd)) {
     ctx.ui.notify("Not in a git repository", "error");
     return;
@@ -1157,18 +1507,23 @@ ${dryRun}`);
     ctx.ui.notify("Cancelled", "info");
     return;
   }
+  const stopBusy = deps.statusService.busy(ctx, "Pruning stale worktrees...");
   try {
     git(["worktree", "prune"], ctx.cwd);
+    stopBusy();
+    deps.statusService.positive(ctx, "Pruned stale references");
     ctx.ui.notify("\u2713 Stale worktree references pruned", "info");
   } catch (err) {
+    stopBusy();
+    deps.statusService.critical(ctx, "Failed to prune");
     ctx.ui.notify(`Failed to prune: ${err.message}`, "error");
   }
 }
 
 // src/cmds/cmdRemove.ts
-import { basename as basename3, join as join4 } from "path";
+import { basename as basename5, join as join4 } from "path";
 function findTarget(worktrees, worktreeName, parentDir) {
-  return worktrees.find((worktree) => basename3(worktree.path) === worktreeName || worktree.path === worktreeName || worktree.path === join4(parentDir, worktreeName));
+  return worktrees.find((worktree) => basename5(worktree.path) === worktreeName || worktree.path === worktreeName || worktree.path === join4(parentDir, worktreeName));
 }
 function isProtectedWorktree(worktree) {
   return worktree.isMain || worktree.isCurrent;
@@ -1179,7 +1534,7 @@ async function pickWorktreeInteractively(ctx, worktrees) {
     ctx.ui.notify("No removable worktrees found", "info");
     return;
   }
-  const options = candidates.map((worktree) => `${basename3(worktree.path)} (${worktree.branch})
+  const options = candidates.map((worktree) => `${basename5(worktree.path)} (${worktree.branch})
   ${worktree.path}`);
   const byOption = new Map(options.map((option, index) => [option, candidates[index]]));
   const selected = await ctx.ui.select("Select worktree to remove", options);
@@ -1189,7 +1544,7 @@ async function pickWorktreeInteractively(ctx, worktrees) {
   }
   return byOption.get(selected);
 }
-async function removeWorktreeWithConfirm(ctx, cwd, target) {
+async function removeWorktreeWithConfirm(ctx, cwd, target, status, runBeforeRemove) {
   const confirmed = await ctx.ui.confirm("Remove worktree?", `This will remove:
   Path: ${target.path}
   Branch: ${target.branch}
@@ -1199,19 +1554,34 @@ The branch will NOT be deleted.`);
     ctx.ui.notify("Cancelled", "info");
     return;
   }
+  if (runBeforeRemove) {
+    const canContinue = await runBeforeRemove();
+    if (!canContinue) {
+      return;
+    }
+  }
+  const stopBusy = status.busy(ctx, "Removing worktree...");
   try {
     git(["worktree", "remove", target.path], cwd);
+    stopBusy();
+    status.positive(ctx, `Removed: ${target.path}`);
     ctx.ui.notify(`\u2713 Worktree removed: ${target.path}`, "info");
   } catch {
+    stopBusy();
     const forceConfirmed = await ctx.ui.confirm("Force remove?", "Worktree has uncommitted changes. Force remove anyway?");
     if (!forceConfirmed) {
       ctx.ui.notify("Cancelled", "info");
       return;
     }
+    const stopForceBusy = status.busy(ctx, "Force removing worktree...");
     try {
       git(["worktree", "remove", "--force", target.path], cwd);
+      stopForceBusy();
+      status.positive(ctx, `Force removed: ${target.path}`);
       ctx.ui.notify(`\u2713 Worktree force removed: ${target.path}`, "info");
     } catch (forceErr) {
+      stopForceBusy();
+      status.critical(ctx, `Failed to remove`);
       ctx.ui.notify(`Failed to remove: ${forceErr.message}`, "error");
     }
   }
@@ -1249,7 +1619,38 @@ async function cmdRemove(args, ctx, deps) {
       return;
     }
   }
-  await removeWorktreeWithConfirm(ctx, ctx.cwd, target);
+  const current = deps.configService.current({ cwd: target.path });
+  await removeWorktreeWithConfirm(ctx, ctx.cwd, target, deps.statusService, async () => {
+    if (!current.onBeforeRemove) {
+      return true;
+    }
+    const hookCtx = {
+      path: target.path,
+      name: basename5(target.path),
+      branch: target.branch,
+      project: current.project,
+      mainWorktree: current.mainWorktree
+    };
+    const sessionId = sanitizePathPart(ctx.sessionManager?.getSessionId?.() || "session");
+    const safeName = sanitizePathPart(hookCtx.name);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const logPath = resolveLogfilePath(current.logfile ?? DefaultLogfileTemplate, {
+      sessionId,
+      name: safeName,
+      timestamp
+    });
+    const result = await runHook(hookCtx, current.onBeforeRemove, "onBeforeRemove", ctx.ui.notify.bind(ctx.ui), {
+      logPath,
+      displayOutputMaxLines: current.onCreateDisplayOutputMaxLines,
+      cmdDisplayPending: current.onCreateCmdDisplayPending,
+      cmdDisplaySuccess: current.onCreateCmdDisplaySuccess,
+      cmdDisplayError: current.onCreateCmdDisplayError,
+      cmdDisplayPendingColor: current.onCreateCmdDisplayPendingColor,
+      cmdDisplaySuccessColor: current.onCreateCmdDisplaySuccessColor,
+      cmdDisplayErrorColor: current.onCreateCmdDisplayErrorColor
+    });
+    return result.success;
+  });
 }
 
 // src/cmds/cmdSettings.ts
@@ -1444,6 +1845,74 @@ function createCompletionFactory(commands) {
   };
 }
 
+// src/ui/status.ts
+class StatusIndicator {
+  statusKey;
+  busyStyle;
+  busyFrames;
+  progressStyle = "bars";
+  progressFrames;
+  constructor(statusKey, options = {
+    busy: "dots",
+    progress: "bars"
+  }) {
+    this.statusKey = statusKey;
+    this.busyStyle = options.busy || "dots";
+    this.busyFrames = StatusIndicator.busyStyles[this.busyStyle];
+    this.progressStyle = options.progress || "bars";
+    this.progressFrames = StatusIndicator.progressStyles[this.progressStyle];
+  }
+  busy(ctx, message) {
+    if (typeof ctx.ui.setStatus !== "function") {
+      return () => {};
+    }
+    let i = 0;
+    ctx.ui.setStatus(this.statusKey, `${this.busyFrames[i]} ${message}`);
+    const timer = globalThis.setInterval(() => {
+      i = (i + 1) % this.busyFrames.length;
+      ctx.ui.setStatus?.(this.statusKey, `${this.busyFrames[i]} ${message}`);
+    }, 100);
+    return () => {
+      globalThis.clearInterval(timer);
+      ctx.ui.setStatus?.(this.statusKey, undefined);
+    };
+  }
+  cautious(ctx, message) {
+    ctx.ui.setStatus?.(this.statusKey, `\u26A0\uFE0F ${message}`);
+  }
+  critical(ctx, message) {
+    ctx.ui.setStatus?.(this.statusKey, `\u274C ${message}`);
+  }
+  positive(ctx, message) {
+    ctx.ui.setStatus?.(this.statusKey, `\u2705 ${message}`);
+  }
+  informative(ctx, message) {
+    ctx.ui.setStatus?.(this.statusKey, `\u2139\uFE0F ${message}`);
+  }
+  progress(ctx, message, percent) {
+    const progressBar = this.progressFrames(percent);
+    ctx.ui.setStatus?.(this.statusKey, `${progressBar} ${message}`);
+  }
+  static busyStyles = {
+    dots: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+  };
+  static progressStyles = {
+    bars: (percent) => {
+      const clampedPercent = Math.max(0, Math.min(100, percent));
+      const progressBarLength = 20;
+      const filledLength = Math.round(clampedPercent / 100 * progressBarLength);
+      const emptyLength = progressBarLength - filledLength;
+      return "\u2588".repeat(filledLength) + "\u2591".repeat(emptyLength);
+    },
+    pie: (percent) => {
+      const clampedPercent = Math.max(0, Math.min(100, percent));
+      const pieFrames = ["\u25CB", "\u25D4", "\u25D1", "\u25D5", "\u25CF"];
+      const frameIndex = Math.floor(clampedPercent / 100 * (pieFrames.length - 1));
+      return pieFrames[frameIndex];
+    }
+  };
+}
+
 // src/index.ts
 var HELP_TEXT = `
 /worktree - Git worktree management
@@ -1451,20 +1920,24 @@ var HELP_TEXT = `
 Commands:
   /worktree init                   Configure worktree settings interactively
   /worktree settings [key] [val]   Get/set individual settings
-  /worktree create <feature-name>  Create new worktree with branch
-  /worktree list                   List all worktrees
-  /worktree remove <name>          Remove a worktree
+  /worktree create <branch> [--name <worktree-name>]  Create new worktree from branch
+  /worktree create --generate [--name <worktree-name>] <prompt-or-name>  Generate branch via config command
+  /worktree list                   List worktrees and run onSwitch for a selection
+  /worktree remove <name>          Remove a worktree (runs onBeforeRemove if set)
   /worktree status                 Show current worktree info
   /worktree cd <name>              Print path to worktree
   /worktree prune                  Clean up stale references
   /worktree templates              Show template variables preview
 
-Configuration (~/.pi/agent/pi-worktrees-settings.json):
+Configuration (~/.pi/agent/pi-worktrees.config.json):
   {
     "worktrees": {
       "github.com/org/repo": {
         "worktreeRoot": "~/work/org",
-        "onCreate": ["mise install", "bun install"]
+        "onCreate": ["mise install", "bun install"],
+        "onSwitch": "mise run dev:resume",
+        "onBeforeRemove": "bun test",
+        "branchNameGenerator": "pi -p 'branch name for $PI_WORKTREE_PROMPT' --model local/model",
       },
       "github.com/org/*": {
         "worktreeRoot": "~/work/org-other",
@@ -1490,7 +1963,13 @@ Pattern matching: exact URL > most-specific glob > fallback (worktree)
 Matching strategies: fail-on-tie | first-wins | last-wins
 
 Config note: parentDir is deprecated and supported as an alias for worktreeRoot.
-Template vars: {{path}}, {{name}}, {{branch}}, {{project}}, {{mainWorktree}}
+Naming note: default worktree name is slugify(branch); explicit '--name' takes precedence.
+Generator note: '--generate' is explicit opt-in and requires branchNameGenerator config.
+Generated branch output must be valid and is never used unless --generate is present.
+Migration note: legacy '/worktree create <feature-name>' is deprecated and now treats token as branch.
+Use '/worktree create feature/<name> --name <name>' to preserve old semantics.
+Hook vars: {{path}}, {{name}}, {{branch}}, {{project}}, {{mainWorktree}}
+Hooks: onCreate (new), onSwitch (existing), onBeforeRemove (pre-delete, non-zero blocks)
 Logfile vars: {sessionId} / {{sessionId}}, {name} / {{name}}, {timestamp} / {{timestamp}}
 `.trim();
 var commands = {
@@ -1511,29 +1990,7 @@ var commands = {
 };
 var PiWorktreeExtension = async function(pi) {
   const configService = await createPiWorktreeConfigService();
-  const queue = [];
-  configService.events.on("MigrationFailed", () => {
-    queue.push({ type: "error", msg: "MigrationFailed" });
-  });
-  configService.events.on("MigrationApplied", () => {
-    queue.push({ type: "info", msg: "MigrationApplied" });
-  });
-  configService.events.on("ConfigLoading", () => {
-    queue.push({ type: "info", msg: "ConfigLoading" });
-  });
-  configService.events.on("ConfigLoaded", () => {
-    queue.push({ type: "info", msg: "ConfigLoaded" });
-  });
-  pi.on("session_start", async (event, ctx) => {
-    await configService.ready;
-    while (queue.length > 0) {
-      const notification = queue.shift();
-      if (!notification) {
-        return;
-      }
-      ctx.ui.setStatus(`Worktrees`, notification.msg);
-    }
-  });
+  const statusService = new StatusIndicator("pi-worktree");
   const getSubcommandCompletions = createCompletionFactory(commands);
   pi.registerCommand("worktree", {
     description: "Git worktree management for isolated workspaces",
@@ -1552,7 +2009,8 @@ var PiWorktreeExtension = async function(pi) {
         const settings = configService.current(ctx);
         await command(rest.join(" "), ctx, {
           settings,
-          configService
+          configService,
+          statusService
         });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/services/branchNameGenerator.d.ts

@@ -0,0 +1,20 @@
+export declare const BRANCH_NAME_GENERATOR_TIMEOUT_MS = 5000;
+export type BranchNameGeneratorErrorCode = 'missing-config' | 'timeout' | 'non-zero-exit' | 'empty-output' | 'invalid-output' | 'spawn-error';
+export interface GenerateBranchNameParams {
+    commandTemplate: string | undefined;
+    input: string;
+    cwd: string;
+    timeoutMs?: number;
+}
+export interface GenerateBranchNameSuccess {
+    ok: true;
+    branchName: string;
+    command: string;
+}
+export interface GenerateBranchNameFailure {
+    ok: false;
+    code: BranchNameGeneratorErrorCode;
+    message: string;
+}
+export type GenerateBranchNameResult = GenerateBranchNameSuccess | GenerateBranchNameFailure;
+export declare function generateBranchName(params: GenerateBranchNameParams): Promise<GenerateBranchNameResult>;

package/dist/services/config/config.d.ts

@@ -4,6 +4,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
         parentDir?: string | undefined;
         onCreate?: string | string[] | undefined;
         worktreeRoot?: string | undefined;
+        onSwitch?: string | string[] | undefined;
+        onBeforeRemove?: string | string[] | undefined;
+        branchNameGenerator?: string | undefined;
     }>;
     current: (ctx: {
         cwd: string;
@@ -23,6 +26,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
         matchedPattern: string | null;
         onCreate?: string | string[] | undefined;
         worktreeRoot?: string | undefined;
+        onSwitch?: string | string[] | undefined;
+        onBeforeRemove?: string | string[] | undefined;
+        branchNameGenerator?: string | undefined;
     };
     save: (data: PiWorktreeConfig) => Promise<void>;
     config: {
@@ -31,6 +37,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
                 worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
                 parentDir: import("typebox").TOptional<import("typebox").TString>;
                 onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
             }>>>;
             matchingStrategy: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"fail-on-tie">, import("typebox").TLiteral<"first-wins">, import("typebox").TLiteral<"last-wins">]>>;
             logfile: import("typebox").TOptional<import("typebox").TString>;
@@ -45,6 +54,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
             worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
             parentDir: import("typebox").TOptional<import("typebox").TString>;
             onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
         }>> | undefined;
         logfile?: string | undefined;
         onCreateDisplayOutputMaxLines?: number | undefined;
@@ -65,6 +77,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
                 worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
                 parentDir: import("typebox").TOptional<import("typebox").TString>;
                 onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+                branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
             }>>>;
             matchingStrategy: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"fail-on-tie">, import("typebox").TLiteral<"first-wins">, import("typebox").TLiteral<"last-wins">]>>;
             logfile: import("typebox").TOptional<import("typebox").TString>;
@@ -79,6 +94,9 @@ export declare function createPiWorktreeConfigService(): Promise<{
             worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
             parentDir: import("typebox").TOptional<import("typebox").TString>;
             onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+            branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
         }>> | undefined;
         logfile?: string | undefined;
         onCreateDisplayOutputMaxLines?: number | undefined;

package/dist/services/config/schema.d.ts

@@ -3,6 +3,9 @@ declare const WorktreeSettingsSchema: import("typebox").TObject<{
     worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
     parentDir: import("typebox").TOptional<import("typebox").TString>;
     onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+    onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+    onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+    branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
 }>;
 declare const MatchingStrategySchema: import("typebox").TUnion<[import("typebox").TLiteral<"fail-on-tie">, import("typebox").TLiteral<"first-wins">, import("typebox").TLiteral<"last-wins">]>;
 declare const MatchStrategyResultSchema: import("typebox").TUnion<[import("typebox").TLiteral<"exact">, import("typebox").TLiteral<"unmatched">]>;
@@ -11,6 +14,9 @@ export declare const PiWorktreeConfigSchema: import("typebox").TObject<{
         worktreeRoot: import("typebox").TOptional<import("typebox").TString>;
         parentDir: import("typebox").TOptional<import("typebox").TString>;
         onCreate: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+        onSwitch: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+        onBeforeRemove: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TString, import("typebox").TArray<import("typebox").TString>]>>;
+        branchNameGenerator: import("typebox").TOptional<import("typebox").TString>;
     }>>>;
     matchingStrategy: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"fail-on-tie">, import("typebox").TLiteral<"first-wins">, import("typebox").TLiteral<"last-wins">]>>;
     logfile: import("typebox").TOptional<import("typebox").TString>;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { ExtensionCommandContext } from '@mariozechner/pi-coding-agent';
 import type { PiWorktreeConfigService } from './services/config/config.ts';
 import { WorktreeSettingsConfig } from './services/config/schema.ts';
+import { StatusIndicator } from './ui/status.ts';
 export interface WorktreeCreatedContext {
     path: string;
     name: string;
@@ -11,5 +12,6 @@ export interface WorktreeCreatedContext {
 export interface CommandDeps {
     settings: WorktreeSettingsConfig;
     configService: PiWorktreeConfigService;
+    statusService: StatusIndicator;
 }
 export type CmdHandler = (...args: [string, ExtensionCommandContext, CommandDeps]) => Promise<void>;

package/dist/ui/status.d.ts

@@ -0,0 +1,27 @@
+import { ExtensionCommandContext } from '@mariozechner/pi-coding-agent';
+type StatusOptions = {
+    busy?: keyof typeof StatusIndicator.busyStyles;
+    progress?: keyof typeof StatusIndicator.progressStyles;
+};
+export declare class StatusIndicator {
+    statusKey: string;
+    busyStyle: keyof typeof StatusIndicator.busyStyles;
+    private busyFrames;
+    private progressStyle;
+    private progressFrames;
+    constructor(statusKey: string, options?: StatusOptions);
+    busy(ctx: ExtensionCommandContext, message: string): () => void;
+    cautious(ctx: ExtensionCommandContext, message: string): void;
+    critical(ctx: ExtensionCommandContext, message: string): void;
+    positive(ctx: ExtensionCommandContext, message: string): void;
+    informative(ctx: ExtensionCommandContext, message: string): void;
+    progress(ctx: ExtensionCommandContext, message: string, percent: number): void;
+    static busyStyles: {
+        dots: string[];
+    };
+    static progressStyles: {
+        bars: (percent: number) => string;
+        pie: (percent: number) => string;
+    };
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenobius/pi-worktrees",
-  "version": "0.4.0-next.8",
+  "version": "0.5.0",
   "description": "Worktrees extension for Pi Coding Agent",
   "author": {
     "name": "Zenobius",