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

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/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,13 @@ 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)
 }, {
   $id: "WorktreeSettingsConfig",
   additionalProperties: false
@@ -73,7 +75,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 +342,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 +419,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 +491,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 +518,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 +532,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 +546,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";
@@ -950,12 +961,6 @@ var DefaultWorktreeSettings = {
 var DefaultLogfileTemplate = DEFAULT_LOGFILE_TEMPLATE;
 
 // src/cmds/cmdCreate.ts
-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);
-}
 async function cmdCreate(args, ctx, deps) {
   const featureName = args.trim();
   if (!featureName) {
@@ -969,9 +974,53 @@ async function cmdCreate(args, ctx, deps) {
   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");
+  const existingWorktree = listWorktrees(ctx.cwd).find((worktree) => worktree.path === worktreePath || basename3(worktree.path) === featureName || 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,10 +1029,14 @@ 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: ${featureName}...`);
   try {
     git(["worktree", "add", "-b", branchName, worktreePath], current.mainWorktree);
+    stopBusy();
+    deps.statusService.positive(ctx, `Created: ${featureName}`);
   } catch (err) {
+    stopBusy();
+    deps.statusService.critical(ctx, `Failed to create worktree`);
     ctx.ui.notify(`Failed to create worktree: ${err.message}`, "error");
     return;
   }
@@ -1100,6 +1153,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 +1169,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 +1191,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 +1276,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 +1303,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 +1313,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 +1323,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 +1388,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 +1614,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
@@ -1452,19 +1690,21 @@ 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 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"
       },
       "github.com/org/*": {
         "worktreeRoot": "~/work/org-other",
@@ -1490,7 +1730,8 @@ 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}}
+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 +1752,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 +1771,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/config/config.d.ts

@@ -4,6 +4,8 @@ export declare function createPiWorktreeConfigService(): Promise<{
         parentDir?: string | undefined;
         onCreate?: string | string[] | undefined;
         worktreeRoot?: string | undefined;
+        onSwitch?: string | string[] | undefined;
+        onBeforeRemove?: string | string[] | undefined;
     }>;
     current: (ctx: {
         cwd: string;
@@ -23,6 +25,8 @@ export declare function createPiWorktreeConfigService(): Promise<{
         matchedPattern: string | null;
         onCreate?: string | string[] | undefined;
         worktreeRoot?: string | undefined;
+        onSwitch?: string | string[] | undefined;
+        onBeforeRemove?: string | string[] | undefined;
     };
     save: (data: PiWorktreeConfig) => Promise<void>;
     config: {
@@ -31,6 +35,8 @@ 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>]>>;
             }>>>;
             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 +51,8 @@ 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>]>>;
         }>> | undefined;
         logfile?: string | undefined;
         onCreateDisplayOutputMaxLines?: number | undefined;
@@ -65,6 +73,8 @@ 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>]>>;
             }>>>;
             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 +89,8 @@ 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>]>>;
         }>> | undefined;
         logfile?: string | undefined;
         onCreateDisplayOutputMaxLines?: number | undefined;

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

@@ -3,6 +3,8 @@ 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>]>>;
 }>;
 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 +13,8 @@ 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>]>>;
     }>>>;
     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.13",
+  "version": "0.4.0-next.16",
   "description": "Worktrees extension for Pi Coding Agent",
   "author": {
     "name": "Zenobius",