workon 3.1.0 → 3.2.1

package/dist/cli.js

@@ -9,27 +9,314 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/events/extensions/npm.ts
-var npm_exports = {};
-__export(npm_exports, {
-  NpmEvent: () => NpmEvent,
-  default: () => npm_default
+// src/lib/config.ts
+import Conf from "conf";
+var TRANSIENT_PROPS, Config;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    TRANSIENT_PROPS = ["pkg", "work"];
+    Config = class {
+      _transient = {};
+      _store;
+      constructor() {
+        this._store = new Conf({
+          projectName: "workon"
+        });
+      }
+      get(key, defaultValue) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          return this._transient[key] ?? defaultValue;
+        }
+        return this._store.get(key, defaultValue);
+      }
+      set(key, value) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          this._transient[key] = value;
+        } else {
+          if (value === void 0) {
+            this._store.set(key, value);
+          } else {
+            this._store.set(key, value);
+          }
+        }
+      }
+      has(key) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          return Object.prototype.hasOwnProperty.call(this._transient, key);
+        }
+        return this._store.has(key);
+      }
+      delete(key) {
+        const rootKey = key.split(".")[0];
+        if (TRANSIENT_PROPS.includes(rootKey)) {
+          delete this._transient[key];
+        } else {
+          this._store.delete(key);
+        }
+      }
+      getProjects() {
+        return this.get("projects") ?? {};
+      }
+      getProject(name) {
+        const projects = this.getProjects();
+        return projects[name];
+      }
+      setProject(name, config) {
+        const projects = this.getProjects();
+        projects[name] = config;
+        this.set("projects", projects);
+      }
+      deleteProject(name) {
+        const projects = this.getProjects();
+        delete projects[name];
+        this.set("projects", projects);
+      }
+      getDefaults() {
+        return this.get("project_defaults");
+      }
+      setDefaults(defaults) {
+        this.set("project_defaults", defaults);
+      }
+      get path() {
+        return this._store.path;
+      }
+      get store() {
+        return this._store.store;
+      }
+    };
+  }
 });
-import { spawn as spawn7 } from "child_process";
-import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
-var NpmEvent, npm_default;
-var init_npm = __esm({
-  "src/events/extensions/npm.ts"() {
+
+// src/lib/project.ts
+import File from "phylo";
+import deepAssign from "deep-assign";
+var Project;
+var init_project = __esm({
+  "src/lib/project.ts"() {
     "use strict";
-    NpmEvent = class _NpmEvent {
+    Project = class {
+      name;
+      _base;
+      _path;
+      _ide;
+      _events = {};
+      _branch;
+      _homepage;
+      _defaults;
+      _initialCfg;
+      constructor(name, cfg, defaults) {
+        this._defaults = defaults ?? { base: "" };
+        this._initialCfg = { path: name, events: {}, ...cfg };
+        this.name = cfg?.name ?? name;
+        const merged = deepAssign({}, this._defaults, this._initialCfg);
+        if (merged.base) {
+          this.base = merged.base;
+        }
+        if (merged.path) {
+          this.path = merged.path;
+        }
+        if (merged.ide) {
+          this._ide = merged.ide;
+        }
+        if (merged.events) {
+          this._events = merged.events;
+        }
+        if (merged.branch) {
+          this._branch = merged.branch;
+        }
+        if (merged.homepage) {
+          this._homepage = merged.homepage;
+        }
+      }
+      set base(path) {
+        this._base = File.from(path).absolutify();
+      }
+      get base() {
+        return this._base;
+      }
+      set ide(cmd) {
+        this._ide = cmd;
+      }
+      get ide() {
+        return this._ide;
+      }
+      set events(eventCfg) {
+        this._events = eventCfg;
+      }
+      get events() {
+        return this._events;
+      }
+      set path(path) {
+        if (this._base) {
+          this._path = this._base.join(path);
+        } else {
+          this._path = File.from(path);
+        }
+        this._path = this._path.absolutify();
+      }
+      get path() {
+        if (!this._path) {
+          throw new Error("Project path not set");
+        }
+        return this._path;
+      }
+      set branch(branch) {
+        this._branch = branch;
+      }
+      get branch() {
+        return this._branch;
+      }
+      set homepage(url) {
+        this._homepage = url;
+      }
+      get homepage() {
+        return this._homepage;
+      }
+      static $isProject = true;
+      $isProject = true;
+    };
+  }
+});
+
+// src/lib/environment.ts
+import File2 from "phylo";
+import { simpleGit } from "simple-git";
+var BaseEnvironment, ProjectEnvironment, EnvironmentRecognizer;
+var init_environment = __esm({
+  "src/lib/environment.ts"() {
+    "use strict";
+    init_config();
+    init_project();
+    BaseEnvironment = class {
+      $isProjectEnvironment = false;
+    };
+    ProjectEnvironment = class _ProjectEnvironment {
+      $isProjectEnvironment = true;
+      project;
+      constructor(projectCfg) {
+        this.project = new Project(projectCfg.name, projectCfg);
+      }
+      static load(cfg, defaults) {
+        const project = new Project(cfg.name, cfg, defaults);
+        return new _ProjectEnvironment({ ...cfg, name: project.name });
+      }
+    };
+    EnvironmentRecognizer = class {
+      static config;
+      static log;
+      static projects = [];
+      static configured = false;
+      static configure(config, log) {
+        if (this.configured) {
+          return;
+        }
+        this.config = config;
+        this.log = log;
+        this.configured = true;
+      }
+      static async recognize(dir) {
+        this.ensureConfigured();
+        const theDir = File2.from(dir).canonicalize();
+        this.log.debug("Directory to recognize is: " + theDir.canonicalPath());
+        const allProjects = this.getAllProjects();
+        const matching = allProjects.filter((p) => p.path.canonicalPath() === theDir.path);
+        if (matching.length === 0) {
+          return new BaseEnvironment();
+        }
+        this.log.debug(`Found ${matching.length} matching projects`);
+        const base = matching.find((p) => !p.name.includes("#")) ?? matching[0];
+        this.log.debug("Base project is: " + base.name);
+        const gitDir = base.path.up(".git");
+        if (gitDir) {
+          try {
+            const git = simpleGit(gitDir.path);
+            const branchSummary = await git.branchLocal();
+            base.branch = branchSummary.current;
+          } catch (error) {
+            this.log.debug(`Git branch detection failed: ${error.message}`);
+          }
+        }
+        return this.getProjectEnvironment(base, matching);
+      }
+      static getAllProjects(refresh = false) {
+        if (this.projects.length > 0 && !refresh) {
+          return this.projects;
+        }
+        const defaults = this.config.getDefaults();
+        if (!defaults?.base) {
+          this.projects = [];
+          return this.projects;
+        }
+        const baseDir = File2.from(defaults.base);
+        const projectsMap = this.config.getProjects();
+        this.projects = Object.entries(projectsMap).map(([name, project]) => ({
+          ...project,
+          name,
+          path: baseDir.join(project.path)
+        }));
+        return this.projects;
+      }
+      static getProjectEnvironment(base, _matching) {
+        const exactName = `${base.name}#${base.branch}`;
+        const exactProj = this.projects.find((p) => p.name === exactName);
+        const toProjectConfig = (p) => ({
+          name: p.name,
+          path: p.path.path,
+          // Convert PhyloFile to string path
+          ide: p.ide,
+          homepage: p.homepage,
+          events: p.events,
+          branch: p.branch,
+          exactName
+        });
+        if (exactProj) {
+          return new ProjectEnvironment({ ...toProjectConfig(exactProj), branch: base.branch });
+        }
+        return new ProjectEnvironment(toProjectConfig(base));
+      }
+      static ensureConfigured() {
+        if (!this.configured) {
+          this.config = new Config();
+          this.log = {
+            debug: () => {
+            },
+            info: () => {
+            },
+            log: () => {
+            },
+            warn: () => {
+            },
+            error: () => {
+            },
+            setLogLevel: () => {
+            }
+          };
+          this.configured = true;
+        }
+      }
+    };
+  }
+});
+
+// src/events/core/cwd.ts
+import { spawn } from "child_process";
+var CwdEvent;
+var init_cwd = __esm({
+  "src/events/core/cwd.ts"() {
+    "use strict";
+    CwdEvent = class {
       static get metadata() {
         return {
-          name: "npm",
-          displayName: "Run NPM command",
-          description: "Execute NPM scripts in project directory",
-          category: "development",
-          requiresTmux: true,
-          dependencies: ["npm"]
+          name: "cwd",
+          displayName: "Change directory (cwd)",
+          description: "Change current working directory to project path",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
         };
       }
       static get validation() {
@@ -38,160 +325,827 @@ var init_npm = __esm({
             if (typeof config === "boolean" || config === "true" || config === "false") {
               return true;
             }
-            if (typeof config === "string") {
-              if (config.trim().length === 0) {
-                return "npm script name cannot be empty";
-              }
-              return true;
-            }
-            if (typeof config === "object" && config !== null) {
-              const cfg = config;
-              if (typeof cfg.command !== "string" || cfg.command.trim().length === 0) {
-                return "npm.command must be a non-empty string";
-              }
-              if (cfg.watch !== void 0 && typeof cfg.watch !== "boolean") {
-                return "npm.watch must be a boolean";
-              }
-              if (cfg.auto_restart !== void 0 && typeof cfg.auto_restart !== "boolean") {
-                return "npm.auto_restart must be a boolean";
-              }
-              return true;
-            }
-            return "npm config must be a boolean, string (script name), or object";
+            return "cwd config must be a boolean (true/false)";
           }
         };
       }
       static get configuration() {
         return {
           async configureInteractive() {
-            const scriptName = await input3({
-              message: "Enter NPM script to run:",
-              default: "dev"
-            });
-            const useAdvanced = await confirm2({
-              message: "Configure advanced NPM options?",
-              default: false
-            });
-            if (!useAdvanced) {
-              return scriptName;
-            }
-            const watch = await confirm2({
-              message: "Enable watch mode?",
-              default: false
-            });
-            const autoRestart = await confirm2({
-              message: "Auto-restart on crash?",
-              default: false
-            });
-            if (!watch && !autoRestart) {
-              return scriptName;
-            }
-            return {
-              command: scriptName,
-              watch,
-              auto_restart: autoRestart
-            };
+            return true;
           },
           getDefaultConfig() {
-            return "dev";
+            return true;
           }
         };
       }
-      static getNpmCommand(config) {
-        if (typeof config === "boolean" || config === void 0) {
-          return "npm run dev";
-        }
-        if (typeof config === "string") {
-          return `npm run ${config}`;
-        }
-        return `npm run ${config.command}`;
-      }
       static get processing() {
         return {
           async processEvent(context) {
             const { project, isShellMode, shellCommands } = context;
-            const npmConfig = project.events.npm;
-            const npmCommand = _NpmEvent.getNpmCommand(npmConfig);
+            const projectPath = project.path.path;
             if (isShellMode) {
-              shellCommands.push(npmCommand);
+              shellCommands.push(`cd "${projectPath}"`);
             } else {
-              const [cmd, ...args] = npmCommand.split(" ");
-              spawn7(cmd, args, {
-                cwd: project.path.path,
+              const shell = process.env.SHELL || "/bin/bash";
+              spawn(shell, [], {
+                cwd: projectPath,
                 stdio: "inherit"
               });
             }
           },
           generateShellCommand(context) {
-            const npmConfig = context.project.events.npm;
-            return [_NpmEvent.getNpmCommand(npmConfig)];
+            const projectPath = context.project.path.path;
+            return [`cd "${projectPath}"`];
           }
         };
       }
       static get tmux() {
+        return null;
+      }
+      static get help() {
         return {
-          getLayoutPriority() {
-            return 50;
+          usage: "cwd: true | false",
+          description: "Change the current working directory to the project path",
+          examples: [
+            { config: true, description: "Enable directory change" },
+            { config: false, description: "Disable directory change" }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/core/ide.ts
+import { spawn as spawn2 } from "child_process";
+var IdeEvent;
+var init_ide = __esm({
+  "src/events/core/ide.ts"() {
+    "use strict";
+    IdeEvent = class {
+      static get metadata() {
+        return {
+          name: "ide",
+          displayName: "Open in IDE",
+          description: "Open project in configured IDE/editor",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            return "ide config must be a boolean (true/false)";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            return true;
           },
-          contributeToLayout(enabledCommands) {
-            if (enabledCommands.includes("claude")) {
-              return "three-pane";
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const projectPath = project.path.path;
+            const ide = project.ide || "code";
+            if (isShellMode) {
+              shellCommands.push(`${ide} "${projectPath}" &`);
+            } else {
+              spawn2(ide, [projectPath], {
+                detached: true,
+                stdio: "ignore"
+              }).unref();
             }
-            return "two-pane-npm";
+          },
+          generateShellCommand(context) {
+            const projectPath = context.project.path.path;
+            const ide = context.project.ide || "code";
+            return [`${ide} "${projectPath}" &`];
           }
         };
       }
+      static get tmux() {
+        return null;
+      }
       static get help() {
         return {
-          usage: 'npm: true | "script" | { command: string, watch?: boolean, auto_restart?: boolean }',
-          description: "Run an NPM script in the project directory",
+          usage: "ide: true | false",
+          description: "Open the project in the configured IDE",
           examples: [
-            { config: true, description: "Run npm run dev" },
-            { config: "test", description: "Run npm run test" },
-            { config: { command: "dev", watch: true }, description: "Run dev with watch mode" }
+            { config: true, description: "Enable IDE opening" },
+            { config: false, description: "Disable IDE opening" }
           ]
         };
       }
     };
-    npm_default = NpmEvent;
   }
 });
 
-// src/commands/interactive.ts
-var interactive_exports = {};
-__export(interactive_exports, {
-  runInteractive: () => runInteractive
-});
-import { select, input as input4, checkbox } from "@inquirer/prompts";
-import File3 from "phylo";
-import deepAssign2 from "deep-assign";
-async function runInteractive(ctx) {
-  const { config, log, environment, suggestedName } = ctx;
-  showLogo(config);
-  log.log("");
-  const defaultName = suggestedName ?? (environment.$isProjectEnvironment ? environment.project.name : File3.cwd().name);
-  const fromUser = !!suggestedName;
-  await startInteractive(defaultName, fromUser, ctx);
-}
-function showLogo(config) {
-  const version = config.get("pkg")?.version ?? "unknown";
-  console.log(
-    `                      8\x1B[2m${" ".repeat(Math.max(15 - version.length - 1, 1)) + "v" + version}\x1B[22m
-Yb  db  dP .d8b. 8d8b 8.dP \x1B[92m.d8b. 8d8b.\x1B[0m
- YbdPYbdP  8' .8 8P   88b  \x1B[92m8' .8 8P Y8\x1B[0m
-  YP  YP   \`Y8P' 8    8 Yb \x1B[92m\`Y8P' 8   8\x1B[0m`
-  );
-}
-async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
-  const { log, environment } = ctx;
-  log.debug(`Name '${defaultName}' was${fromUser ? "" : " not"} provided by the user`);
-  const question = getFirstQuestion(defaultName, fromUser, environment, showMain);
-  const action = await select(question);
-  switch (action) {
-    case "exit":
-      return;
-    case "more":
-      await startInteractive(defaultName, fromUser, ctx, true);
+// src/events/core/web.ts
+import { spawn as spawn3 } from "child_process";
+import { platform } from "os";
+var WebEvent;
+var init_web = __esm({
+  "src/events/core/web.ts"() {
+    "use strict";
+    WebEvent = class _WebEvent {
+      static get metadata() {
+        return {
+          name: "web",
+          displayName: "Open homepage in browser",
+          description: "Open project homepage in web browser",
+          category: "core",
+          requiresTmux: false,
+          dependencies: []
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            return "web config must be a boolean (true/false)";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            return true;
+          },
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static getOpenCommand() {
+        const os = platform();
+        switch (os) {
+          case "darwin":
+            return "open";
+          case "win32":
+            return "start";
+          default:
+            return "xdg-open";
+        }
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const homepage = project.homepage;
+            if (!homepage) {
+              console.warn("No homepage configured for project");
+              return;
+            }
+            const openCmd = _WebEvent.getOpenCommand();
+            if (isShellMode) {
+              shellCommands.push(`${openCmd} "${homepage}" &`);
+            } else {
+              spawn3(openCmd, [homepage], {
+                detached: true,
+                stdio: "ignore"
+              }).unref();
+            }
+          },
+          generateShellCommand(context) {
+            const homepage = context.project.homepage;
+            if (!homepage) return [];
+            const openCmd = _WebEvent.getOpenCommand();
+            return [`${openCmd} "${homepage}" &`];
+          }
+        };
+      }
+      static get tmux() {
+        return null;
+      }
+      static get help() {
+        return {
+          usage: "web: true | false",
+          description: "Open the project homepage in the default browser",
+          examples: [
+            { config: true, description: "Enable browser opening" },
+            { config: false, description: "Disable browser opening" }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/claude.ts
+import { spawn as spawn4 } from "child_process";
+import { input, confirm } from "@inquirer/prompts";
+var ClaudeEvent;
+var init_claude = __esm({
+  "src/events/extensions/claude.ts"() {
+    "use strict";
+    ClaudeEvent = class _ClaudeEvent {
+      static get metadata() {
+        return {
+          name: "claude",
+          displayName: "Launch Claude Code",
+          description: "Launch Claude Code with optional flags and configuration",
+          category: "development",
+          requiresTmux: true,
+          dependencies: ["claude"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (cfg.flags !== void 0) {
+                if (!Array.isArray(cfg.flags)) {
+                  return "claude.flags must be an array of strings";
+                }
+                for (const flag of cfg.flags) {
+                  if (typeof flag !== "string") {
+                    return "claude.flags must contain only strings";
+                  }
+                  if (!flag.startsWith("-")) {
+                    return `Invalid flag "${flag}": flags must start with - or --`;
+                  }
+                }
+              }
+              if (cfg.split_terminal !== void 0 && typeof cfg.split_terminal !== "boolean") {
+                return "claude.split_terminal must be a boolean";
+              }
+              return true;
+            }
+            return "claude config must be a boolean or object with flags/split_terminal";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const useAdvanced = await confirm({
+              message: "Configure advanced Claude options?",
+              default: false
+            });
+            if (!useAdvanced) {
+              return true;
+            }
+            const flagsInput = await input({
+              message: "Enter Claude flags (comma-separated, e.g., --resume, --debug):",
+              default: ""
+            });
+            const flags = flagsInput.split(",").map((f) => f.trim()).filter((f) => f.length > 0 && f.startsWith("-"));
+            const splitTerminal = await confirm({
+              message: "Use split terminal layout (Claude + shell)?",
+              default: true
+            });
+            if (flags.length === 0 && !splitTerminal) {
+              return true;
+            }
+            const config = {};
+            if (flags.length > 0) config.flags = flags;
+            if (splitTerminal) config.split_terminal = splitTerminal;
+            return config;
+          },
+          getDefaultConfig() {
+            return true;
+          }
+        };
+      }
+      static getClaudeCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "claude";
+        }
+        const flags = config.flags || [];
+        return flags.length > 0 ? `claude ${flags.join(" ")}` : "claude";
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const claudeConfig = project.events.claude;
+            const claudeCommand = _ClaudeEvent.getClaudeCommand(claudeConfig);
+            if (isShellMode) {
+              shellCommands.push(claudeCommand);
+            } else {
+              const args = claudeCommand.split(" ").slice(1);
+              spawn4("claude", args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const claudeConfig = context.project.events.claude;
+            return [_ClaudeEvent.getClaudeCommand(claudeConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return {
+          getLayoutPriority() {
+            return 100;
+          },
+          contributeToLayout(enabledCommands) {
+            if (enabledCommands.includes("npm")) {
+              return "three-pane";
+            }
+            return "split";
+          }
+        };
+      }
+      static get help() {
+        return {
+          usage: "claude: true | { flags: string[], split_terminal: boolean }",
+          description: "Launch Claude Code in the project directory",
+          examples: [
+            { config: true, description: "Launch Claude with defaults" },
+            { config: { flags: ["--resume"] }, description: "Resume previous session" },
+            {
+              config: { flags: ["--model", "opus"], split_terminal: true },
+              description: "Use Opus model with split terminal"
+            }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/docker.ts
+import { spawn as spawn5 } from "child_process";
+import { input as input2 } from "@inquirer/prompts";
+var DockerEvent;
+var init_docker = __esm({
+  "src/events/extensions/docker.ts"() {
+    "use strict";
+    DockerEvent = class _DockerEvent {
+      static get metadata() {
+        return {
+          name: "docker",
+          displayName: "Docker container management",
+          description: "Start/stop Docker containers for the project",
+          category: "development",
+          requiresTmux: false,
+          dependencies: ["docker"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "string") {
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (cfg.compose_file !== void 0 && typeof cfg.compose_file !== "string") {
+                return "docker.compose_file must be a string";
+              }
+              if (cfg.services !== void 0) {
+                if (!Array.isArray(cfg.services)) {
+                  return "docker.services must be an array";
+                }
+                for (const service of cfg.services) {
+                  if (typeof service !== "string") {
+                    return "docker.services must contain only strings";
+                  }
+                }
+              }
+              return true;
+            }
+            return "docker config must be a boolean, string (compose file), or object";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const composeFile = await input2({
+              message: "Enter docker-compose file path:",
+              default: "docker-compose.yml"
+            });
+            const servicesInput = await input2({
+              message: "Enter services to start (comma-separated, leave empty for all):",
+              default: ""
+            });
+            const services = servicesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+            if (composeFile === "docker-compose.yml" && services.length === 0) {
+              return { compose_file: "docker-compose.yml" };
+            }
+            if (services.length === 0) {
+              return composeFile;
+            }
+            return {
+              compose_file: composeFile,
+              services
+            };
+          },
+          getDefaultConfig() {
+            return { compose_file: "docker-compose.yml" };
+          }
+        };
+      }
+      static getDockerCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "docker-compose up -d";
+        }
+        if (typeof config === "string") {
+          return `docker-compose -f ${config} up -d`;
+        }
+        const composeFile = config.compose_file || "docker-compose.yml";
+        const services = config.services?.join(" ") || "";
+        return `docker-compose -f ${composeFile} up -d ${services}`.trim();
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const dockerConfig = project.events.docker;
+            const dockerCommand = _DockerEvent.getDockerCommand(
+              dockerConfig
+            );
+            if (isShellMode) {
+              shellCommands.push(dockerCommand);
+            } else {
+              const [cmd, ...args] = dockerCommand.split(" ");
+              spawn5(cmd, args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const dockerConfig = context.project.events.docker;
+            return [_DockerEvent.getDockerCommand(dockerConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return null;
+      }
+      static get help() {
+        return {
+          usage: 'docker: true | "compose-file.yml" | { compose_file: string, services?: string[] }',
+          description: "Start Docker containers for the project",
+          examples: [
+            { config: true, description: "Use default docker-compose.yml" },
+            { config: "docker-compose.dev.yml", description: "Use custom compose file" },
+            {
+              config: { compose_file: "docker-compose.yml", services: ["web", "db"] },
+              description: "Start specific services"
+            }
+          ]
+        };
+      }
+    };
+  }
+});
+
+// src/events/extensions/npm.ts
+var npm_exports = {};
+__export(npm_exports, {
+  NpmEvent: () => NpmEvent,
+  default: () => npm_default
+});
+import { spawn as spawn6 } from "child_process";
+import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
+var NpmEvent, npm_default;
+var init_npm = __esm({
+  "src/events/extensions/npm.ts"() {
+    "use strict";
+    NpmEvent = class _NpmEvent {
+      static get metadata() {
+        return {
+          name: "npm",
+          displayName: "Run NPM command",
+          description: "Execute NPM scripts in project directory",
+          category: "development",
+          requiresTmux: true,
+          dependencies: ["npm"]
+        };
+      }
+      static get validation() {
+        return {
+          validateConfig(config) {
+            if (typeof config === "boolean" || config === "true" || config === "false") {
+              return true;
+            }
+            if (typeof config === "string") {
+              if (config.trim().length === 0) {
+                return "npm script name cannot be empty";
+              }
+              return true;
+            }
+            if (typeof config === "object" && config !== null) {
+              const cfg = config;
+              if (typeof cfg.command !== "string" || cfg.command.trim().length === 0) {
+                return "npm.command must be a non-empty string";
+              }
+              if (cfg.watch !== void 0 && typeof cfg.watch !== "boolean") {
+                return "npm.watch must be a boolean";
+              }
+              if (cfg.auto_restart !== void 0 && typeof cfg.auto_restart !== "boolean") {
+                return "npm.auto_restart must be a boolean";
+              }
+              return true;
+            }
+            return "npm config must be a boolean, string (script name), or object";
+          }
+        };
+      }
+      static get configuration() {
+        return {
+          async configureInteractive() {
+            const scriptName = await input3({
+              message: "Enter NPM script to run:",
+              default: "dev"
+            });
+            const useAdvanced = await confirm2({
+              message: "Configure advanced NPM options?",
+              default: false
+            });
+            if (!useAdvanced) {
+              return scriptName;
+            }
+            const watch = await confirm2({
+              message: "Enable watch mode?",
+              default: false
+            });
+            const autoRestart = await confirm2({
+              message: "Auto-restart on crash?",
+              default: false
+            });
+            if (!watch && !autoRestart) {
+              return scriptName;
+            }
+            return {
+              command: scriptName,
+              watch,
+              auto_restart: autoRestart
+            };
+          },
+          getDefaultConfig() {
+            return "dev";
+          }
+        };
+      }
+      static getNpmCommand(config) {
+        if (typeof config === "boolean" || config === void 0) {
+          return "npm run dev";
+        }
+        if (typeof config === "string") {
+          return `npm run ${config}`;
+        }
+        return `npm run ${config.command}`;
+      }
+      static get processing() {
+        return {
+          async processEvent(context) {
+            const { project, isShellMode, shellCommands } = context;
+            const npmConfig = project.events.npm;
+            const npmCommand = _NpmEvent.getNpmCommand(npmConfig);
+            if (isShellMode) {
+              shellCommands.push(npmCommand);
+            } else {
+              const [cmd, ...args] = npmCommand.split(" ");
+              spawn6(cmd, args, {
+                cwd: project.path.path,
+                stdio: "inherit"
+              });
+            }
+          },
+          generateShellCommand(context) {
+            const npmConfig = context.project.events.npm;
+            return [_NpmEvent.getNpmCommand(npmConfig)];
+          }
+        };
+      }
+      static get tmux() {
+        return {
+          getLayoutPriority() {
+            return 50;
+          },
+          contributeToLayout(enabledCommands) {
+            if (enabledCommands.includes("claude")) {
+              return "three-pane";
+            }
+            return "two-pane-npm";
+          }
+        };
+      }
+      static get help() {
+        return {
+          usage: 'npm: true | "script" | { command: string, watch?: boolean, auto_restart?: boolean }',
+          description: "Run an NPM script in the project directory",
+          examples: [
+            { config: true, description: "Run npm run dev" },
+            { config: "test", description: "Run npm run test" },
+            { config: { command: "dev", watch: true }, description: "Run dev with watch mode" }
+          ]
+        };
+      }
+    };
+    npm_default = NpmEvent;
+  }
+});
+
+// src/events/registry.ts
+var ALL_EVENTS, EventRegistryClass, EventRegistry;
+var init_registry = __esm({
+  "src/events/registry.ts"() {
+    "use strict";
+    init_cwd();
+    init_ide();
+    init_web();
+    init_claude();
+    init_docker();
+    init_npm();
+    ALL_EVENTS = [CwdEvent, IdeEvent, WebEvent, ClaudeEvent, DockerEvent, NpmEvent];
+    EventRegistryClass = class {
+      _events = /* @__PURE__ */ new Map();
+      _initialized = false;
+      /**
+       * Initialize the registry by registering all events
+       */
+      async initialize() {
+        if (this._initialized) return;
+        this.registerEvents();
+        this._initialized = true;
+      }
+      /**
+       * Register all event classes
+       */
+      registerEvents() {
+        for (const EventClass of ALL_EVENTS) {
+          if (this.isValidEventClass(EventClass)) {
+            this._events.set(EventClass.metadata.name, EventClass);
+          }
+        }
+      }
+      /**
+       * Type guard to check if an object is a valid EventHandlerClass
+       */
+      isValidEventClass(obj) {
+        if (typeof obj !== "function" && typeof obj !== "object") return false;
+        if (obj === null) return false;
+        const candidate = obj;
+        return candidate.metadata !== void 0 && typeof candidate.metadata.name === "string" && typeof candidate.metadata.displayName === "string" && candidate.validation !== void 0 && typeof candidate.validation.validateConfig === "function" && candidate.configuration !== void 0 && typeof candidate.configuration.configureInteractive === "function" && candidate.processing !== void 0 && typeof candidate.processing.processEvent === "function";
+      }
+      /**
+       * Get all valid event names from registered events
+       */
+      getValidEventNames() {
+        this.ensureInitialized();
+        return Array.from(this._events.keys());
+      }
+      /**
+       * Get event by name
+       */
+      getEventByName(name) {
+        this.ensureInitialized();
+        return this._events.get(name) ?? null;
+      }
+      /**
+       * Get all events for management UI
+       */
+      getEventsForManageUI() {
+        this.ensureInitialized();
+        const events = [];
+        for (const [name, eventClass] of this._events) {
+          events.push({
+            name: eventClass.metadata.displayName,
+            value: name,
+            description: eventClass.metadata.description
+          });
+        }
+        return events.sort((a, b) => a.name.localeCompare(b.name));
+      }
+      /**
+       * Get events that support tmux integration
+       */
+      getTmuxEnabledEvents() {
+        this.ensureInitialized();
+        const tmuxEvents = [];
+        for (const [name, eventClass] of this._events) {
+          const tmux = eventClass.tmux;
+          if (tmux) {
+            tmuxEvents.push({
+              name,
+              event: eventClass,
+              priority: tmux.getLayoutPriority()
+            });
+          }
+        }
+        return tmuxEvents.sort((a, b) => b.priority - a.priority);
+      }
+      /**
+       * Get all available events with their metadata
+       */
+      getAllEvents() {
+        this.ensureInitialized();
+        const events = [];
+        for (const [name, eventClass] of this._events) {
+          events.push({
+            name,
+            metadata: eventClass.metadata,
+            hasValidation: !!eventClass.validation,
+            hasConfiguration: !!eventClass.configuration,
+            hasProcessing: !!eventClass.processing,
+            hasTmux: !!eventClass.tmux,
+            hasHelp: !!eventClass.help
+          });
+        }
+        return events;
+      }
+      /**
+       * Ensure registry is initialized
+       */
+      ensureInitialized() {
+        if (!this._initialized) {
+          throw new Error("EventRegistry must be initialized before use. Call initialize() first.");
+        }
+      }
+      /**
+       * Clear the registry (useful for testing)
+       */
+      clear() {
+        this._events.clear();
+        this._initialized = false;
+      }
+    };
+    EventRegistry = new EventRegistryClass();
+  }
+});
+
+// src/types/constants.ts
+var IDE_CHOICES;
+var init_constants = __esm({
+  "src/types/constants.ts"() {
+    "use strict";
+    IDE_CHOICES = [
+      { name: "Visual Studio Code", value: "vscode" },
+      { name: "Visual Studio Code (code)", value: "code" },
+      { name: "IntelliJ IDEA", value: "idea" },
+      { name: "Atom", value: "atom" },
+      { name: "Sublime Text", value: "subl" },
+      { name: "Vim", value: "vim" },
+      { name: "Emacs", value: "emacs" }
+    ];
+  }
+});
+
+// src/commands/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  runInteractive: () => runInteractive
+});
+import { select, input as input4, checkbox, confirm as confirm3 } from "@inquirer/prompts";
+import File3 from "phylo";
+import deepAssign2 from "deep-assign";
+async function runInteractive(ctx) {
+  const { config, log, environment, suggestedName } = ctx;
+  showLogo(config);
+  log.log("");
+  const defaultName = suggestedName ?? (environment.$isProjectEnvironment ? environment.project.name : File3.cwd().name);
+  const fromUser = !!suggestedName;
+  await startInteractive(defaultName, fromUser, ctx);
+}
+function showLogo(config) {
+  const version = config.get("pkg")?.version ?? "unknown";
+  console.log(
+    `                      8\x1B[2m${" ".repeat(Math.max(15 - version.length - 1, 1)) + "v" + version}\x1B[22m
+Yb  db  dP .d8b. 8d8b 8.dP \x1B[92m.d8b. 8d8b.\x1B[0m
+ YbdPYbdP  8' .8 8P   88b  \x1B[92m8' .8 8P Y8\x1B[0m
+  YP  YP   \`Y8P' 8    8 Yb \x1B[92m\`Y8P' 8   8\x1B[0m`
+  );
+}
+async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
+  const { log, environment } = ctx;
+  log.debug(`Name '${defaultName}' was${fromUser ? "" : " not"} provided by the user`);
+  const question = getFirstQuestion(defaultName, fromUser, environment, showMain);
+  const action = await select(question);
+  switch (action) {
+    case "exit":
+      return;
+    case "more":
+      await startInteractive(defaultName, fromUser, ctx, true);
       return;
     case "init-project":
       await initProject(defaultName, fromUser, ctx);
@@ -200,17 +1154,17 @@ async function startInteractive(defaultName, fromUser, ctx, showMain = false) {
       await initBranch(defaultName, ctx);
       return;
     case "switch-project":
-      log.info("Switch to an existing project");
-      break;
+      await switchProject(ctx);
+      return;
     case "switch-branch":
-      log.info("Switch to an existing branch");
-      break;
+      await switchBranch(defaultName, ctx);
+      return;
     case "manage-projects":
-      log.info("Manage existing projects");
-      break;
+      await manageProjects(ctx);
+      return;
     case "manage-branches":
-      log.info("Manage existing branches");
-      break;
+      await manageBranches(defaultName, ctx);
+      return;
   }
 }
 function getFirstQuestion(defaultName, fromUser, environment, showMain) {
@@ -279,364 +1233,537 @@ async function initProject(defaultName, fromUser, ctx) {
       answerFile = defaultBase.join(answerFile.path);
     }
     try {
-      const canonical = answerFile.canonicalize();
-      if (canonical) {
-        answerFile = canonical;
-      } else {
-        answerFile = answerFile.absolutify();
+      const canonical = answerFile.canonicalize();
+      if (canonical) {
+        answerFile = canonical;
+      } else {
+        answerFile = answerFile.absolutify();
+      }
+    } catch {
+      answerFile = answerFile.absolutify();
+    }
+    basePath = answerFile.relativize(defaultBase.path).path;
+  }
+  const ide = await select({
+    message: "What is the IDE?",
+    choices: IDE_CHOICES
+  });
+  const selectedEvents = await checkbox({
+    message: "Which events should take place when opening?",
+    choices: [
+      { name: "Change terminal cwd to project path", value: "cwd", checked: true },
+      { name: "Open project in IDE", value: "ide", checked: true }
+    ]
+  });
+  const events = {
+    cwd: selectedEvents.includes("cwd"),
+    ide: selectedEvents.includes("ide")
+  };
+  const projectConfig = {
+    path: basePath,
+    ide,
+    events
+  };
+  projects[name] = projectConfig;
+  config.set("projects", projects);
+  log.info("Your project has been initialized.");
+  log.info(`Use 'workon ${name}' to start working!`);
+}
+async function initBranch(defaultName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branch = await input4({
+    message: "What is the name of the branch?",
+    validate: (value) => {
+      if (/\w+#\w+/.test(value)) return `Branch name can't contain the "#" sign`;
+      if (`${defaultName}#${value}` in projects) return "Branch already exists.";
+      return true;
+    }
+  });
+  const branchName = `${defaultName}#${branch}`;
+  const baseProject = projects[defaultName];
+  const { name: _excludedName, ...mergedConfig } = deepAssign2({}, baseProject, {
+    branch
+  });
+  const branchConfig = mergedConfig;
+  projects[branchName] = branchConfig;
+  config.set("projects", projects);
+  log.info("Your branch configuration has been initialized.");
+  log.info(`Use 'workon ${branchName}' to start working!`);
+}
+async function switchProject(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const baseProjects = Object.keys(projects).filter((name) => !name.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info('No projects configured yet. Use "Start a new project" to create one.');
+    return;
+  }
+  const projectName = await select({
+    message: "Select a project to open:",
+    choices: baseProjects.map((name) => ({
+      name: `${name} (${projects[name].path})`,
+      value: name
+    }))
+  });
+  await openProject(projectName, ctx);
+}
+async function switchBranch(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info(`No branch configurations found for '${projectName}'.`);
+    log.info('Use "Start a branch" to create one.');
+    return;
+  }
+  const branchConfig = await select({
+    message: "Select a branch configuration:",
+    choices: branches.map((name) => ({
+      name: name.substring(branchPrefix.length),
+      value: name
+    }))
+  });
+  await openProject(branchConfig, ctx);
+}
+async function manageProjects(ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const hasProjects = Object.keys(projects).length > 0;
+  const choices = [
+    { name: "Create new project", value: "create" },
+    ...hasProjects ? [
+      { name: "Edit project", value: "edit" },
+      { name: "Delete project", value: "delete" },
+      { name: "List projects", value: "list" }
+    ] : [],
+    { name: "Back", value: "back" }
+  ];
+  const action = await select({
+    message: "Manage projects:",
+    choices
+  });
+  switch (action) {
+    case "create":
+      await createProjectManage(ctx);
+      break;
+    case "edit":
+      await editProjectManage(ctx);
+      break;
+    case "delete":
+      await deleteProjectManage(ctx);
+      break;
+    case "list":
+      listProjectsManage(ctx);
+      break;
+    case "back":
+      return;
+  }
+  await manageProjects(ctx);
+}
+async function manageBranches(projectName, ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  const choices = [
+    { name: "Create new branch config", value: "create" },
+    ...branches.length > 0 ? [
+      { name: "Edit branch config", value: "edit" },
+      { name: "Delete branch config", value: "delete" },
+      { name: "List branch configs", value: "list" }
+    ] : [],
+    { name: "Back", value: "back" }
+  ];
+  const action = await select({
+    message: `Manage branches for '${projectName}':`,
+    choices
+  });
+  switch (action) {
+    case "create":
+      await initBranch(projectName, ctx);
+      break;
+    case "edit":
+      await editBranchManage(projectName, ctx);
+      break;
+    case "delete":
+      await deleteBranchManage(projectName, ctx);
+      break;
+    case "list":
+      listBranchesManage(projectName, ctx);
+      break;
+    case "back":
+      return;
+  }
+  await manageBranches(projectName, ctx);
+}
+async function openProject(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  if (!(projectName in projects)) {
+    log.error(`Project '${projectName}' not found.`);
+    return;
+  }
+  const projectConfig = projects[projectName];
+  const projectCfg = { ...projectConfig, name: projectName };
+  const projectEnv = ProjectEnvironment.load(projectCfg, config.getDefaults());
+  log.info(`Opening project '${projectName}'...`);
+  const events = Object.keys(projectConfig.events).filter(
+    (e) => projectConfig.events[e]
+  );
+  for (const event of events) {
+    const eventHandler = EventRegistry.getEventByName(event);
+    if (eventHandler) {
+      await eventHandler.processing.processEvent({
+        project: projectEnv.project,
+        isShellMode: false,
+        shellCommands: []
+      });
+    }
+  }
+}
+async function createProjectManage(ctx) {
+  const { config, log } = ctx;
+  const defaults = config.getDefaults();
+  const projects = config.getProjects();
+  const name = await input4({
+    message: "Project name:",
+    validate: (value) => {
+      if (!value.trim()) return "Name is required";
+      if (!/^[\w-]+$/.test(value))
+        return "Name can only contain letters, numbers, underscores, and hyphens";
+      if (value in projects) return "Project already exists";
+      return true;
+    }
+  });
+  const defaultPath = defaults?.base ? File3.from(defaults.base).join(name).path : name;
+  const pathInput = await input4({
+    message: "Project path:",
+    default: defaultPath
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File3.from(defaults.base);
+    const pathFile = File3.from(pathInput);
+    try {
+      if (pathFile.isAbsolute()) {
+        relativePath = pathFile.relativize(baseDir.path).path;
       }
     } catch {
-      answerFile = answerFile.absolutify();
+      relativePath = pathInput;
     }
-    basePath = answerFile.relativize(defaultBase.path).path;
   }
   const ide = await select({
-    message: "What is the IDE?",
+    message: "Select IDE:",
     choices: IDE_CHOICES
   });
+  const availableEvents = EventRegistry.getEventsForManageUI();
   const selectedEvents = await checkbox({
-    message: "Which events should take place when opening?",
-    choices: [
-      { name: "Change terminal cwd to project path", value: "cwd", checked: true },
-      { name: "Open project in IDE", value: "ide", checked: true }
-    ]
+    message: "Select events to enable:",
+    choices: availableEvents.map((e) => ({
+      name: `${e.name} - ${e.description}`,
+      value: e.value,
+      checked: e.value === "cwd" || e.value === "ide"
+    }))
   });
-  const events = {
-    cwd: selectedEvents.includes("cwd"),
-    ide: selectedEvents.includes("ide")
-  };
+  const events = {};
+  for (const eventName of selectedEvents) {
+    const eventHandler = EventRegistry.getEventByName(eventName);
+    if (eventHandler) {
+      const eventConfig = await eventHandler.configuration.configureInteractive();
+      events[eventName] = eventConfig;
+    }
+  }
   const projectConfig = {
-    path: basePath,
+    path: relativePath,
     ide,
     events
   };
-  projects[name] = projectConfig;
-  config.set("projects", projects);
-  log.info("Your project has been initialized.");
-  log.info(`Use 'workon ${name}' to start working!`);
+  const confirmed = await confirm3({
+    message: "Save this project?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, projectConfig);
+    log.info(`Project '${name}' created successfully!`);
+  }
 }
-async function initBranch(defaultName, ctx) {
+async function editProjectManage(ctx) {
   const { config, log } = ctx;
   const projects = config.getProjects();
-  const branch = await input4({
-    message: "What is the name of the branch?",
-    validate: (value) => {
-      if (/\w+#\w+/.test(value)) return `Branch name can't contain the "#" sign`;
-      if (`${defaultName}#${value}` in projects) return "Branch already exists.";
-      return true;
-    }
-  });
-  const branchName = `${defaultName}#${branch}`;
-  const baseProject = projects[defaultName];
-  const branchConfig = deepAssign2({}, baseProject, { branch });
-  delete branchConfig.name;
-  projects[branchName] = branchConfig;
-  config.set("projects", projects);
-  log.info("Your branch configuration has been initialized.");
-  log.info(`Use 'workon ${branchName}' to start working!`);
-}
-var IDE_CHOICES;
-var init_interactive = __esm({
-  "src/commands/interactive.ts"() {
-    "use strict";
-    IDE_CHOICES = [
-      { name: "Visual Studio Code", value: "vscode" },
-      { name: "IntelliJ IDEA", value: "idea" },
-      { name: "Atom", value: "atom" }
-    ];
-  }
-});
-
-// src/commands/index.ts
-import { Command as Command8 } from "commander";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import loog from "loog";
-import omelette from "omelette";
-import File7 from "phylo";
-
-// src/lib/config.ts
-import Conf from "conf";
-var TRANSIENT_PROPS = ["pkg", "work"];
-var Config = class {
-  _transient = {};
-  _store;
-  constructor() {
-    this._store = new Conf({
-      projectName: "workon"
-    });
+  const defaults = config.getDefaults();
+  const baseProjects = Object.keys(projects).filter((name2) => !name2.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info("No projects to edit.");
+    return;
   }
-  get(key, defaultValue) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      return this._transient[key] ?? defaultValue;
+  const name = await select({
+    message: "Select project to edit:",
+    choices: baseProjects.map((n) => ({ name: n, value: n }))
+  });
+  const project = projects[name];
+  const pathInput = await input4({
+    message: "Project path:",
+    default: project.path
+  });
+  let relativePath = pathInput;
+  if (defaults?.base) {
+    const baseDir = File3.from(defaults.base);
+    const pathFile = File3.from(pathInput);
+    try {
+      if (pathFile.isAbsolute()) {
+        relativePath = pathFile.relativize(baseDir.path).path;
+      }
+    } catch {
+      relativePath = pathInput;
     }
-    return this._store.get(key, defaultValue);
   }
-  set(key, value) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      this._transient[key] = value;
-    } else {
-      if (value === void 0) {
-        this._store.set(key, value);
+  const ide = await select({
+    message: "Select IDE:",
+    choices: IDE_CHOICES,
+    default: project.ide || "vscode"
+  });
+  const keepEvents = await confirm3({
+    message: "Keep existing event configuration?",
+    default: true
+  });
+  let events = project.events;
+  if (!keepEvents) {
+    const availableEvents = EventRegistry.getEventsForManageUI();
+    const currentEvents = Object.keys(project.events);
+    const selectedEvents = await checkbox({
+      message: "Select events to enable:",
+      choices: availableEvents.map((e) => ({
+        name: `${e.name} - ${e.description}`,
+        value: e.value,
+        checked: currentEvents.includes(e.value)
+      }))
+    });
+    events = {};
+    for (const eventName of selectedEvents) {
+      if (project.events[eventName]) {
+        events[eventName] = project.events[eventName];
       } else {
-        this._store.set(key, value);
+        const eventHandler = EventRegistry.getEventByName(eventName);
+        if (eventHandler) {
+          const eventConfig = await eventHandler.configuration.configureInteractive();
+          events[eventName] = eventConfig;
+        }
       }
     }
   }
-  has(key) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      return Object.prototype.hasOwnProperty.call(this._transient, key);
-    }
-    return this._store.has(key);
-  }
-  delete(key) {
-    const rootKey = key.split(".")[0];
-    if (TRANSIENT_PROPS.includes(rootKey)) {
-      delete this._transient[key];
-    } else {
-      this._store.delete(key);
-    }
-  }
-  getProjects() {
-    return this.get("projects") ?? {};
-  }
-  getProject(name) {
-    const projects = this.getProjects();
-    return projects[name];
-  }
-  setProject(name, config) {
-    const projects = this.getProjects();
-    projects[name] = config;
-    this.set("projects", projects);
-  }
-  deleteProject(name) {
-    const projects = this.getProjects();
-    delete projects[name];
-    this.set("projects", projects);
-  }
-  getDefaults() {
-    return this.get("project_defaults");
-  }
-  setDefaults(defaults) {
-    this.set("project_defaults", defaults);
-  }
-  get path() {
-    return this._store.path;
+  const updatedConfig = {
+    path: relativePath,
+    ide,
+    events
+  };
+  const confirmed = await confirm3({
+    message: "Save changes?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(name, updatedConfig);
+    log.info(`Project '${name}' updated successfully!`);
   }
-  get store() {
-    return this._store.store;
+}
+async function deleteProjectManage(ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const baseProjects = Object.keys(projects).filter((name2) => !name2.includes("#"));
+  if (baseProjects.length === 0) {
+    log.info("No projects to delete.");
+    return;
   }
-};
-
-// src/lib/environment.ts
-import File2 from "phylo";
-import { simpleGit } from "simple-git";
-
-// src/lib/project.ts
-import File from "phylo";
-import deepAssign from "deep-assign";
-var Project = class {
-  name;
-  _base;
-  _path;
-  _ide;
-  _events = {};
-  _branch;
-  _homepage;
-  _defaults;
-  _initialCfg;
-  constructor(name, cfg, defaults) {
-    this._defaults = defaults ?? { base: "" };
-    this._initialCfg = { path: name, events: {}, ...cfg };
-    this.name = cfg?.name ?? name;
-    const merged = deepAssign({}, this._defaults, this._initialCfg);
-    if (merged.base) {
-      this.base = merged.base;
-    }
-    if (merged.path) {
-      this.path = merged.path;
-    }
-    if (merged.ide) {
-      this._ide = merged.ide;
-    }
-    if (merged.events) {
-      this._events = merged.events;
-    }
-    if (merged.branch) {
-      this._branch = merged.branch;
-    }
-    if (merged.homepage) {
-      this._homepage = merged.homepage;
+  const name = await select({
+    message: "Select project to delete:",
+    choices: baseProjects.map((n) => ({ name: n, value: n }))
+  });
+  const branchPrefix = `${name}#`;
+  const branches = Object.keys(projects).filter((n) => n.startsWith(branchPrefix));
+  if (branches.length > 0) {
+    log.warn(`This project has ${branches.length} branch configuration(s).`);
+    const deleteAll = await confirm3({
+      message: "Delete all branch configurations as well?",
+      default: false
+    });
+    if (deleteAll) {
+      for (const branch of branches) {
+        config.deleteProject(branch);
+      }
     }
   }
-  set base(path) {
-    this._base = File.from(path).absolutify();
-  }
-  get base() {
-    return this._base;
-  }
-  set ide(cmd) {
-    this._ide = cmd;
-  }
-  get ide() {
-    return this._ide;
-  }
-  set events(eventCfg) {
-    this._events = eventCfg;
-  }
-  get events() {
-    return this._events;
-  }
-  set path(path) {
-    if (this._base) {
-      this._path = this._base.join(path);
-    } else {
-      this._path = File.from(path);
-    }
-    this._path = this._path.absolutify();
+  const confirmed = await confirm3({
+    message: `Are you sure you want to delete '${name}'?`,
+    default: false
+  });
+  if (confirmed) {
+    config.deleteProject(name);
+    log.info(`Project '${name}' deleted.`);
   }
-  get path() {
-    if (!this._path) {
-      throw new Error("Project path not set");
+}
+function listProjectsManage(ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const defaults = config.getDefaults();
+  console.log("\nConfigured projects:\n");
+  const baseProjects = Object.keys(projects).filter((name) => !name.includes("#"));
+  for (const name of baseProjects) {
+    const project = projects[name];
+    const fullPath = defaults?.base ? File3.from(defaults.base).join(project.path).path : project.path;
+    console.log(`  ${name}`);
+    console.log(`    Path: ${fullPath}`);
+    console.log(`    IDE: ${project.ide || "not set"}`);
+    console.log(`    Events: ${Object.keys(project.events).join(", ") || "none"}`);
+    const branchPrefix = `${name}#`;
+    const branches = Object.keys(projects).filter((n) => n.startsWith(branchPrefix));
+    if (branches.length > 0) {
+      console.log(`    Branches: ${branches.length}`);
     }
-    return this._path;
-  }
-  set branch(branch) {
-    this._branch = branch;
+    console.log();
   }
-  get branch() {
-    return this._branch;
+}
+async function editBranchManage(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info("No branch configurations to edit.");
+    return;
   }
-  set homepage(url) {
-    this._homepage = url;
+  const branchName = await select({
+    message: "Select branch configuration to edit:",
+    choices: branches.map((n) => ({
+      name: n.substring(branchPrefix.length),
+      value: n
+    }))
+  });
+  const branch = projects[branchName];
+  const keepEvents = await confirm3({
+    message: "Keep existing event configuration?",
+    default: true
+  });
+  let events = branch.events;
+  if (!keepEvents) {
+    const availableEvents = EventRegistry.getEventsForManageUI();
+    const currentEvents = Object.keys(branch.events);
+    const selectedEvents = await checkbox({
+      message: "Select events to enable:",
+      choices: availableEvents.map((e) => ({
+        name: `${e.name} - ${e.description}`,
+        value: e.value,
+        checked: currentEvents.includes(e.value)
+      }))
+    });
+    events = {};
+    for (const eventName of selectedEvents) {
+      if (branch.events[eventName]) {
+        events[eventName] = branch.events[eventName];
+      } else {
+        const eventHandler = EventRegistry.getEventByName(eventName);
+        if (eventHandler) {
+          const eventConfig = await eventHandler.configuration.configureInteractive();
+          events[eventName] = eventConfig;
+        }
+      }
+    }
   }
-  get homepage() {
-    return this._homepage;
+  const updatedConfig = {
+    ...branch,
+    events
+  };
+  const confirmed = await confirm3({
+    message: "Save changes?",
+    default: true
+  });
+  if (confirmed) {
+    config.setProject(branchName, updatedConfig);
+    log.info(`Branch configuration '${branchName}' updated successfully!`);
   }
-  static $isProject = true;
-  $isProject = true;
-};
-
-// src/lib/environment.ts
-var BaseEnvironment = class {
-  $isProjectEnvironment = false;
-};
-var ProjectEnvironment = class _ProjectEnvironment {
-  $isProjectEnvironment = true;
-  project;
-  constructor(projectCfg) {
-    this.project = new Project(projectCfg.name, projectCfg);
+}
+async function deleteBranchManage(projectName, ctx) {
+  const { config, log } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  if (branches.length === 0) {
+    log.info("No branch configurations to delete.");
+    return;
   }
-  static load(cfg, defaults) {
-    const project = new Project(cfg.name, cfg, defaults);
-    return new _ProjectEnvironment({ ...cfg, name: project.name });
+  const branchName = await select({
+    message: "Select branch configuration to delete:",
+    choices: branches.map((n) => ({
+      name: n.substring(branchPrefix.length),
+      value: n
+    }))
+  });
+  const confirmed = await confirm3({
+    message: `Are you sure you want to delete '${branchName}'?`,
+    default: false
+  });
+  if (confirmed) {
+    config.deleteProject(branchName);
+    log.info(`Branch configuration '${branchName}' deleted.`);
   }
-};
-var EnvironmentRecognizer = class {
-  static config;
-  static log;
-  static projects = [];
-  static configured = false;
-  static configure(config, log) {
-    if (this.configured) {
-      return;
-    }
-    this.config = config;
-    this.log = log;
-    this.configured = true;
-  }
-  static async recognize(dir) {
-    this.ensureConfigured();
-    const theDir = File2.from(dir).canonicalize();
-    this.log.debug("Directory to recognize is: " + theDir.canonicalPath());
-    const allProjects = this.getAllProjects();
-    const matching = allProjects.filter((p) => p.path.canonicalPath() === theDir.path);
-    if (matching.length === 0) {
-      return new BaseEnvironment();
-    }
-    this.log.debug(`Found ${matching.length} matching projects`);
-    const base = matching.find((p) => !p.name.includes("#")) ?? matching[0];
-    this.log.debug("Base project is: " + base.name);
-    const gitDir = base.path.up(".git");
-    if (gitDir) {
-      try {
-        const git = simpleGit(gitDir.path);
-        const branchSummary = await git.branchLocal();
-        base.branch = branchSummary.current;
-      } catch {
-      }
-    }
-    return this.getProjectEnvironment(base, matching);
+}
+function listBranchesManage(projectName, ctx) {
+  const { config } = ctx;
+  const projects = config.getProjects();
+  const branchPrefix = `${projectName}#`;
+  const branches = Object.keys(projects).filter((name) => name.startsWith(branchPrefix));
+  console.log(`
+Branch configurations for '${projectName}':
+`);
+  for (const branchName of branches) {
+    const branch = projects[branchName];
+    const shortName = branchName.substring(branchPrefix.length);
+    console.log(`  ${shortName}`);
+    console.log(`    Events: ${Object.keys(branch.events).join(", ") || "none"}`);
+    console.log();
   }
-  static getAllProjects(refresh = false) {
-    if (this.projects.length > 0 && !refresh) {
-      return this.projects;
-    }
-    const defaults = this.config.getDefaults();
-    if (!defaults?.base) {
-      this.projects = [];
-      return this.projects;
-    }
-    const baseDir = File2.from(defaults.base);
-    const projectsMap = this.config.getProjects();
-    this.projects = Object.entries(projectsMap).map(([name, project]) => ({
-      ...project,
-      name,
-      path: baseDir.join(project.path)
-    }));
-    return this.projects;
-  }
-  static getProjectEnvironment(base, _matching) {
-    const exactName = `${base.name}#${base.branch}`;
-    const exactProj = this.projects.find((p) => p.name === exactName);
-    const toProjectConfig = (p) => ({
-      name: p.name,
-      path: p.path.path,
-      // Convert PhyloFile to string path
-      ide: p.ide,
-      homepage: p.homepage,
-      events: p.events,
-      branch: p.branch,
-      exactName
-    });
-    if (exactProj) {
-      return new ProjectEnvironment({ ...toProjectConfig(exactProj), branch: base.branch });
-    }
-    return new ProjectEnvironment(toProjectConfig(base));
-  }
-  static ensureConfigured() {
-    if (!this.configured) {
-      this.config = new Config();
-      this.log = {
-        debug: () => {
-        },
-        info: () => {
-        },
-        log: () => {
-        },
-        warn: () => {
-        },
-        error: () => {
-        },
-        setLogLevel: () => {
-        }
-      };
-      this.configured = true;
-    }
+}
+var init_interactive = __esm({
+  "src/commands/interactive.ts"() {
+    "use strict";
+    init_environment();
+    init_registry();
+    init_constants();
   }
-};
+});
+
+// src/commands/index.ts
+init_config();
+init_environment();
+init_registry();
+import { Command as Command8 } from "commander";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import loog from "loog";
+import omelette from "omelette";
+import File7 from "phylo";
 
 // src/commands/open.ts
+init_environment();
 import { Command } from "commander";
 import File4 from "phylo";
 
 // src/lib/tmux.ts
-import { exec as execCallback, spawn } from "child_process";
+import { exec as execCallback, spawn as spawn7 } from "child_process";
 import { promisify } from "util";
+
+// src/lib/sanitize.ts
+function sanitizeForShell(input6) {
+  if (!input6) return "";
+  return input6.replace(/[^a-zA-Z0-9_\-.]/g, "_");
+}
+function escapeForSingleQuotes(input6) {
+  if (!input6) return "";
+  return input6.replace(/'/g, "'\\''");
+}
+
+// src/lib/tmux.ts
 var exec = promisify(execCallback);
 var TmuxManager = class {
   sessionPrefix = "workon-";
@@ -650,755 +1777,176 @@ var TmuxManager = class {
   }
   async sessionExists(sessionName) {
     try {
-      await exec(`tmux has-session -t "${sessionName}"`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  getSessionName(projectName) {
-    return `${this.sessionPrefix}${projectName}`;
-  }
-  async killSession(sessionName) {
-    try {
-      await exec(`tmux kill-session -t "${sessionName}"`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async createSplitSession(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
-    await exec(`tmux set-option -t "${sessionName}:0.2" remain-on-exit on`);
-    await exec(`tmux resize-pane -t "${sessionName}:0.2" -y 10`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`);
-    await exec(`tmux set-option -t "${sessionName}:0.1" remain-on-exit on`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async attachToSession(sessionName) {
-    if (process.env.TMUX) {
-      await exec(`tmux switch-client -t "${sessionName}"`);
-    } else {
-      const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || !!process.env.ITERM_SESSION_ID;
-      const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
-      if (useiTermIntegration) {
-        spawn("tmux", ["-CC", "attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      } else {
-        spawn("tmux", ["attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      }
-    }
-  }
-  buildShellCommands(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    return [
-      `# Create tmux split session for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    return [
-      `# Create tmux three-pane session for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-      `tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`,
-      `tmux set-option -t "${sessionName}:0.2" remain-on-exit on`,
-      `tmux resize-pane -t "${sessionName}:0.2" -y 10`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    return [
-      `# Create tmux two-pane session with npm for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}"`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`,
-      `tmux set-option -t "${sessionName}:0.1" remain-on-exit on`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  getAttachCommand(sessionName) {
-    if (process.env.TMUX) {
-      return `tmux switch-client -t "${sessionName}"`;
-    }
-    const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || process.env.ITERM_SESSION_ID;
-    const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
-    if (useiTermIntegration) {
-      return `tmux -CC attach-session -t "${sessionName}"`;
-    }
-    return `tmux attach-session -t "${sessionName}"`;
-  }
-  async listWorkonSessions() {
-    try {
-      const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
-      return stdout.trim().split("\n").filter((session) => session.startsWith(this.sessionPrefix)).map((session) => session.replace(this.sessionPrefix, ""));
-    } catch {
-      return [];
-    }
-  }
-};
-
-// src/events/core/cwd.ts
-import { spawn as spawn2 } from "child_process";
-var CwdEvent = class {
-  static get metadata() {
-    return {
-      name: "cwd",
-      displayName: "Change directory (cwd)",
-      description: "Change current working directory to project path",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "cwd config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const projectPath = project.path.path;
-        if (isShellMode) {
-          shellCommands.push(`cd "${projectPath}"`);
-        } else {
-          const shell = process.env.SHELL || "/bin/bash";
-          spawn2(shell, [], {
-            cwd: projectPath,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const projectPath = context.project.path.path;
-        return [`cd "${projectPath}"`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "cwd: true | false",
-      description: "Change the current working directory to the project path",
-      examples: [
-        { config: true, description: "Enable directory change" },
-        { config: false, description: "Disable directory change" }
-      ]
-    };
-  }
-};
-
-// src/events/core/ide.ts
-import { spawn as spawn3 } from "child_process";
-var IdeEvent = class {
-  static get metadata() {
-    return {
-      name: "ide",
-      displayName: "Open in IDE",
-      description: "Open project in configured IDE/editor",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "ide config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const projectPath = project.path.path;
-        const ide = project.ide || "code";
-        if (isShellMode) {
-          shellCommands.push(`${ide} "${projectPath}" &`);
-        } else {
-          spawn3(ide, [projectPath], {
-            detached: true,
-            stdio: "ignore"
-          }).unref();
-        }
-      },
-      generateShellCommand(context) {
-        const projectPath = context.project.path.path;
-        const ide = context.project.ide || "code";
-        return [`${ide} "${projectPath}" &`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "ide: true | false",
-      description: "Open the project in the configured IDE",
-      examples: [
-        { config: true, description: "Enable IDE opening" },
-        { config: false, description: "Disable IDE opening" }
-      ]
-    };
-  }
-};
-
-// src/events/core/web.ts
-import { spawn as spawn4 } from "child_process";
-import { platform } from "os";
-var WebEvent = class _WebEvent {
-  static get metadata() {
-    return {
-      name: "web",
-      displayName: "Open homepage in browser",
-      description: "Open project homepage in web browser",
-      category: "core",
-      requiresTmux: false,
-      dependencies: []
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        return "web config must be a boolean (true/false)";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        return true;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static getOpenCommand() {
-    const os = platform();
-    switch (os) {
-      case "darwin":
-        return "open";
-      case "win32":
-        return "start";
-      default:
-        return "xdg-open";
-    }
-  }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const homepage = project.homepage;
-        if (!homepage) {
-          console.warn("No homepage configured for project");
-          return;
-        }
-        const openCmd = _WebEvent.getOpenCommand();
-        if (isShellMode) {
-          shellCommands.push(`${openCmd} "${homepage}" &`);
-        } else {
-          spawn4(openCmd, [homepage], {
-            detached: true,
-            stdio: "ignore"
-          }).unref();
-        }
-      },
-      generateShellCommand(context) {
-        const homepage = context.project.homepage;
-        if (!homepage) return [];
-        const openCmd = _WebEvent.getOpenCommand();
-        return [`${openCmd} "${homepage}" &`];
-      }
-    };
-  }
-  static get tmux() {
-    return null;
-  }
-  static get help() {
-    return {
-      usage: "web: true | false",
-      description: "Open the project homepage in the default browser",
-      examples: [
-        { config: true, description: "Enable browser opening" },
-        { config: false, description: "Disable browser opening" }
-      ]
-    };
-  }
-};
-
-// src/events/extensions/claude.ts
-import { spawn as spawn5 } from "child_process";
-import { input, confirm } from "@inquirer/prompts";
-var ClaudeEvent = class _ClaudeEvent {
-  static get metadata() {
-    return {
-      name: "claude",
-      displayName: "Launch Claude Code",
-      description: "Launch Claude Code with optional flags and configuration",
-      category: "development",
-      requiresTmux: true,
-      dependencies: ["claude"]
-    };
-  }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        if (typeof config === "object" && config !== null) {
-          const cfg = config;
-          if (cfg.flags !== void 0) {
-            if (!Array.isArray(cfg.flags)) {
-              return "claude.flags must be an array of strings";
-            }
-            for (const flag of cfg.flags) {
-              if (typeof flag !== "string") {
-                return "claude.flags must contain only strings";
-              }
-              if (!flag.startsWith("-")) {
-                return `Invalid flag "${flag}": flags must start with - or --`;
-              }
-            }
-          }
-          if (cfg.split_terminal !== void 0 && typeof cfg.split_terminal !== "boolean") {
-            return "claude.split_terminal must be a boolean";
-          }
-          return true;
-        }
-        return "claude config must be a boolean or object with flags/split_terminal";
-      }
-    };
-  }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        const useAdvanced = await confirm({
-          message: "Configure advanced Claude options?",
-          default: false
-        });
-        if (!useAdvanced) {
-          return true;
-        }
-        const flagsInput = await input({
-          message: "Enter Claude flags (comma-separated, e.g., --resume, --debug):",
-          default: ""
-        });
-        const flags = flagsInput.split(",").map((f) => f.trim()).filter((f) => f.length > 0 && f.startsWith("-"));
-        const splitTerminal = await confirm({
-          message: "Use split terminal layout (Claude + shell)?",
-          default: true
-        });
-        if (flags.length === 0 && !splitTerminal) {
-          return true;
-        }
-        const config = {};
-        if (flags.length > 0) config.flags = flags;
-        if (splitTerminal) config.split_terminal = splitTerminal;
-        return config;
-      },
-      getDefaultConfig() {
-        return true;
-      }
-    };
-  }
-  static getClaudeCommand(config) {
-    if (typeof config === "boolean" || config === void 0) {
-      return "claude";
+      await exec(`tmux has-session -t '${escapeForSingleQuotes(sessionName)}'`);
+      return true;
+    } catch {
+      return false;
     }
-    const flags = config.flags || [];
-    return flags.length > 0 ? `claude ${flags.join(" ")}` : "claude";
   }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const claudeConfig = project.events.claude;
-        const claudeCommand = _ClaudeEvent.getClaudeCommand(claudeConfig);
-        if (isShellMode) {
-          shellCommands.push(claudeCommand);
-        } else {
-          const args = claudeCommand.split(" ").slice(1);
-          spawn5("claude", args, {
-            cwd: project.path.path,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const claudeConfig = context.project.events.claude;
-        return [_ClaudeEvent.getClaudeCommand(claudeConfig)];
-      }
-    };
+  getSessionName(projectName) {
+    return `${this.sessionPrefix}${sanitizeForShell(projectName)}`;
   }
-  static get tmux() {
-    return {
-      getLayoutPriority() {
-        return 100;
-      },
-      contributeToLayout(enabledCommands) {
-        if (enabledCommands.includes("npm")) {
-          return "three-pane";
-        }
-        return "split";
-      }
-    };
+  async killSession(sessionName) {
+    try {
+      await exec(`tmux kill-session -t '${escapeForSingleQuotes(sessionName)}'`);
+      return true;
+    } catch {
+      return false;
+    }
   }
-  static get help() {
-    return {
-      usage: "claude: true | { flags: string[], split_terminal: boolean }",
-      description: "Launch Claude Code in the project directory",
-      examples: [
-        { config: true, description: "Launch Claude with defaults" },
-        { config: { flags: ["--resume"] }, description: "Resume previous session" },
-        {
-          config: { flags: ["--model", "opus"], split_terminal: true },
-          description: "Use Opus model with split terminal"
-        }
-      ]
-    };
+  async createSplitSession(projectName, projectPath, claudeArgs = []) {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+    await exec(
+      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
+    );
+    await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
+    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+    return sessionName;
   }
-};
-
-// src/events/extensions/docker.ts
-import { spawn as spawn6 } from "child_process";
-import { input as input2 } from "@inquirer/prompts";
-var DockerEvent = class _DockerEvent {
-  static get metadata() {
-    return {
-      name: "docker",
-      displayName: "Docker container management",
-      description: "Start/stop Docker containers for the project",
-      category: "development",
-      requiresTmux: false,
-      dependencies: ["docker"]
-    };
+  async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+    await exec(
+      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
+    );
+    await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
+    await exec(
+      `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`
+    );
+    await exec(`tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`);
+    await exec(`tmux resize-pane -t '${escapedSession}:0.2' -y 10`);
+    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+    return sessionName;
   }
-  static get validation() {
-    return {
-      validateConfig(config) {
-        if (typeof config === "boolean" || config === "true" || config === "false") {
-          return true;
-        }
-        if (typeof config === "string") {
-          return true;
-        }
-        if (typeof config === "object" && config !== null) {
-          const cfg = config;
-          if (cfg.compose_file !== void 0 && typeof cfg.compose_file !== "string") {
-            return "docker.compose_file must be a string";
-          }
-          if (cfg.services !== void 0) {
-            if (!Array.isArray(cfg.services)) {
-              return "docker.services must be an array";
-            }
-            for (const service of cfg.services) {
-              if (typeof service !== "string") {
-                return "docker.services must contain only strings";
-              }
-            }
-          }
-          return true;
-        }
-        return "docker config must be a boolean, string (compose file), or object";
-      }
-    };
+  async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+    if (await this.sessionExists(sessionName)) {
+      await this.killSession(sessionName);
+    }
+    await exec(`tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`);
+    await exec(
+      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`
+    );
+    await exec(`tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`);
+    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+    return sessionName;
   }
-  static get configuration() {
-    return {
-      async configureInteractive() {
-        const composeFile = await input2({
-          message: "Enter docker-compose file path:",
-          default: "docker-compose.yml"
+  async attachToSession(sessionName) {
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    if (process.env.TMUX) {
+      await exec(`tmux switch-client -t '${escapedSession}'`);
+    } else {
+      const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || !!process.env.ITERM_SESSION_ID;
+      const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+      if (useiTermIntegration) {
+        spawn7("tmux", ["-CC", "attach-session", "-t", sessionName], {
+          stdio: "inherit",
+          detached: true
         });
-        const servicesInput = await input2({
-          message: "Enter services to start (comma-separated, leave empty for all):",
-          default: ""
+      } else {
+        spawn7("tmux", ["attach-session", "-t", sessionName], {
+          stdio: "inherit",
+          detached: true
         });
-        const services = servicesInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-        if (composeFile === "docker-compose.yml" && services.length === 0) {
-          return { compose_file: "docker-compose.yml" };
-        }
-        if (services.length === 0) {
-          return composeFile;
-        }
-        return {
-          compose_file: composeFile,
-          services
-        };
-      },
-      getDefaultConfig() {
-        return { compose_file: "docker-compose.yml" };
       }
-    };
-  }
-  static getDockerCommand(config) {
-    if (typeof config === "boolean" || config === void 0) {
-      return "docker-compose up -d";
     }
-    if (typeof config === "string") {
-      return `docker-compose -f ${config} up -d`;
-    }
-    const composeFile = config.compose_file || "docker-compose.yml";
-    const services = config.services?.join(" ") || "";
-    return `docker-compose -f ${composeFile} up -d ${services}`.trim();
   }
-  static get processing() {
-    return {
-      async processEvent(context) {
-        const { project, isShellMode, shellCommands } = context;
-        const dockerConfig = project.events.docker;
-        const dockerCommand = _DockerEvent.getDockerCommand(
-          dockerConfig
-        );
-        if (isShellMode) {
-          shellCommands.push(dockerCommand);
-        } else {
-          const [cmd, ...args] = dockerCommand.split(" ");
-          spawn6(cmd, args, {
-            cwd: project.path.path,
-            stdio: "inherit"
-          });
-        }
-      },
-      generateShellCommand(context) {
-        const dockerConfig = context.project.events.docker;
-        return [_DockerEvent.getDockerCommand(dockerConfig)];
-      }
-    };
+  buildShellCommands(projectName, projectPath, claudeArgs = []) {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+    return [
+      `# Create tmux split session for ${sanitizeForShell(projectName)}`,
+      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
+      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
+      `tmux select-pane -t '${escapedSession}:0.0'`,
+      this.getAttachCommand(sessionName)
+    ];
   }
-  static get tmux() {
-    return null;
+  buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+    return [
+      `# Create tmux three-pane session for ${sanitizeForShell(projectName)}`,
+      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
+      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
+      `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`,
+      `tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`,
+      `tmux resize-pane -t '${escapedSession}:0.2' -y 10`,
+      `tmux select-pane -t '${escapedSession}:0.0'`,
+      this.getAttachCommand(sessionName)
+    ];
   }
-  static get help() {
-    return {
-      usage: 'docker: true | "compose-file.yml" | { compose_file: string, services?: string[] }',
-      description: "Start Docker containers for the project",
-      examples: [
-        { config: true, description: "Use default docker-compose.yml" },
-        { config: "docker-compose.dev.yml", description: "Use custom compose file" },
-        {
-          config: { compose_file: "docker-compose.yml", services: ["web", "db"] },
-          description: "Start specific services"
-        }
-      ]
-    };
+  buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
+    const sessionName = this.getSessionName(projectName);
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    const escapedPath = escapeForSingleQuotes(projectPath);
+    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+    return [
+      `# Create tmux two-pane session with npm for ${sanitizeForShell(projectName)}`,
+      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`,
+      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`,
+      `tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`,
+      `tmux select-pane -t '${escapedSession}:0.0'`,
+      this.getAttachCommand(sessionName)
+    ];
   }
-};
-
-// src/events/registry.ts
-init_npm();
-var ALL_EVENTS = [CwdEvent, IdeEvent, WebEvent, ClaudeEvent, DockerEvent, NpmEvent];
-var EventRegistryClass = class {
-  _events = /* @__PURE__ */ new Map();
-  _initialized = false;
-  /**
-   * Initialize the registry by registering all events
-   */
-  async initialize() {
-    if (this._initialized) return;
-    this.registerEvents();
-    this._initialized = true;
-  }
-  /**
-   * Register all event classes
-   */
-  registerEvents() {
-    for (const EventClass of ALL_EVENTS) {
-      if (this.isValidEvent(EventClass)) {
-        const metadata = EventClass.metadata;
-        this._events.set(metadata.name, EventClass);
-      }
+  getAttachCommand(sessionName) {
+    const escapedSession = escapeForSingleQuotes(sessionName);
+    if (process.env.TMUX) {
+      return `tmux switch-client -t '${escapedSession}'`;
+    }
+    const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || process.env.ITERM_SESSION_ID;
+    const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+    if (useiTermIntegration) {
+      return `tmux -CC attach-session -t '${escapedSession}'`;
     }
+    return `tmux attach-session -t '${escapedSession}'`;
   }
-  /**
-   * Validate if a class is a proper event
-   */
-  isValidEvent(EventClass) {
+  async listWorkonSessions() {
     try {
-      if (typeof EventClass !== "function") return false;
-      const metadata = EventClass.metadata;
-      return metadata !== void 0 && typeof metadata.name === "string" && typeof metadata.displayName === "string" && typeof EventClass.validation === "object" && typeof EventClass.configuration === "object" && typeof EventClass.processing === "object";
+      const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
+      return stdout.trim().split("\n").filter((session) => session.startsWith(this.sessionPrefix)).map((session) => session.replace(this.sessionPrefix, ""));
     } catch {
-      return false;
-    }
-  }
-  /**
-   * Get all valid event names from registered events
-   */
-  getValidEventNames() {
-    this.ensureInitialized();
-    return Array.from(this._events.keys());
-  }
-  /**
-   * Get event by name
-   */
-  getEventByName(name) {
-    this.ensureInitialized();
-    return this._events.get(name) ?? null;
-  }
-  /**
-   * Get all events for management UI
-   */
-  getEventsForManageUI() {
-    this.ensureInitialized();
-    const events = [];
-    for (const [name, EventClass] of this._events) {
-      const metadata = EventClass.metadata;
-      events.push({
-        name: metadata.displayName,
-        value: name,
-        description: metadata.description
-      });
-    }
-    return events.sort((a, b) => a.name.localeCompare(b.name));
-  }
-  /**
-   * Get events that support tmux integration
-   */
-  getTmuxEnabledEvents() {
-    this.ensureInitialized();
-    const tmuxEvents = [];
-    for (const [name, EventClass] of this._events) {
-      const tmux = EventClass.tmux;
-      if (tmux) {
-        tmuxEvents.push({
-          name,
-          event: EventClass,
-          priority: tmux.getLayoutPriority ? tmux.getLayoutPriority() : 0
-        });
-      }
-    }
-    return tmuxEvents.sort((a, b) => b.priority - a.priority);
-  }
-  /**
-   * Get all available events with their metadata
-   */
-  getAllEvents() {
-    this.ensureInitialized();
-    const events = [];
-    for (const [name, EventClass] of this._events) {
-      const typedClass = EventClass;
-      events.push({
-        name,
-        metadata: typedClass.metadata,
-        hasValidation: !!typedClass.validation,
-        hasConfiguration: !!typedClass.configuration,
-        hasProcessing: !!typedClass.processing,
-        hasTmux: !!typedClass.tmux,
-        hasHelp: !!typedClass.help
-      });
-    }
-    return events;
-  }
-  /**
-   * Ensure registry is initialized
-   */
-  ensureInitialized() {
-    if (!this._initialized) {
-      throw new Error("EventRegistry must be initialized before use. Call initialize() first.");
+      return [];
     }
   }
-  /**
-   * Clear the registry (useful for testing)
-   */
-  clear() {
-    this._events.clear();
-    this._initialized = false;
-  }
 };
-var EventRegistry = new EventRegistryClass();
 
 // src/commands/open.ts
+init_registry();
 function createOpenCommand(ctx) {
   const { config, log } = ctx;
   const command = new Command("open").description("Open a project by passing its project id").argument("[project]", "The id of the project to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("-n, --dry-run", "Show what would happen without executing").option("--shell", "Output shell commands instead of spawning processes").action(async (projectArg, options) => {
     if (options.debug) {
       log.setLogLevel("debug");
     }
-    await EventRegistry.initialize();
     if (projectArg) {
       await processProject(projectArg, options, ctx);
     } else {
@@ -1505,32 +2053,34 @@ function resolveCommandDependencies(requestedCommands, project) {
   }
   return [...new Set(resolved)];
 }
-async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+function getClaudeArgs(project) {
+  const claudeConfig = project.events.claude;
+  return typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+}
+async function getNpmCommand(project) {
+  const npmConfig = project.events.npm;
+  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
+  return NpmEvent2.getNpmCommand(npmConfig);
+}
+async function handleTmuxLayout(project, layout, options, shellCommands, events, ctx) {
   const { log } = ctx;
   const tmux = new TmuxManager();
-  const claudeConfig = project.events.claude;
-  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  const { isShellMode, dryRun } = options;
   let tmuxHandled = false;
   if (isShellMode) {
     if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildShellCommands(project.name, project.path.path, claudeArgs);
+      const commands = buildLayoutShellCommands(tmux, project, layout);
       shellCommands.push(...commands);
       tmuxHandled = true;
     } else {
       log.debug("Tmux not available, falling back to normal mode");
-      shellCommands.push(`cd "${project.path.path}"`);
-      const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-      shellCommands.push(claudeCommand);
+      buildFallbackCommands(shellCommands, project, layout);
       tmuxHandled = true;
     }
   } else if (!dryRun) {
     if (await tmux.isTmuxAvailable()) {
       try {
-        const sessionName = await tmux.createSplitSession(
-          project.name,
-          project.path.path,
-          claudeArgs
-        );
+        const sessionName = await createTmuxSession(tmux, project, layout);
         await tmux.attachToSession(sessionName);
         tmuxHandled = true;
       } catch (error) {
@@ -1540,139 +2090,103 @@ async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands,
       log.debug("Tmux not available, falling back to normal event processing");
     }
   } else {
-    log.info(`Would create split tmux session '${project.name}' with Claude`);
+    log.info(layout.dryRunMessage);
     tmuxHandled = true;
   }
   if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "claude"].includes(e))) {
+    for (const event of events.filter((e) => layout.handledEvents.includes(e))) {
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
   }
   if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "claude"].includes(e))) {
+    for (const event of events.filter((e) => !layout.handledEvents.includes(e))) {
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
   }
 }
-async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
-  const { log } = ctx;
-  const tmux = new TmuxManager();
-  const claudeConfig = project.events.claude;
-  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
-  const npmConfig = project.events.npm;
-  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
-  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
-  let tmuxHandled = false;
-  if (isShellMode) {
-    if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildThreePaneShellCommands(
+function buildLayoutShellCommands(tmux, project, layout) {
+  switch (layout.type) {
+    case "split-claude":
+      return tmux.buildShellCommands(project.name, project.path.path, layout.claudeArgs);
+    case "three-pane":
+      return tmux.buildThreePaneShellCommands(
         project.name,
         project.path.path,
-        claudeArgs,
-        npmCommand
+        layout.claudeArgs,
+        layout.npmCommand
       );
-      shellCommands.push(...commands);
-      tmuxHandled = true;
-    } else {
-      log.debug("Tmux not available, falling back to normal mode");
-      shellCommands.push(`cd "${project.path.path}"`);
-      shellCommands.push(claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude");
-      shellCommands.push(npmCommand);
-      tmuxHandled = true;
-    }
-  } else if (!dryRun) {
-    if (await tmux.isTmuxAvailable()) {
-      try {
-        const sessionName = await tmux.createThreePaneSession(
-          project.name,
-          project.path.path,
-          claudeArgs,
-          npmCommand
-        );
-        await tmux.attachToSession(sessionName);
-        tmuxHandled = true;
-      } catch (error) {
-        log.debug(`Failed to create tmux session: ${error.message}`);
-      }
-    } else {
-      log.debug("Tmux not available, falling back to normal event processing");
-    }
-  } else {
-    log.info(`Would create three-pane tmux session '${project.name}' with Claude and NPM`);
-    tmuxHandled = true;
+    case "two-pane-npm":
+      return tmux.buildTwoPaneNpmShellCommands(project.name, project.path.path, layout.npmCommand);
   }
-  if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+}
+function buildFallbackCommands(shellCommands, project, layout) {
+  shellCommands.push(`cd "${project.path.path}"`);
+  if (layout.type === "split-claude" || layout.type === "three-pane") {
+    const claudeCommand = layout.claudeArgs.length > 0 ? `claude ${layout.claudeArgs.join(" ")}` : "claude";
+    shellCommands.push(claudeCommand);
   }
-  if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+  if (layout.npmCommand) {
+    shellCommands.push(layout.npmCommand);
   }
 }
-async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
-  const { log } = ctx;
-  const tmux = new TmuxManager();
-  const npmConfig = project.events.npm;
-  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
-  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
-  let tmuxHandled = false;
-  if (isShellMode) {
-    if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildTwoPaneNpmShellCommands(
+async function createTmuxSession(tmux, project, layout) {
+  switch (layout.type) {
+    case "split-claude":
+      return tmux.createSplitSession(project.name, project.path.path, layout.claudeArgs);
+    case "three-pane":
+      return tmux.createThreePaneSession(
         project.name,
         project.path.path,
-        npmCommand
+        layout.claudeArgs,
+        layout.npmCommand
       );
-      shellCommands.push(...commands);
-      tmuxHandled = true;
-    } else {
-      log.debug("Tmux not available, falling back to normal mode");
-      shellCommands.push(`cd "${project.path.path}"`);
-      shellCommands.push(npmCommand);
-      tmuxHandled = true;
-    }
-  } else if (!dryRun) {
-    if (await tmux.isTmuxAvailable()) {
-      try {
-        const sessionName = await tmux.createTwoPaneNpmSession(
-          project.name,
-          project.path.path,
-          npmCommand
-        );
-        await tmux.attachToSession(sessionName);
-        tmuxHandled = true;
-      } catch (error) {
-        log.debug(`Failed to create tmux session: ${error.message}`);
-      }
-    } else {
-      log.debug("Tmux not available, falling back to normal event processing");
-    }
-  } else {
-    log.info(`Would create two-pane tmux session '${project.name}' with NPM`);
-    tmuxHandled = true;
-  }
-  if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
-  }
-  if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+    case "two-pane-npm":
+      return tmux.createTwoPaneNpmSession(project.name, project.path.path, layout.npmCommand);
   }
 }
+async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "split-claude",
+    handledEvents: ["cwd", "claude"],
+    dryRunMessage: `Would create split tmux session '${project.name}' with Claude`,
+    claudeArgs: getClaudeArgs(project),
+    npmCommand: null
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
+async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "three-pane",
+    handledEvents: ["cwd", "claude", "npm"],
+    dryRunMessage: `Would create three-pane tmux session '${project.name}' with Claude and NPM`,
+    claudeArgs: getClaudeArgs(project),
+    npmCommand: await getNpmCommand(project)
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
+async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "two-pane-npm",
+    handledEvents: ["cwd", "npm"],
+    dryRunMessage: `Would create two-pane tmux session '${project.name}' with NPM`,
+    claudeArgs: [],
+    npmCommand: await getNpmCommand(project)
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
 async function processEvent(event, context, ctx) {
   const { log } = ctx;
   log.debug(`Processing event ${event}`);
   const eventHandler = EventRegistry.getEventByName(event);
-  if (eventHandler && eventHandler.processing) {
-    await eventHandler.processing.processEvent(context);
-  } else {
+  if (!eventHandler) {
     log.debug(`No event handler found for: ${event}`);
+    return;
+  }
+  try {
+    await eventHandler.processing.processEvent(context);
+  } catch (error) {
+    log.error(`Failed to process event '${event}': ${error.message}`);
+    log.debug(`Event error stack: ${error.stack}`);
   }
 }
 async function showProjectHelp(projectName, ctx) {
@@ -1690,17 +2204,16 @@ Available commands for '${projectName}':`);
   for (const eventName of configuredEvents) {
     const eventHandler = EventRegistry.getEventByName(eventName);
     if (eventHandler) {
-      const metadata = eventHandler.metadata;
-      const config2 = projectConfig.events[eventName];
+      const eventConfig = projectConfig.events[eventName];
       let configDesc = "";
-      if (config2 !== true && config2 !== "true") {
-        if (typeof config2 === "object") {
-          configDesc = ` (${JSON.stringify(config2)})`;
+      if (eventConfig !== true && eventConfig !== "true") {
+        if (typeof eventConfig === "object") {
+          configDesc = ` (${JSON.stringify(eventConfig)})`;
         } else {
-          configDesc = ` (${config2})`;
+          configDesc = ` (${eventConfig})`;
         }
       }
-      console.log(`  ${eventName.padEnd(8)} - ${metadata.description}${configDesc}`);
+      console.log(`  ${eventName.padEnd(8)} - ${eventHandler.metadata.description}${configDesc}`);
     }
   }
   console.log("\nUsage examples:");
@@ -1806,25 +2319,17 @@ function createConfigCommand(ctx) {
 }
 
 // src/commands/manage.ts
+init_registry();
+init_constants();
 import { Command as Command6 } from "commander";
-import { select as select2, input as input5, confirm as confirm3, checkbox as checkbox2 } from "@inquirer/prompts";
+import { select as select2, input as input5, confirm as confirm4, checkbox as checkbox2 } from "@inquirer/prompts";
 import File5 from "phylo";
-var IDE_CHOICES2 = [
-  { name: "Visual Studio Code", value: "vscode" },
-  { name: "Visual Studio Code (code)", value: "code" },
-  { name: "IntelliJ IDEA", value: "idea" },
-  { name: "Atom", value: "atom" },
-  { name: "Sublime Text", value: "subl" },
-  { name: "Vim", value: "vim" },
-  { name: "Emacs", value: "emacs" }
-];
 function createManageCommand(ctx) {
   const { log } = ctx;
   return new Command6("manage").description("Interactive project management").option("-d, --debug", "Enable debug logging").action(async (options) => {
     if (options.debug) {
       log.setLogLevel("debug");
     }
-    await EventRegistry.initialize();
     await mainMenu(ctx);
   });
 }
@@ -1906,7 +2411,7 @@ async function createProject(ctx) {
   }
   const ide = await select2({
     message: "Select IDE:",
-    choices: IDE_CHOICES2
+    choices: IDE_CHOICES
   });
   const homepage = await input5({
     message: "Project homepage URL (optional):",
@@ -1939,7 +2444,7 @@ async function createProject(ctx) {
   }
   console.log("\nProject configuration:");
   console.log(JSON.stringify(projectConfig, null, 2));
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: "Save this project?",
     default: true
   });
@@ -1983,14 +2488,14 @@ async function editProject(ctx) {
   }
   const ide = await select2({
     message: "Select IDE:",
-    choices: IDE_CHOICES2,
+    choices: IDE_CHOICES,
     default: project.ide || "vscode"
   });
   const homepage = await input5({
     message: "Project homepage URL:",
     default: project.homepage || ""
   });
-  const keepEvents = await confirm3({
+  const keepEvents = await confirm4({
     message: "Keep existing event configuration?",
     default: true
   });
@@ -2029,7 +2534,7 @@ async function editProject(ctx) {
   }
   console.log("\nUpdated configuration:");
   console.log(JSON.stringify(updatedConfig, null, 2));
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: "Save changes?",
     default: true
   });
@@ -2052,7 +2557,7 @@ async function deleteProject(ctx) {
     message: "Select project to delete:",
     choices: projectNames.map((n) => ({ name: n, value: n }))
   });
-  const confirmed = await confirm3({
+  const confirmed = await confirm4({
     message: `Are you sure you want to delete '${name}'?`,
     default: false
   });
@@ -2086,7 +2591,7 @@ import { Command as Command7 } from "commander";
 import { existsSync, readFileSync } from "fs";
 import { basename, resolve } from "path";
 import File6 from "phylo";
-import { confirm as confirm4 } from "@inquirer/prompts";
+import { confirm as confirm5 } from "@inquirer/prompts";
 function createAddCommand(ctx) {
   const { log } = ctx;
   return new Command7("add").description("Add a project from a directory path").argument("[path]", "Path to the project directory (defaults to current directory)", ".").option("-d, --debug", "Enable debug logging").option("-n, --name <name>", "Override the detected project name").option(
@@ -2130,7 +2635,7 @@ async function addProject(pathArg, options, ctx) {
     process.exit(1);
   }
   if (projectName in projects && !options.force) {
-    const overwrite = await confirm4({
+    const overwrite = await confirm5({
       message: `Project '${projectName}' already exists. Overwrite?`,
       default: false
     });
@@ -2245,32 +2750,42 @@ function createCli() {
   config.set("pkg", packageJson);
   EnvironmentRecognizer.configure(config, log);
   const completion = setupCompletion(config);
-  program2.name("workon").description("Work on something great!").version(packageJson.version).option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", (thisCommand) => {
+  program2.name("workon").description("Work on something great!").version(packageJson.version).argument("[project]", "Project name to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", async (thisCommand) => {
     const opts = thisCommand.opts();
     if (opts.debug) {
       log.setLogLevel("debug");
     }
-  }).action(async (options) => {
-    if (options.debug) {
-      log.setLogLevel("debug");
-    }
-    if (options.completion) {
-      log.debug("Setting up command-line completion");
-      completion.setupShellInitFile();
-      return;
-    }
-    if (options.init) {
-      log.debug("Generating shell integration function");
-      outputShellInit(program2);
-      return;
+    await EventRegistry.initialize();
+  }).action(
+    async (project, options) => {
+      if (options.debug) {
+        log.setLogLevel("debug");
+      }
+      if (options.completion) {
+        log.debug("Setting up command-line completion");
+        completion.setupShellInitFile();
+        return;
+      }
+      if (options.init) {
+        log.debug("Generating shell integration function");
+        outputShellInit(program2);
+        return;
+      }
+      if (project) {
+        const args = ["open", project];
+        if (options.shell) args.push("--shell");
+        if (options.debug) args.push("--debug");
+        await program2.parseAsync(["node", "workon", ...args]);
+        return;
+      }
+      const environment = await EnvironmentRecognizer.recognize(File7.cwd());
+      program2.setOptionValue("_environment", environment);
+      program2.setOptionValue("_config", config);
+      program2.setOptionValue("_log", log);
+      const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+      await runInteractive2({ config, log, environment });
     }
-    const environment = await EnvironmentRecognizer.recognize(File7.cwd());
-    program2.setOptionValue("_environment", environment);
-    program2.setOptionValue("_config", config);
-    program2.setOptionValue("_log", log);
-    const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-    await runInteractive2({ config, log, environment });
-  });
+  );
   program2.setOptionValue("_config", config);
   program2.setOptionValue("_log", log);
   program2.addCommand(createOpenCommand({ config, log }));