webmux 0.39.0 → 0.41.0

package/bin/webmux.js

@@ -473,7 +473,8 @@ _webmux() {
     'remove:Remove a worktree'
     'merge:Merge a worktree into main'
     'send:Send a prompt to a running worktree agent'
-    'prune:Remove all worktrees in the current project'
+    'prune:Remove all closed (not open) worktrees in the current project'
+    'restore:Re-open all worktree sessions that were open before'
     'linear:Post a worktree conversation to a Linear issue/team'
     'project:List, add, or remove projects served by the dashboard'
     'completion:Generate shell completion script'
@@ -543,7 +544,7 @@ compdef _webmux webmux`, BASH_SCRIPT = `_webmux() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=($(compgen -W "serve init service update add oneshot list open close refresh archive unarchive label remove merge send prune linear project completion" -- "\${cur}"))
+    COMPREPLY=($(compgen -W "serve init service update add oneshot list open close refresh archive unarchive label remove merge send prune restore linear project completion" -- "\${cur}"))
     return
   fi
 
@@ -5996,7 +5997,7 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// node_modules/.bun/@ts-rest+core@3.52.1+f5aac5c7d31a6dcb/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+38b2c5aebf202339/node_modules/@ts-rest/core/index.esm.mjs
 var isZodType = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.safeParse) === "function";
 }, isZodObjectStrict = (obj) => {
@@ -8338,21 +8339,110 @@ ${result.stderr.trim()}` : ""
   console.log();
 });
 
+// backend/src/domain/projects.ts
+function isProjectEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  return typeof v.path === "string" && v.path.length > 0 && typeof v.name === "string" && typeof v.addedAt === "number";
+}
+
+// backend/src/lib/log.ts
+function ts() {
+  return new Date().toISOString().slice(11, 23);
+}
+var DEBUG, log2;
+var init_log = __esm(() => {
+  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
+  log2 = {
+    info(msg) {
+      console.log(`[${ts()}] ${msg}`);
+    },
+    debug(msg) {
+      if (DEBUG)
+        console.log(`[${ts()}] ${msg}`);
+    },
+    warn(msg) {
+      console.warn(`[${ts()}] ${msg}`);
+    },
+    error(msg, err) {
+      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
+    }
+  };
+});
+
+// backend/src/adapters/projects-registry.ts
+import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+function defaultRegistryFile() {
+  return join5(homedir(), ".webmux", "projects.json");
+}
+function createProjectsRegistry(file = defaultRegistryFile()) {
+  function read() {
+    let raw;
+    try {
+      raw = readFileSync3(file, "utf8");
+    } catch {
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      log2.debug(`[projects-registry] ignoring malformed ${file}`);
+      return [];
+    }
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter(isProjectEntry);
+  }
+  function write(entries) {
+    mkdirSync(dirname3(file), { recursive: true });
+    const tmpPath = `${file}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(entries, null, 2)}
+`);
+    renameSync(tmpPath, file);
+  }
+  return {
+    list() {
+      return read();
+    },
+    add(entry) {
+      const entries = read().filter((existing) => existing.path !== entry.path);
+      entries.push(entry);
+      write(entries);
+    },
+    remove(path) {
+      const entries = read();
+      const next = entries.filter((entry) => entry.path !== path);
+      if (next.length !== entries.length)
+        write(next);
+    }
+  };
+}
+var init_projects_registry = __esm(() => {
+  init_log();
+});
+
 // bin/src/service.ts
 var exports_service = {};
 __export(exports_service, {
+  shouldPersistProject: () => shouldPersistProject,
   resolveEnvVars: () => resolveEnvVars,
+  resolveConfirmDecision: () => resolveConfirmDecision,
   readPortFromUnit: () => readPortFromUnit,
   readEnvVarsFromUnit: () => readEnvVarsFromUnit,
   parseInstalledServiceConfig: () => parseInstalledServiceConfig,
   parseEnvCliArgs: () => parseEnvCliArgs,
+  migrateServedRepoFromUnit: () => migrateServedRepoFromUnit,
   generateServiceFile: () => generateServiceFile,
   default: () => service,
   AUTO_PICKUP_ENV_VARS: () => AUTO_PICKUP_ENV_VARS
 });
-import { chmodSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, unlinkSync } from "fs";
-import { basename as basename3, join as join5 } from "path";
-import { homedir } from "os";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { basename as basename3, join as join6 } from "path";
+import { homedir as homedir2 } from "os";
 function getPlatform() {
   const plat = process.platform;
   if (plat === "linux" || plat === "darwin")
@@ -8365,6 +8455,33 @@ function resolveWebmuxPath() {
     return null;
   return result.stdout.toString().trim();
 }
+function shouldPersistProject(root, hasWebmuxConfig, existingPaths) {
+  if (!root || !hasWebmuxConfig)
+    return false;
+  return !existingPaths.includes(root);
+}
+function hasWebmuxConfig(root) {
+  return existsSync4(join6(root, ".webmux.yaml")) || existsSync4(join6(root, ".webmux.local.yaml"));
+}
+function persistProject(root, registry) {
+  if (!root)
+    return null;
+  const existingPaths = registry.list().map((entry) => entry.path);
+  if (!shouldPersistProject(root, hasWebmuxConfig(root), existingPaths))
+    return null;
+  registry.add({ path: root, name: detectProjectName(root), addedAt: Date.now() });
+  return root;
+}
+function cwdProjectToPersist() {
+  const gitRoot2 = getGitRoot();
+  if (!gitRoot2)
+    return null;
+  const existingPaths = createProjectsRegistry().list().map((entry) => entry.path);
+  return shouldPersistProject(gitRoot2, hasWebmuxConfig(gitRoot2), existingPaths) ? gitRoot2 : null;
+}
+function migrateServedRepoFromUnit(filePath, platform, registry = createProjectsRegistry()) {
+  return persistProject(readWorkingDirFromUnit(filePath, platform), registry);
+}
 function formatCommand([bin, args]) {
   return [bin, ...args].join(" ");
 }
@@ -8378,10 +8495,10 @@ function printRunResult(result) {
     console.error(err);
 }
 function systemdUnitPath(serviceName) {
-  return join5(homedir(), ".config", "systemd", "user", `${serviceName}.service`);
+  return join6(homedir2(), ".config", "systemd", "user", `${serviceName}.service`);
 }
 function launchdPlistPath(serviceName) {
-  return join5(homedir(), "Library", "LaunchAgents", `com.webmux.${serviceName}.plist`);
+  return join6(homedir2(), "Library", "LaunchAgents", `com.webmux.${serviceName}.plist`);
 }
 function serviceFilePath(config) {
   if (config.platform === "linux")
@@ -8392,16 +8509,15 @@ function generateSystemdUnit(config) {
   const extra = Object.keys(config.envVars).sort().map((key) => `Environment=${key}=${config.envVars[key]}`).join(`
 `);
   return `[Unit]
-Description=webmux dashboard \u2014 ${config.projectName}
+Description=webmux dashboard
 
 [Service]
 Type=simple
 ExecStart=${config.webmuxPath} serve --port ${config.port}
-WorkingDirectory=${config.projectDir}
+WorkingDirectory=${homedir2()}
 Restart=on-failure
 RestartSec=5
 Environment=PORT=${config.port}
-Environment=WEBMUX_PROJECT_DIR=${config.projectDir}
 Environment=PATH=${process.env.PATH}${extra ? `
 ` + extra : ""}
 
@@ -8413,7 +8529,7 @@ function escapePlistText(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function generateLaunchdPlist(config) {
-  const logPath = join5(homedir(), "Library", "Logs", `webmux-${config.serviceName}.log`);
+  const logPath = join6(homedir2(), "Library", "Logs", `webmux-${config.serviceName}.log`);
   const extra = Object.keys(config.envVars).sort().map((key) => `    <key>${escapePlistText(key)}</key>
     <string>${escapePlistText(config.envVars[key])}</string>`).join(`
 `);
@@ -8431,7 +8547,7 @@ function generateLaunchdPlist(config) {
     <string>${config.port}</string>
   </array>
   <key>WorkingDirectory</key>
-  <string>${config.projectDir}</string>
+  <string>${homedir2()}</string>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
@@ -8447,8 +8563,6 @@ function generateLaunchdPlist(config) {
   <dict>
     <key>PORT</key>
     <string>${config.port}</string>
-    <key>WEBMUX_PROJECT_DIR</key>
-    <string>${config.projectDir}</string>
     <key>PATH</key>
     <string>${process.env.PATH}</string>${extra ? `
 ` + extra : ""}
@@ -8465,7 +8579,7 @@ function generateServiceFile(config) {
 function readWorkingDirFromUnit(filePath, platform) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return null;
   }
@@ -8476,7 +8590,7 @@ function readWorkingDirFromUnit(filePath, platform) {
 function readPortFromUnit(filePath) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return null;
   }
@@ -8490,7 +8604,7 @@ function unescapePlistText(value) {
 function readEnvVarsFromUnit(filePath, platform) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return {};
   }
@@ -8519,19 +8633,13 @@ function parseInstalledServiceConfig(filePath, platform, webmuxPath) {
   const port = readPortFromUnit(filePath);
   if (port === null)
     return null;
-  const projectDir = readWorkingDirFromUnit(filePath, platform);
-  if (projectDir === null)
-    return null;
   const fileBase = basename3(filePath);
   const serviceName = platform === "linux" ? fileBase.replace(/\.service$/, "") : fileBase.replace(/^com\.webmux\./, "").replace(/\.plist$/, "");
-  const projectName = detectProjectName(projectDir);
   const envVars = readEnvVarsFromUnit(filePath, platform);
   return {
     platform,
-    projectName,
     serviceName,
     webmuxPath,
-    projectDir,
     port,
     envVars
   };
@@ -8626,19 +8734,19 @@ function redactSecretsInUnit(content, envVars) {
   }
   return out;
 }
-async function install(config, portExplicit, envVarNotes) {
+function isInteractive() {
+  return Boolean(process.stdin.isTTY);
+}
+function resolveConfirmDecision(autoConfirm, interactive) {
+  if (autoConfirm)
+    return "proceed";
+  if (!interactive)
+    return "abort-noninteractive";
+  return "prompt";
+}
+async function install(config, portExplicit, envVarNotes, autoConfirm) {
   const filePath = serviceFilePath(config);
   const alreadyInstalled = isInstalled(config);
-  if (alreadyInstalled) {
-    const reinstall = await confirm({ message: "Service is already installed. Reinstall?" });
-    if (isCancel(reinstall) || !reinstall) {
-      log.info("Aborted.");
-      return;
-    }
-    for (const cmd of uninstallCommands(config)) {
-      runCommand(cmd);
-    }
-  }
   const requestedPort = config.port;
   let chosenPort = requestedPort;
   let portNote = null;
@@ -8652,14 +8760,17 @@ async function install(config, portExplicit, envVarNotes) {
   config = { ...config, port: chosenPort };
   const content = generateServiceFile(config);
   const commands = installCommands(config);
+  const persistPath = cwdProjectToPersist();
   const displayContent = redactSecretsInUnit(content, config.envVars);
   note([
+    ...alreadyInstalled ? ["Service is already installed \u2014 this will reinstall it.", ""] : [],
     `File: ${filePath}`,
     "",
     "Contents:",
     displayContent,
     "Commands to run:",
-    ...commands.map((c4) => `  $ ${formatCommand(c4)}`)
+    ...commands.map((c4) => `  $ ${formatCommand(c4)}`),
+    ...persistPath ? ["", `Will also register this project: ${persistPath}`] : []
   ].join(`
 `), "Install service");
   if (Object.keys(config.envVars).length > 0) {
@@ -8669,12 +8780,28 @@ ${envVarNotes.join(`
   }
   if (portNote)
     log.info(portNote);
-  const ok = await confirm({ message: "Proceed?" });
-  if (isCancel(ok) || !ok) {
-    log.info("Aborted.");
+  const decision = resolveConfirmDecision(autoConfirm, isInteractive());
+  if (decision === "abort-noninteractive") {
+    log.info(`Non-interactive environment \u2014 not ${alreadyInstalled ? "reinstalling" : "installing"}. ` + "Re-run with --yes to confirm and apply the plan above.");
     return;
   }
-  mkdirSync(filePath.substring(0, filePath.lastIndexOf("/")), { recursive: true });
+  if (decision === "prompt") {
+    const ok = await confirm({ message: alreadyInstalled ? "Reinstall?" : "Proceed?" });
+    if (isCancel(ok) || !ok) {
+      log.info("Aborted.");
+      return;
+    }
+  }
+  if (alreadyInstalled) {
+    const migrated = migrateServedRepoFromUnit(filePath, config.platform);
+    if (migrated) {
+      log.success(`Migrated previously-served project ${detectProjectName(migrated)} (${migrated})`);
+    }
+    for (const cmd of uninstallCommands(config)) {
+      runCommand(cmd);
+    }
+  }
+  mkdirSync2(filePath.substring(0, filePath.lastIndexOf("/")), { recursive: true });
   await Bun.write(filePath, content);
   if (Object.keys(config.envVars).length > 0) {
     try {
@@ -8684,6 +8811,14 @@ ${envVarNotes.join(`
     }
   }
   log.success(`Wrote ${filePath}`);
+  if (persistPath) {
+    createProjectsRegistry().add({
+      path: persistPath,
+      name: detectProjectName(persistPath),
+      addedAt: Date.now()
+    });
+    log.success(`Registered project ${detectProjectName(persistPath)} (${persistPath})`);
+  }
   for (const cmd of commands) {
     const result = runCommand(cmd);
     if (!result.success) {
@@ -8755,7 +8890,7 @@ function logs(config) {
   if (config.platform === "linux") {
     proc = Bun.spawn(["journalctl", "--user", "-u", config.serviceName, "-f", "--no-pager"], { stdout: "inherit", stderr: "inherit" });
   } else {
-    const logPath = join5(homedir(), "Library", "Logs", `webmux-${config.serviceName}.log`);
+    const logPath = join6(homedir2(), "Library", "Logs", `webmux-${config.serviceName}.log`);
     if (!existsSync4(logPath)) {
       log.error(`Log file not found: ${logPath}`);
       return;
@@ -8784,6 +8919,9 @@ Usage:
 Options:
   --port N                   Pin the service to a port (default: 5111). On
                              reinstall without --port the existing port is kept.
+  --yes, -y                  Skip the confirmation prompt and install. In a
+                             non-interactive shell (CI, pipe) install prints the
+                             plan and stops unless --yes is passed.
   --env KEY=VALUE            Bake an environment variable into the service
                              unit (repeatable). Reserved keys PORT,
                              WEBMUX_PROJECT_DIR, and PATH are rejected.
@@ -8812,11 +8950,6 @@ async function service(args) {
     log.error(`Unsupported platform: ${process.platform}. Only linux and macOS are supported.`);
     return;
   }
-  const gitRoot2 = getGitRoot();
-  if (!gitRoot2) {
-    log.error("Not inside a git repository.");
-    return;
-  }
   const serviceManager = platform === "linux" ? "systemctl" : "launchctl";
   const smResult = run("which", [serviceManager]);
   if (!smResult.success) {
@@ -8831,6 +8964,7 @@ async function service(args) {
   let port = parseInt(process.env.PORT || "5111");
   let portExplicit = false;
   let autoPickup = true;
+  let autoConfirm = false;
   for (let i2 = 1;i2 < args.length; i2++) {
     if (args[i2] === "--port" && args[i2 + 1]) {
       const parsed = parseInt(args[++i2]);
@@ -8842,6 +8976,8 @@ async function service(args) {
       portExplicit = true;
     } else if (args[i2] === "--no-auto-env") {
       autoPickup = false;
+    } else if (args[i2] === "--yes" || args[i2] === "-y") {
+      autoConfirm = true;
     }
   }
   const cliEnv = parseEnvCliArgs(args.slice(1));
@@ -8850,7 +8986,6 @@ async function service(args) {
       log.error(err);
     return;
   }
-  const projectName = detectProjectName(gitRoot2);
   const serviceName = "webmux";
   let envVars = {};
   let envVarNotes = [];
@@ -8867,16 +9002,14 @@ async function service(args) {
   }
   const config = {
     platform,
-    projectName,
     serviceName,
     webmuxPath,
-    projectDir: gitRoot2,
     port,
     envVars
   };
   switch (action) {
     case "install":
-      await install(config, portExplicit, envVarNotes);
+      await install(config, portExplicit, envVarNotes, autoConfirm);
       break;
     case "uninstall":
       await uninstall(config);
@@ -8897,6 +9030,7 @@ var AUTO_PICKUP_ENV_VARS, RESERVED_ENV_KEYS, SYSTEMD_WORKDIR_RE, LAUNCHD_WORKDIR
 var init_service = __esm(() => {
   init_dist4();
   init_shared();
+  init_projects_registry();
   AUTO_PICKUP_ENV_VARS = ["LINEAR_API_KEY"];
   RESERVED_ENV_KEYS = new Set(["PORT", "WEBMUX_PROJECT_DIR", "PATH"]);
   SYSTEMD_WORKDIR_RE = /^WorkingDirectory=(.+)$/m;
@@ -8916,9 +9050,9 @@ __export(exports_service_restart, {
   restartCommand: () => restartCommand,
   listInstalledServices: () => listInstalledServices
 });
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
 function listInstalledServices(opts = {}) {
   const out = [];
   const systemdDir = opts.systemdDir ?? DEFAULT_SYSTEMD_DIR;
@@ -8930,7 +9064,7 @@ function listInstalledServices(opts = {}) {
           continue;
         out.push({
           name: name.slice(0, -".service".length),
-          filePath: join6(systemdDir, name),
+          filePath: join7(systemdDir, name),
           platform: "linux"
         });
       }
@@ -8943,7 +9077,7 @@ function listInstalledServices(opts = {}) {
           continue;
         out.push({
           name: name.slice(0, -".plist".length),
-          filePath: join6(launchdDir, name),
+          filePath: join7(launchdDir, name),
           platform: "darwin"
         });
       }
@@ -8986,17 +9120,19 @@ function reloadAfterRegenerate(service2, runner) {
   service is now unloaded \u2014 recover with: launchctl load -w "${service2.filePath}"`
   };
 }
-async function updateInstalledService(service2, webmuxPath, runner = defaultRunner) {
+async function updateInstalledService(service2, webmuxPath, runner = defaultRunner, migrate = migrateServedRepoFromUnit) {
   const canRegenerate = webmuxPath.length > 0;
   const config = canRegenerate ? parseInstalledServiceConfig(service2.filePath, service2.platform, webmuxPath) : null;
   let regenerated = false;
+  let migratedProject;
   if (config !== null) {
     let currentContent = "";
     try {
-      currentContent = readFileSync4(service2.filePath, "utf8");
+      currentContent = readFileSync5(service2.filePath, "utf8");
     } catch {}
     const expected = generateServiceFile(config);
     if (currentContent !== expected) {
+      migratedProject = migrate(service2.filePath, service2.platform) ?? undefined;
       try {
         await Bun.write(service2.filePath, expected);
         regenerated = true;
@@ -9005,6 +9141,7 @@ async function updateInstalledService(service2, webmuxPath, runner = defaultRunn
           service: service2,
           regenerated: false,
           restarted: false,
+          migratedProject,
           error: `could not rewrite ${service2.filePath}: ${String(err)}`
         };
       }
@@ -9013,16 +9150,17 @@ async function updateInstalledService(service2, webmuxPath, runner = defaultRunn
   if (regenerated) {
     const reload = reloadAfterRegenerate(service2, runner);
     if (!reload.ok) {
-      return { service: service2, regenerated, restarted: false, error: reload.error };
+      return { service: service2, regenerated, restarted: false, migratedProject, error: reload.error };
     }
     if (service2.platform === "darwin") {
-      return { service: service2, regenerated, restarted: true };
+      return { service: service2, regenerated, restarted: true, migratedProject };
     }
   }
   const outcome = restartInstalledService(service2, runner);
   return {
     service: service2,
     regenerated,
+    migratedProject,
     restarted: outcome.ok,
     error: outcome.error
   };
@@ -9032,40 +9170,16 @@ var init_service_restart = __esm(() => {
   init_shared();
   init_service();
   defaultRunner = { run };
-  DEFAULT_SYSTEMD_DIR = join6(homedir2(), ".config", "systemd", "user");
-  DEFAULT_LAUNCHD_DIR = join6(homedir2(), "Library", "LaunchAgents");
-});
-
-// backend/src/lib/log.ts
-function ts() {
-  return new Date().toISOString().slice(11, 23);
-}
-var DEBUG, log2;
-var init_log = __esm(() => {
-  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
-  log2 = {
-    info(msg) {
-      console.log(`[${ts()}] ${msg}`);
-    },
-    debug(msg) {
-      if (DEBUG)
-        console.log(`[${ts()}] ${msg}`);
-    },
-    warn(msg) {
-      console.warn(`[${ts()}] ${msg}`);
-    },
-    error(msg, err) {
-      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
-    }
-  };
+  DEFAULT_SYSTEMD_DIR = join7(homedir3(), ".config", "systemd", "user");
+  DEFAULT_LAUNCHD_DIR = join7(homedir3(), "Library", "LaunchAgents");
 });
 
 // backend/src/adapters/instance-registry.ts
-import { mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync5, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
 function defaultRegistryDir() {
-  return join7(homedir3(), ".webmux", "instances");
+  return join8(homedir4(), ".webmux", "instances");
 }
 function isAlive(pid) {
   try {
@@ -9083,14 +9197,14 @@ function isInstanceEntry(value) {
 }
 function createInstanceRegistry(dir = defaultRegistryDir()) {
   function ensureDir() {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   function entryPath(port) {
-    return join7(dir, `${port}.json`);
+    return join8(dir, `${port}.json`);
   }
   function readEntry(filename) {
     try {
-      const raw = readFileSync5(join7(dir, filename), "utf8");
+      const raw = readFileSync6(join8(dir, filename), "utf8");
       const parsed = JSON.parse(raw);
       return isInstanceEntry(parsed) ? parsed : null;
     } catch {
@@ -9104,8 +9218,8 @@ function createInstanceRegistry(dir = defaultRegistryDir()) {
       const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
       const text = `${JSON.stringify(entry, null, 2)}
 `;
-      writeFileSync(tmpPath, text);
-      renameSync(tmpPath, finalPath);
+      writeFileSync2(tmpPath, text);
+      renameSync2(tmpPath, finalPath);
     },
     deregister(port, expectedPid) {
       if (expectedPid !== undefined) {
@@ -9138,7 +9252,7 @@ function createInstanceRegistry(dir = defaultRegistryDir()) {
           continue;
         if (!isAlive(entry.pid)) {
           try {
-            unlinkSync2(join7(dir, filename));
+            unlinkSync2(join8(dir, filename));
           } catch {}
           continue;
         }
@@ -11317,11 +11431,11 @@ function conversationSessionId(conversation) {
     return null;
   return conversation.provider === "codexAppServer" ? conversation.threadId : conversation.sessionId;
 }
-var WORKTREE_META_SCHEMA_VERSION = 1, WORKTREE_ARCHIVE_STATE_VERSION = 1, ROOT_TAB_ID = "root";
+var WORKTREE_META_SCHEMA_VERSION = 1, WORKTREE_ARCHIVE_STATE_VERSION = 1, OPEN_SESSIONS_STATE_VERSION = 1, ROOT_TAB_ID = "root";
 
 // backend/src/adapters/fs.ts
 import { mkdir } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function stringifyAllocatedPorts(ports) {
   const entries = Object.entries(ports).map(([key, value]) => [key, String(value)]);
   return Object.fromEntries(entries);
@@ -11353,25 +11467,28 @@ function parseDotenv(content) {
 }
 async function loadDotenvLocal(worktreePath) {
   try {
-    const content = await Bun.file(join8(worktreePath, ".env.local")).text();
+    const content = await Bun.file(join9(worktreePath, ".env.local")).text();
     return parseDotenv(content);
   } catch {
     return {};
   }
 }
 function getWorktreeStoragePaths(gitDir) {
-  const webmuxDir = join8(gitDir, "webmux");
+  const webmuxDir = join9(gitDir, "webmux");
   return {
     gitDir,
     webmuxDir,
-    metaPath: join8(webmuxDir, "meta.json"),
-    runtimeEnvPath: join8(webmuxDir, "runtime.env"),
-    controlEnvPath: join8(webmuxDir, "control.env"),
-    prsPath: join8(webmuxDir, "prs.json")
+    metaPath: join9(webmuxDir, "meta.json"),
+    runtimeEnvPath: join9(webmuxDir, "runtime.env"),
+    controlEnvPath: join9(webmuxDir, "control.env"),
+    prsPath: join9(webmuxDir, "prs.json")
   };
 }
 function getProjectArchiveStatePath(gitDir) {
-  return join8(gitDir, "webmux", "archive.json");
+  return join9(gitDir, "webmux", "archive.json");
+}
+function getProjectOpenSessionsStatePath(gitDir) {
+  return join9(gitDir, "webmux", "open-sessions.json");
 }
 async function ensureWorktreeStorageDirs(gitDir) {
   const paths = getWorktreeStoragePaths(gitDir);
@@ -11422,6 +11539,29 @@ async function writeWorktreeArchiveState(gitDir, state) {
   await Bun.write(archivePath, JSON.stringify(state, null, 2) + `
 `);
 }
+function emptyOpenSessionsState() {
+  return {
+    schemaVersion: OPEN_SESSIONS_STATE_VERSION,
+    savedAt: "",
+    branches: []
+  };
+}
+function isOpenSessionsState(raw) {
+  return isRecord3(raw) && typeof raw.schemaVersion === "number" && typeof raw.savedAt === "string" && Array.isArray(raw.branches) && raw.branches.every((branch) => typeof branch === "string");
+}
+async function readOpenSessionsState(gitDir) {
+  const statePath = getProjectOpenSessionsStatePath(gitDir);
+  try {
+    const raw = await Bun.file(statePath).json();
+    return isOpenSessionsState(raw) ? {
+      schemaVersion: raw.schemaVersion,
+      savedAt: raw.savedAt,
+      branches: [...raw.branches]
+    } : emptyOpenSessionsState();
+  } catch {
+    return emptyOpenSessionsState();
+  }
+}
 function buildRuntimeEnvMap(meta, extraEnv = {}, dotenvValues = {}) {
   return {
     ...dotenvValues,
@@ -18756,8 +18896,8 @@ var init_dist5 = __esm(() => {
 });
 
 // backend/src/adapters/config.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname3, join as join9, resolve as resolve7 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname4, join as join10, resolve as resolve7 } from "path";
 function DEFAULT_ONESHOT_SYSTEM_PROMPT() {
   return [
     "You are running in webmux ONESHOT mode. There is NO interactive user \u2014 nobody is watching the chat or will respond to questions, approvals, or status checks. Any message asking the user to review, approve, confirm, take a look, or 'let you know' is wasted output: it will not be answered.",
@@ -18986,10 +19126,10 @@ function getDefaultProfileName(config) {
   return Object.keys(config.profiles)[0] ?? "default";
 }
 function readConfigFile(root) {
-  return readFileSync6(join9(root, ".webmux.yaml"), "utf8");
+  return readFileSync7(join10(root, ".webmux.yaml"), "utf8");
 }
 function readLocalConfigFile(root) {
-  return readFileSync6(join9(root, ".webmux.local.yaml"), "utf8");
+  return readFileSync7(join10(root, ".webmux.local.yaml"), "utf8");
 }
 function parseConfigDocument(text) {
   const parsed = $parse(text);
@@ -19137,7 +19277,7 @@ function projectRoot(dir) {
   if (result.exitCode !== 0)
     return gitRoot2(dir);
   const commonDir = new TextDecoder().decode(result.stdout).trim();
-  return commonDir ? dirname3(resolve7(dir, commonDir)) : gitRoot2(dir);
+  return commonDir ? dirname4(resolve7(dir, commonDir)) : gitRoot2(dir);
 }
 function loadConfig(dir, options = {}) {
   const root = options.resolvedRoot ? dir : projectRoot(dir);
@@ -19216,7 +19356,7 @@ var init_config = __esm(() => {
 
 // backend/src/adapters/control-token.ts
 import { chmod, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 async function loadControlToken() {
   if (cachedToken)
     return cachedToken;
@@ -19226,7 +19366,7 @@ async function loadControlToken() {
     return cachedToken;
   }
   const controlToken = crypto.randomUUID();
-  await mkdir2(dirname4(CONTROL_TOKEN_PATH), { recursive: true });
+  await mkdir2(dirname5(CONTROL_TOKEN_PATH), { recursive: true });
   await Bun.write(CONTROL_TOKEN_PATH, controlToken);
   await chmod(CONTROL_TOKEN_PATH, 384);
   cachedToken = controlToken;
@@ -19494,7 +19634,7 @@ var init_docker = __esm(() => {
 });
 
 // backend/src/adapters/hooks.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function buildErrorMessage(name, exitCode, stdout2, stderr) {
   const output = stderr.trim() || stdout2.trim();
   if (output) {
@@ -19519,7 +19659,7 @@ class BunLifecycleHookRunner {
     return this.direnvAvailable;
   }
   async buildCommand(cwd, command) {
-    if (this.checkDirenv() && await Bun.file(join10(cwd, ".envrc")).exists()) {
+    if (this.checkDirenv() && await Bun.file(join11(cwd, ".envrc")).exists()) {
       Bun.spawnSync(["direnv", "allow"], { cwd, stdout: "pipe", stderr: "pipe" });
       return ["direnv", "exec", cwd, "bash", "-c", command];
     }
@@ -19626,7 +19766,7 @@ var init_claude_cli = __esm(() => {
 
 // backend/src/adapters/session-discovery.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import { basename as basename5, join as join11 } from "path";
+import { basename as basename5, join as join12 } from "path";
 function home() {
   const value = Bun.env.HOME;
   if (!value)
@@ -19637,10 +19777,10 @@ function newestFirst(sessions) {
   return sessions.sort((left, right) => right.mtimeMs - left.mtimeMs).map((entry) => entry.sessionId);
 }
 async function listClaudeSessionIds(cwd) {
-  const dir = join11(home(), ".claude", "projects", encodeClaudeProjectDir(cwd));
+  const dir = join12(home(), ".claude", "projects", encodeClaudeProjectDir(cwd));
   const names = await readdir(dir).catch(() => []);
   const stamped = await Promise.all(names.filter((name) => name.endsWith(".jsonl")).map(async (name) => {
-    const info = await stat2(join11(dir, name)).catch(() => null);
+    const info = await stat2(join12(dir, name)).catch(() => null);
     return info ? { sessionId: basename5(name, ".jsonl"), mtimeMs: info.mtimeMs } : null;
   }));
   return newestFirst(stamped.filter((entry) => entry !== null));
@@ -19662,14 +19802,14 @@ async function readCodexSessionCwdId(path) {
   }
 }
 async function listCodexSessionIds(cwd) {
-  const root = join11(home(), ".codex", "sessions");
+  const root = join12(home(), ".codex", "sessions");
   const relPaths = await readdir(root, { recursive: true }).catch(() => []);
   const rollouts = relPaths.filter((rel) => {
     const name = basename5(rel);
     return name.startsWith("rollout-") && name.endsWith(".jsonl");
   });
   const stamped = await Promise.all(rollouts.map(async (rel) => {
-    const path = join11(root, rel);
+    const path = join12(root, rel);
     const meta = await readCodexSessionCwdId(path);
     if (!meta || meta.cwd !== cwd)
       return null;
@@ -19859,7 +19999,7 @@ var init_archive_state_service = __esm(() => {
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname5, join as join12, resolve as resolve8 } from "path";
+import { dirname as dirname6, join as join13, resolve as resolve8 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -20278,7 +20418,7 @@ async function mergeCodexHooksFile(hooksPath, hookSettings, agentCtlPath) {
 }
 async function resolveGitCommonDir(gitDir) {
   try {
-    const commonDir = (await Bun.file(join12(gitDir, "commondir")).text()).trim();
+    const commonDir = (await Bun.file(join13(gitDir, "commondir")).text()).trim();
     if (!commonDir)
       return gitDir;
     return commonDir.startsWith("/") ? commonDir : resolve8(gitDir, commonDir);
@@ -20288,7 +20428,7 @@ async function resolveGitCommonDir(gitDir) {
 }
 async function ensureGeneratedCodexHooksIgnored(gitDir) {
   const commonDir = await resolveGitCommonDir(gitDir);
-  const excludePath = join12(commonDir, "info", "exclude");
+  const excludePath = join13(commonDir, "info", "exclude");
   let existing = "";
   try {
     existing = await Bun.file(excludePath).text();
@@ -20298,7 +20438,7 @@ async function ensureGeneratedCodexHooksIgnored(gitDir) {
   const lines = existing.split(/\r?\n/).map((line) => line.trim());
   if (lines.includes(GENERATED_CODEX_HOOKS_EXCLUDE))
     return;
-  await mkdir3(dirname5(excludePath), { recursive: true });
+  await mkdir3(dirname6(excludePath), { recursive: true });
   const separator = existing.length > 0 && !existing.endsWith(`
 `) ? `
 ` : "";
@@ -20308,12 +20448,12 @@ async function ensureGeneratedCodexHooksIgnored(gitDir) {
 async function ensureAgentRuntimeArtifacts(input) {
   const storagePaths = getWorktreeStoragePaths(input.gitDir);
   const artifacts = {
-    agentCtlPath: join12(storagePaths.webmuxDir, "webmux-agentctl"),
-    claudeSettingsPath: join12(input.worktreePath, ".claude", "settings.local.json"),
-    codexHooksPath: join12(input.worktreePath, ".codex", "hooks.json")
+    agentCtlPath: join13(storagePaths.webmuxDir, "webmux-agentctl"),
+    claudeSettingsPath: join13(input.worktreePath, ".claude", "settings.local.json"),
+    codexHooksPath: join13(input.worktreePath, ".codex", "hooks.json")
   };
-  await mkdir3(dirname5(artifacts.claudeSettingsPath), { recursive: true });
-  await mkdir3(dirname5(artifacts.codexHooksPath), { recursive: true });
+  await mkdir3(dirname6(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname6(artifacts.codexHooksPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -20845,7 +20985,7 @@ var init_worktree_service = __esm(() => {
 // backend/src/services/lifecycle-service.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname6, resolve as resolve10 } from "path";
+import { dirname as dirname7, resolve as resolve10 } from "path";
 function toErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -21289,9 +21429,13 @@ class LifecycleService {
   async pruneWorktrees() {
     try {
       const resolvedWorktrees = await this.resolveAllWorktrees();
+      const sessionName = buildProjectSessionName(this.deps.projectRoot);
       const removedBranches = [];
       for (const resolved of resolvedWorktrees) {
         const branch = resolved.entry.branch ?? resolved.entry.path;
+        if (this.deps.tmux.hasWindow(sessionName, buildWorktreeWindowName(branch))) {
+          continue;
+        }
         await this.removeResolvedWorktree(resolved);
         removedBranches.push(branch);
       }
@@ -21761,7 +21905,7 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
         ...createProgressBase,
         phase: "creating_worktree"
       });
-      await mkdir4(dirname6(worktreePath), { recursive: true });
+      await mkdir4(dirname7(worktreePath), { recursive: true });
       initialized = await createManagedWorktree({
         repoRoot: this.deps.projectRoot,
         worktreePath,
@@ -22544,6 +22688,11 @@ function getWorktreeCommandUsage(command) {
     case "prune":
       return `Usage:
   webmux prune`;
+    case "restore":
+      return `Usage:
+  webmux restore
+
+Re-open every worktree session that was open the last time sessions were saved.`;
     case "tab":
       return [
         "Usage:",
@@ -22844,6 +22993,18 @@ function parsePruneCommandArgs(args) {
   }
   return true;
 }
+function parseRestoreCommandArgs(args) {
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") {
+      return false;
+    }
+    if (arg.startsWith("-")) {
+      throw new CommandUsageError(`Unknown option: ${arg}`);
+    }
+    throw new CommandUsageError(`Unexpected argument: ${arg}`);
+  }
+  return true;
+}
 function parseListCommandArgs(args) {
   let mode = "active";
   let search = "";
@@ -22882,9 +23043,19 @@ function listProjectWorktrees(runtime) {
   const projectDir = resolve12(runtime.projectDir);
   return runtime.git.listWorktrees(projectDir).filter((entry) => !entry.bare && resolve12(entry.path) !== projectDir);
 }
+function buildOpenWorktreeWindowSet(runtime) {
+  const sessionName = buildProjectSessionName(resolve12(runtime.projectDir));
+  let windows = [];
+  try {
+    windows = runtime.tmux.listWindows();
+  } catch {
+    windows = [];
+  }
+  return new Set(windows.filter((w) => w.sessionName === sessionName).map((w) => w.windowName));
+}
 async function defaultConfirmPrune(worktreeCount) {
   const response = await confirm({
-    message: `Prune all ${worktreeCount} worktree${worktreeCount === 1 ? "" : "s"}? This action cannot be undone.`,
+    message: `Prune ${worktreeCount} closed worktree${worktreeCount === 1 ? "" : "s"}? This action cannot be undone.`,
     initialValue: false
   });
   return !isCancel(response) && response;
@@ -22928,14 +23099,7 @@ async function listWorktrees(runtime, stdout2, options) {
     stdout2("No worktrees found.");
     return;
   }
-  const sessionName = buildProjectSessionName(projectDir);
-  let windows = [];
-  try {
-    windows = runtime.tmux.listWindows();
-  } catch {
-    windows = [];
-  }
-  const openWindows = new Set(windows.filter((w) => w.sessionName === sessionName).map((w) => w.windowName));
+  const openWindows = buildOpenWorktreeWindowSet(runtime);
   const projectGitDir = runtime.git.resolveWorktreeGitDir(projectDir);
   const archivedPaths = buildArchivedWorktreePathSet(await readWorktreeArchiveState(projectGitDir));
   const rows = await Promise.all(entries.map(async (entry) => {
@@ -23000,6 +23164,7 @@ async function runWorktreeCommand(context, deps2 = {}) {
   const resolveBaseUrl = deps2.resolveBaseUrl ?? resolveProjectBaseUrl;
   const switchToTmuxWindow = deps2.switchToTmuxWindow ?? defaultSwitchToTmuxWindow;
   const confirmPrune = deps2.confirmPrune ?? defaultConfirmPrune;
+  const readOpenSessions = deps2.readOpenSessions ?? readOpenSessionsState;
   try {
     if (context.command === "add") {
       const parsed = parseAddCommandArgs(context.args);
@@ -23078,18 +23243,85 @@ ${parsed.input.prompt}` : seed.data.conversationMarkdown;
         stdout2("No worktrees found.");
         return 0;
       }
-      if (!await confirmPrune(worktrees.length)) {
+      const openWindows = buildOpenWorktreeWindowSet(runtime2);
+      const closedWorktrees = worktrees.filter((entry) => !openWindows.has(buildWorktreeWindowName(entry.branch ?? basename7(entry.path))));
+      if (closedWorktrees.length === 0) {
+        stdout2("No closed worktrees to prune.");
+        return 0;
+      }
+      if (!await confirmPrune(closedWorktrees.length)) {
         stdout2("Aborted.");
         return 0;
       }
       const result = await runtime2.lifecycleService.pruneWorktrees();
       if (result.removedBranches.length === 0) {
-        stdout2("No worktrees found.");
+        stdout2("No closed worktrees to prune.");
         return 0;
       }
       stdout2(`Pruned ${result.removedBranches.length} worktree${result.removedBranches.length === 1 ? "" : "s"}: ${result.removedBranches.join(", ")}`);
       return 0;
     }
+    if (context.command === "restore") {
+      if (!parseRestoreCommandArgs(context.args)) {
+        stdout2(getWorktreeCommandUsage("restore"));
+        return 0;
+      }
+      const runtime2 = createRuntime({
+        projectDir: context.projectDir,
+        port: context.port
+      });
+      const projectDir = resolve12(runtime2.projectDir);
+      const gitDir = runtime2.git.resolveWorktreeGitDir(projectDir);
+      const state = await readOpenSessions(gitDir);
+      if (state.branches.length === 0) {
+        stdout2("No saved sessions to restore.");
+        return 0;
+      }
+      const sessionName = buildProjectSessionName(projectDir);
+      let openWindows = new Set;
+      try {
+        openWindows = new Set(runtime2.tmux.listWindows().filter((w) => w.sessionName === sessionName).map((w) => w.windowName));
+      } catch {
+        openWindows = new Set;
+      }
+      const existingBranches = new Set(listProjectWorktrees(runtime2).map((entry) => entry.branch ?? basename7(entry.path)));
+      let restored = 0;
+      let skipped = 0;
+      let failed = 0;
+      let firstRestored = null;
+      for (const branch2 of state.branches) {
+        if (openWindows.has(buildWorktreeWindowName(branch2))) {
+          stdout2(`Already open: ${branch2}`);
+          skipped++;
+          continue;
+        }
+        if (!existingBranches.has(branch2)) {
+          stderr(`Skipping ${branch2}: worktree no longer exists`);
+          skipped++;
+          continue;
+        }
+        try {
+          await runtime2.lifecycleService.openWorktree(branch2);
+          stdout2(`Restored ${branch2}`);
+          restored++;
+          if (!firstRestored)
+            firstRestored = branch2;
+        } catch (error) {
+          stderr(`Failed to restore ${branch2}: ${error instanceof Error ? error.message : String(error)}`);
+          failed++;
+        }
+      }
+      const summaryParts = [`Restored ${restored} session${restored === 1 ? "" : "s"}`];
+      if (skipped > 0)
+        summaryParts.push(`skipped ${skipped}`);
+      if (failed > 0)
+        summaryParts.push(`${failed} failed`);
+      stdout2(`${summaryParts.join(", ")}.`);
+      if (firstRestored) {
+        switchToTmuxWindow(runtime2.projectDir, firstRestored);
+      }
+      return failed > 0 ? 1 : 0;
+    }
     if (context.command === "send") {
       const parsed = parseSendCommandArgs(context.args);
       if (!parsed) {
@@ -23227,13 +23459,13 @@ var init_worktree_commands = __esm(() => {
 });
 
 // bin/src/webmux.ts
-import { resolve as resolve13, dirname as dirname7, join as join13 } from "path";
+import { resolve as resolve13, dirname as dirname8, join as join14 } from "path";
 import { existsSync as existsSync6 } from "fs";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.39.0",
+  version: "0.41.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -23290,7 +23522,7 @@ var package_default = {
 };
 
 // bin/src/webmux.ts
-var PKG_ROOT = resolve13(dirname7(fileURLToPath(import.meta.url)), "..");
+var PKG_ROOT = resolve13(dirname8(fileURLToPath(import.meta.url)), "..");
 function usage2() {
   console.log(`
 webmux \u2014 Dev dashboard for managing Git worktrees
@@ -23313,7 +23545,8 @@ Usage:
   webmux merge        Merge a worktree into the main branch and remove it
   webmux send         Send a prompt to a running worktree agent
   webmux tab          List, create, switch, or close agent tabs in a worktree
-  webmux prune        Remove all worktrees in the current project
+  webmux prune        Remove all closed (not open) worktrees in the current project
+  webmux restore      Re-open all worktree sessions that were open before
   webmux linear       Post a worktree conversation to a Linear issue/team
   webmux project      List, add, or remove projects served by the dashboard
   webmux completion   Generate shell completion script (bash, zsh)
@@ -23331,7 +23564,7 @@ Environment:
 `);
 }
 function isRootCommand(value) {
-  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "oneshot" || value === "list" || value === "open" || value === "close" || value === "refresh" || value === "archive" || value === "unarchive" || value === "label" || value === "remove" || value === "merge" || value === "send" || value === "tab" || value === "prune" || value === "linear" || value === "project" || value === "completion";
+  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "oneshot" || value === "list" || value === "open" || value === "close" || value === "refresh" || value === "archive" || value === "unarchive" || value === "label" || value === "remove" || value === "merge" || value === "send" || value === "tab" || value === "prune" || value === "restore" || value === "linear" || value === "project" || value === "completion";
 }
 function isServeRootOption(value) {
   return value === "--port" || value === "--app" || value === "--debug" || value === "--help" || value === "-h" || value === "--version" || value === "-V";
@@ -23398,7 +23631,7 @@ Run webmux --help for usage.`);
   };
 }
 function isWorktreeCommand(command) {
-  return command === "add" || command === "list" || command === "open" || command === "close" || command === "refresh" || command === "archive" || command === "unarchive" || command === "label" || command === "remove" || command === "merge" || command === "send" || command === "tab" || command === "prune";
+  return command === "add" || command === "list" || command === "open" || command === "close" || command === "refresh" || command === "archive" || command === "unarchive" || command === "label" || command === "remove" || command === "merge" || command === "send" || command === "tab" || command === "prune" || command === "restore";
 }
 async function loadEnvFile(path) {
   if (!existsSync6(path))
@@ -23526,6 +23759,8 @@ Refreshing ${services.length} installed webmux service(s) to pick up the new ver
           const parts = [];
           if (outcome.regenerated)
             parts.push("regenerated unit");
+          if (outcome.migratedProject)
+            parts.push(`migrated served project ${outcome.migratedProject}`);
           if (outcome.restarted)
             parts.push("restarted");
           if (!outcome.regenerated && !outcome.restarted && !outcome.error)
@@ -23613,8 +23848,8 @@ Refreshing ${services.length} installed webmux service(s) to pick up the new ver
   }
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  const backendEntry = join13(PKG_ROOT, "backend", "dist", "server.js");
-  const staticDir = join13(PKG_ROOT, "frontend", "dist");
+  const backendEntry = join14(PKG_ROOT, "backend", "dist", "server.js");
+  const staticDir = join14(PKG_ROOT, "frontend", "dist");
   if (!existsSync6(staticDir)) {
     console.error(`Error: frontend/dist/ not found. Run 'bun run build' first.`);
     process.exit(1);