@zenobius/pi-worktrees 0.4.0-next.16 → 0.4.0-next.19

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/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/index.js

@@ -30,7 +30,8 @@ var WorktreeSettingsSchema = TypeObject({
   parentDir: Optional(TypeString()),
   onCreate: Optional(HookCommandsSchema),
   onSwitch: Optional(HookCommandsSchema),
-  onBeforeRemove: Optional(HookCommandsSchema)
+  onBeforeRemove: Optional(HookCommandsSchema),
+  branchNameGenerator: Optional(TypeString())
 }, {
   $id: "WorktreeSettingsConfig",
   additionalProperties: false
@@ -960,21 +961,251 @@ var DefaultWorktreeSettings = {
 };
 var DefaultLogfileTemplate = DEFAULT_LOGFILE_TEMPLATE;
 
+// 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 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 = 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;
+      clearTimeout(timer);
+      resolve2({ kind: "spawn-error", error: error.message });
+    });
+    child.on("close", (code) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      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 existingWorktree = listWorktrees(ctx.cwd).find((worktree) => worktree.path === worktreePath || basename3(worktree.path) === featureName || worktree.branch === branchName);
+  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");
@@ -1029,11 +1260,11 @@ Switch to this worktree?`;
     return;
   } catch {}
   ensureExcluded(ctx.cwd, current.parentDir);
-  const stopBusy = deps.statusService.busy(ctx, `Creating worktree: ${featureName}...`);
+  const stopBusy = deps.statusService.busy(ctx, `Creating worktree: ${worktreeName}...`);
   try {
     git(["worktree", "add", "-b", branchName, worktreePath], current.mainWorktree);
     stopBusy();
-    deps.statusService.positive(ctx, `Created: ${featureName}`);
+    deps.statusService.positive(ctx, `Created: ${worktreeName}`);
   } catch (err) {
     stopBusy();
     deps.statusService.critical(ctx, `Failed to create worktree`);
@@ -1042,12 +1273,12 @@ Switch to this worktree?`;
   }
   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,
@@ -1689,7 +1920,8 @@ 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 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
@@ -1704,7 +1936,8 @@ Configuration (~/.pi/agent/pi-worktrees.config.json):
         "worktreeRoot": "~/work/org",
         "onCreate": ["mise install", "bun install"],
         "onSwitch": "mise run dev:resume",
-        "onBeforeRemove": "bun test"
+        "onBeforeRemove": "bun test",
+        "branchNameGenerator": "pi -p "branch name for $PI_WORKTREE_PROMPT" --model local/model",
       },
       "github.com/org/*": {
         "worktreeRoot": "~/work/org-other",
@@ -1730,6 +1963,11 @@ 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.
+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}}

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

@@ -6,6 +6,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
         worktreeRoot?: string | undefined;
         onSwitch?: string | string[] | undefined;
         onBeforeRemove?: string | string[] | undefined;
+        branchNameGenerator?: string | undefined;
     }>;
     current: (ctx: {
         cwd: string;
@@ -27,6 +28,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
         worktreeRoot?: string | undefined;
         onSwitch?: string | string[] | undefined;
         onBeforeRemove?: string | string[] | undefined;
+        branchNameGenerator?: string | undefined;
     };
     save: (data: PiWorktreeConfig) => Promise<void>;
     config: {
@@ -37,6 +39,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
                 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>;
@@ -53,6 +56,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
             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;
@@ -75,6 +79,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
                 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>;
@@ -91,6 +96,7 @@ export declare function createPiWorktreeConfigService(): Promise<{
             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

@@ -5,6 +5,7 @@ declare const WorktreeSettingsSchema: import("typebox").TObject<{
     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">]>;
@@ -15,6 +16,7 @@ export declare const PiWorktreeConfigSchema: import("typebox").TObject<{
         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/package.json

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