@brainervirus/workit-cli 2.0.2 → 2.1.0

package/dist/index.js

@@ -49793,13 +49793,6 @@ var workspaceConfigSchema = object({
   profiles: record(nonBlank, workspaceProfileSchema).optional(),
   releaseTracks: record(nonBlank, releaseTrackSchema).optional()
 }).passthrough().superRefine((workspace, context) => {
-  if (workspace.youtrack && workspace.vcs?.provider !== "gitlab") {
-    context.addIssue({
-      code: "custom",
-      path: ["youtrack"],
-      message: `YouTrack issue linking requires the gitlab provider, got ${workspace.vcs?.provider ?? "unset"}`
-    });
-  }
   if (workspace.issues && workspace.vcs?.provider !== "github") {
     context.addIssue({
       code: "custom",
@@ -49992,13 +49985,10 @@ var selectWorkspaceMatch = (matches, cwd, workspaceName) => {
   }
   return mostSpecific[0];
 };
-var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
-  const result = readWorkspacesResult(dir);
-  if (result.status === "malformed" || result.status === "invalid")
-    throw new Error(result.error);
+var resolveWorkspaceFromEntries = (cwd, entries, workspaceName) => {
   const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
   const matches = [];
-  for (const ws of result.entries) {
+  for (const ws of entries) {
     const glob = ws.glob.replaceAll("\\", "/");
     const canonical = canonicalGlob(glob);
     let matched = false;
@@ -50013,6 +50003,12 @@ var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
   }
   return selectWorkspaceMatch(matches, cwd, workspaceName) ?? null;
 };
+var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
+  const result = readWorkspacesResult(dir);
+  if (result.status === "malformed" || result.status === "invalid")
+    throw new Error(result.error);
+  return resolveWorkspaceFromEntries(cwd, result.entries, workspaceName);
+};
 var runtimeWorkspacePolicySchema = (kind) => {
   const key = kind === "branch" ? "branchPolicy" : kind === "commit" ? "commitPolicy" : "vcs";
   const policySchema = kind === "branch" ? workspaceBranchPolicySchema : kind === "commit" ? workspaceCommitPolicySchema : object({
@@ -50096,6 +50092,48 @@ var resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
     source: profilePolicy ? `profile:${profileName}` : workspacePolicy ? `workspace:${candidate.name}` : "user-default"
   };
 };
+var resolveWorkspaceProfile = (workspace, requestedProfile) => {
+  const profileName = requestedProfile ?? workspace.defaultProfile ?? null;
+  const profile = profileName ? workspace.profiles?.[profileName] : undefined;
+  if (profileName && !profile) {
+    return {
+      status: "invalid",
+      error: `workspace ${JSON.stringify(workspace.name)} has no profile ${JSON.stringify(profileName)}`
+    };
+  }
+  const effectiveWorkspace = profile ? {
+    ...workspace,
+    ...profile.branchPolicy ? { branchPolicy: profile.branchPolicy } : {},
+    ...profile.commitPolicy ? { commitPolicy: profile.commitPolicy } : {}
+  } : workspace;
+  return {
+    status: "resolved",
+    profileName,
+    workspace: effectiveWorkspace,
+    provenance: {
+      branchPolicy: profile?.branchPolicy ? `profile:${profileName}` : workspace.branchPolicy ? `workspace:${workspace.name}` : "user-default",
+      commitPolicy: profile?.commitPolicy ? `profile:${profileName}` : workspace.commitPolicy ? `workspace:${workspace.name}` : "user-default"
+    }
+  };
+};
+var resolveWorkspacePolicy = (config, workspace, profileName) => {
+  const selected = workspace ? resolveWorkspaceProfile(workspace, profileName) : {
+    status: "resolved",
+    profileName: null,
+    workspace: null,
+    provenance: { branchPolicy: "user-default", commitPolicy: "user-default" }
+  };
+  if (selected.status === "invalid")
+    return selected;
+  return {
+    status: "resolved",
+    workspace: selected.workspace,
+    profileName: selected.profileName,
+    branchPolicy: resolveBranchPolicy(config, selected.workspace),
+    commitPolicy: resolveCommitPolicy(config, selected.workspace),
+    provenance: selected.provenance
+  };
+};
 
 // packages/workit-core/src/core/gitignore.ts
 var GITIGNORE_ENTRIES = [
@@ -50607,20 +50645,20 @@ function writeFileAtomic(file, content, mode) {
 import {
   copyFileSync as copyFileSync2,
   cpSync as cpSync3,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync5,
   mkdtempSync,
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync4,
+  readFileSync as readFileSync12,
+  readdirSync as readdirSync5,
   realpathSync as realpathSync2,
   renameSync as renameSync2,
   rmSync,
-  statSync as statSync3,
+  statSync as statSync4,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import os6 from "node:os";
-import path13 from "node:path";
+import os7 from "node:os";
+import path14 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 
 // packages/workit-core/src/core/branch-policy.ts
@@ -50729,7 +50767,7 @@ var named = (s, name) => s === name || s.startsWith(`${name}@`);
 function isWorkitPlugin(value) {
   const s = String(value).replaceAll("\\", "/");
   const url = s.startsWith("file://") || s.startsWith("git+file://");
-  const pkgPath = s.includes("/packages/workit-opencode/") || s.includes("/packages/workit-cursor/") || s.includes("/node_modules/@brainervirus/workit-opencode/") || s.includes("/node_modules/@brainervirus/workit-cursor/");
+  const pkgPath = /\/(?:packages\/workit-(?:opencode|cursor)|node_modules\/@brainervirus\/workit-(?:opencode|cursor))(?:\/|$)/.test(s);
   return named(s, "workflow-toolkit") || named(s, "workflow-toolkit-opencode") || named(s, "local/workflow-toolkit") || named(s, "workit") || named(s, "local/workit") || named(s, "@brainervirus/workit-opencode") || named(s, "@brainervirus/workit-cursor") || url && pkgPath || s.startsWith("git+file://") && s.includes("workflow-toolkit");
 }
 function mergeOpenCodePlugins(plugin, pin) {
@@ -53344,9 +53382,10 @@ var parsesAsConfigObject = (p) => {
   }
 };
 var pluginEntries = (cfg) => {
-  const plugin = cfg?.plugin;
-  const list = Array.isArray(plugin) ? plugin : typeof plugin === "string" ? [plugin] : [];
-  return list.map(String).filter(isWorkitPlugin);
+  const entries = [cfg?.plugins, cfg?.plugin].flatMap((value) => Array.isArray(value) ? value : typeof value === "string" ? [value] : []);
+  return [
+    ...new Set(entries.filter((entry) => typeof entry === "string" && isWorkitPlugin(entry)))
+  ];
 };
 var commandOnPath = (name, env) => {
   const dirs = (env.PATH ?? process.env.PATH ?? "").split(path12.delimiter);
@@ -54603,6 +54642,351 @@ var runDoctor = (options = {}) => {
   return report;
 };
 
+// packages/workit-core/src/core/host-install.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { accessSync, constants as constants2, existsSync as existsSync10, readFileSync as readFileSync11, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import os6 from "node:os";
+import path13 from "node:path";
+function hostCommand(name, args, options = {}) {
+  const executable = findHostExecutable(name, options);
+  if (!executable)
+    throw new Error(`${name} executable was not found on PATH or supported user bin directories`);
+  if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(executable)) {
+    const node = findHostExecutable("node", options);
+    if (!node)
+      throw new Error(`Node.js is required to run the ${name} Windows shim`);
+    const script = resolveWindowsShimScript(executable);
+    if (!script)
+      throw new Error(`could not resolve the ${name} Windows shim to a JavaScript entrypoint`);
+    return { command: node, args: [script, ...args], cwd: options.cwd, purpose: `${name} CLI` };
+  }
+  return { command: executable, args, cwd: options.cwd, purpose: `${name} CLI` };
+}
+function resolveWindowsShimEntry(contents, shim, exists = existsSync10) {
+  const root = path13.win32.dirname(shim);
+  const matches = contents.matchAll(/(["']?)([^\r\n"']*node_modules[\\/][^\r\n"']+?\.js)\1/gi);
+  for (const match of matches) {
+    const raw = match[2].replace(/%~?dp0%?/gi, root);
+    const candidate = path13.win32.isAbsolute(raw) ? raw : path13.win32.resolve(root, raw);
+    if (exists(candidate))
+      return candidate;
+  }
+  return null;
+}
+var resolveWindowsShimScript = (shim) => {
+  try {
+    const contents = readFileSync11(shim, "utf8");
+    return resolveWindowsShimEntry(contents, shim);
+  } catch {
+    return null;
+  }
+};
+var MARKETPLACE = "https://github.com/BrainerVirus/workit.git";
+var CODEX_MARKETPLACE_NAME = "workflow-toolkit";
+var validPackageVersion = (value) => value === "latest" || /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value);
+var nodePrerequisite = (options) => {
+  const node = findHostExecutable("node", options);
+  if (!node)
+    throw new Error("Workit host packages require Node.js 24+; install Node.js and retry");
+  return {
+    command: node,
+    args: [
+      "-e",
+      'const v=Number(process.versions.node.split(".")[0]);if(v<24){console.error(`Workit host packages require Node.js 24+ (found ${process.versions.node})`);process.exit(1)}'
+    ],
+    cwd: options.cwd,
+    purpose: "Check the Node.js 24+ package runtime requirement"
+  };
+};
+function findHostExecutable(name, options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? env.HOME ?? os6.homedir();
+  const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  const dirs = (env.PATH ?? "").split(path13.delimiter).filter(Boolean);
+  dirs.push(path13.join(home, ".local", "bin"), path13.join(home, ".asdf", "shims"));
+  for (const [base, tail] of [
+    [path13.join(home, ".local", "share", "fnm", "node-versions"), path13.join("installation", "bin")],
+    [path13.join(home, ".nvm", "versions", "node"), "bin"]
+  ]) {
+    try {
+      for (const entry of readdirSync4(base, { withFileTypes: true })) {
+        if (entry.isDirectory())
+          dirs.push(path13.join(base, entry.name, tail));
+      }
+    } catch {}
+  }
+  for (const dir of dirs) {
+    for (const suffix of suffixes) {
+      const candidate = path13.join(dir, `${name}${suffix}`);
+      try {
+        if (statSync3(candidate).isFile()) {
+          if (process.platform === "win32")
+            return candidate;
+          accessSync(candidate, constants2.X_OK);
+          return candidate;
+        }
+      } catch {}
+    }
+  }
+  return null;
+}
+var isPiWorkitInstalled = (home, env = process.env) => {
+  const settings = path13.join(env.PI_CODING_AGENT_DIR ?? path13.join(home, ".pi", "agent"), "settings.json");
+  try {
+    const document2 = JSON.parse(readFileSync11(settings, "utf8"));
+    return (document2.packages ?? []).some((entry) => {
+      const source = entry && typeof entry === "object" && !Array.isArray(entry) ? entry.source : entry;
+      const value = String(source).replaceAll("\\", "/").replace(/\/+$/, "");
+      return /^npm:@brainervirus\/workit-pi(?:@[^/]+)?$/.test(value) || value === "@brainervirus/workit-pi" || /(?:^|\/)packages\/workit-pi$/.test(value);
+    });
+  } catch {
+    return false;
+  }
+};
+var isCanonicalCodexPackage = (root) => {
+  for (const file of [
+    path13.join(root, ".codex-plugin", "plugin.json"),
+    path13.join(root, "package.json")
+  ]) {
+    try {
+      const manifest = JSON.parse(readFileSync11(file, "utf8"));
+      const repository = typeof manifest.repository === "string" ? manifest.repository : manifest.repository?.url;
+      if ((manifest.name === "workit" || manifest.name === "@brainervirus/workit-codex") && repository?.replace(/\.git$/, "").toLowerCase() === "https://github.com/brainervirus/workit")
+        return true;
+    } catch {}
+  }
+  return false;
+};
+var isCodexWorkitInstalled = (home, env = process.env) => {
+  const codexHome = env.CODEX_HOME ?? path13.join(home, ".codex");
+  const isPackageOrVersionDirectory = (root) => {
+    if (isCanonicalCodexPackage(root))
+      return true;
+    try {
+      return readdirSync4(root, { withFileTypes: true }).some((entry) => entry.isDirectory() && isCanonicalCodexPackage(path13.join(root, entry.name)));
+    } catch {
+      return false;
+    }
+  };
+  if (isPackageOrVersionDirectory(path13.join(codexHome, "plugins", "workit")))
+    return true;
+  const root = path13.join(codexHome, "plugins", "cache");
+  try {
+    for (const marketplace of readdirSync4(root, { withFileTypes: true })) {
+      if (!marketplace.isDirectory())
+        continue;
+      if (isPackageOrVersionDirectory(path13.join(root, marketplace.name, "workit")))
+        return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+};
+function installedHostApp(host, home, env = process.env, platform = process.platform, exists = existsSync10) {
+  const candidates = [];
+  const pathApi = platform === "win32" ? path13.win32 : path13;
+  if (platform === "darwin") {
+    const app = host === "cursor" ? "Cursor.app" : host === "codex" ? "Codex.app" : host === "opencode" ? "OpenCode.app" : "";
+    if (app)
+      candidates.push(`/Applications/${app}`, pathApi.join(home, "Applications", app));
+  } else if (platform === "win32") {
+    const local = env.LOCALAPPDATA ?? pathApi.join(home, "AppData", "Local");
+    if (host === "cursor")
+      candidates.push(pathApi.join(local, "Programs", "Cursor", "Cursor.exe"));
+    if (host === "codex")
+      candidates.push(pathApi.join(local, "Programs", "Codex", "Codex.exe"));
+    if (host === "opencode")
+      candidates.push(pathApi.join(local, "Programs", "OpenCode", "OpenCode.exe"));
+  }
+  return candidates.some(exists);
+}
+function planHostInstall(host, options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? env.HOME ?? os6.homedir();
+  const cwd = options.cwd ?? process.cwd();
+  const version = options.packageVersion ?? "latest";
+  if (!validPackageVersion(version))
+    throw new Error(`unsupported package version selector: ${version}`);
+  if (options.alreadyInstalled && options.mode !== "upgrade")
+    return [];
+  const upgrading = options.mode === "upgrade";
+  if (host === "codex") {
+    if (!upgrading && isCodexWorkitInstalled(home, env))
+      return [];
+    const base = hostCommand("codex", [], { home, cwd, env });
+    return [
+      nodePrerequisite({ home, cwd, env }),
+      {
+        ...base,
+        args: [...base.args, "plugin", "marketplace", "list"],
+        purpose: "Check whether the Workit marketplace is already registered"
+      },
+      {
+        ...base,
+        args: [
+          ...base.args,
+          "plugin",
+          "marketplace",
+          upgrading ? "upgrade" : "add",
+          ...upgrading ? [CODEX_MARKETPLACE_NAME] : [MARKETPLACE]
+        ],
+        purpose: upgrading ? "Refresh the Workit Codex marketplace" : "Register the Workit Codex marketplace",
+        ...upgrading ? {} : { skipWhenOutputIncludes: CODEX_MARKETPLACE_NAME }
+      },
+      {
+        ...base,
+        args: [...base.args, "plugin", "add", `workit@${CODEX_MARKETPLACE_NAME}`],
+        purpose: upgrading ? "Refresh the Workit Codex plugin" : "Install the Workit Codex plugin"
+      }
+    ];
+  }
+  if (host === "pi") {
+    if (!upgrading && isPiWorkitInstalled(home, env))
+      return [];
+    const base = hostCommand("pi", [], { home, cwd, env });
+    return [
+      nodePrerequisite({ home, cwd, env }),
+      {
+        ...base,
+        args: upgrading ? [...base.args, "update", "--extension", "npm:@brainervirus/workit-pi"] : [...base.args, "install", `npm:@brainervirus/workit-pi@${version}`],
+        purpose: upgrading ? "Update the Workit Pi package" : "Install the Workit Pi package in personal Pi settings"
+      }
+    ];
+  }
+  if (host === "cursor") {
+    const node = findHostExecutable("node", { home, env });
+    if (!node)
+      throw new Error("Workit host packages require Node.js 24+; install Node.js and retry");
+    const npm = findHostExecutable("npm", { home, env });
+    const npmCli = npm ? findNpmCli(npm) : null;
+    if (!npmCli)
+      throw new Error("npm CLI could not be resolved; install Node.js 24+ and npm, then retry");
+    const stage = path13.join(home, ".cursor", "plugins", "local", ".workit-package-bootstrap");
+    const target = options.targetDir ?? path13.join(home, ".cursor", "plugins", "local", "workit");
+    return [
+      nodePrerequisite({ home, cwd, env }),
+      {
+        command: node,
+        args: [
+          npmCli,
+          "install",
+          "--prefix",
+          stage,
+          "--no-save",
+          "--package-lock=false",
+          `@brainervirus/workit-cursor@${version}`
+        ],
+        cwd,
+        purpose: upgrading ? "Download the current Workit Cursor adapter for the managed local plugin directory" : "Download the Workit Cursor adapter package for the managed local plugin directory",
+        packageRoot: path13.join(stage, "node_modules", "@brainervirus", "workit-cursor"),
+        packageTarget: target
+      }
+    ];
+  }
+  if (host === "opencode") {
+    if (upgrading)
+      throw new Error("OpenCode CLI cannot target the Workit server plugin for a scoped update; upgrade is unsupported and the current registration was preserved");
+    return [];
+  }
+  return [];
+}
+function runHostInstall(commands, runner, context = {}) {
+  const results = [];
+  let packageRoot;
+  let outputHistory = "";
+  for (const command of commands) {
+    if (command.skipWhenOutputIncludes && outputHistory.includes(command.skipWhenOutputIncludes)) {
+      results.push({
+        command,
+        result: { exitCode: 0, stdout: "", stderr: "already registered; skipped" }
+      });
+      continue;
+    }
+    const result = runner ? runner(command) : runHostCommand(command, context);
+    results.push({ command, result });
+    if (result.exitCode !== 0)
+      return { ok: false, results };
+    outputHistory += `
+${result.stdout}
+${result.stderr}`;
+    if (command.packageRoot && command.packageTarget) {
+      try {
+        if (!existsSync10(command.packageRoot)) {
+          return {
+            ok: false,
+            results: [
+              {
+                command,
+                result: {
+                  ...result,
+                  exitCode: 1,
+                  stderr: "npm completed without producing the expected Cursor package"
+                }
+              }
+            ]
+          };
+        } else {
+          packageRoot = command.packageRoot;
+        }
+      } catch (error) {
+        return {
+          ok: false,
+          results: [
+            {
+              command,
+              result: {
+                ...result,
+                exitCode: 1,
+                stderr: error instanceof Error ? error.message : String(error)
+              }
+            }
+          ]
+        };
+      }
+    }
+  }
+  return { ok: true, results, packageRoot };
+}
+function runHostCommand(step, context = {}) {
+  if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(step.command)) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Cannot safely execute batch shim ${step.command}; resolve its Node.js CLI entrypoint and retry`
+    };
+  }
+  const result = spawnSync3(step.command, step.args, {
+    cwd: step.cwd,
+    env: (() => {
+      const home = context.home ?? context.env?.HOME ?? os6.homedir();
+      const env = { ...process.env, ...context.env, HOME: home };
+      env.CODEX_HOME = context.env?.CODEX_HOME ?? path13.join(home, ".codex");
+      env.PI_CODING_AGENT_DIR = context.env?.PI_CODING_AGENT_DIR ?? path13.join(home, ".pi", "agent");
+      env.XDG_CONFIG_HOME = context.env?.XDG_CONFIG_HOME ?? path13.join(home, ".config");
+      return env;
+    })(),
+    encoding: "utf8",
+    timeout: 60000,
+    windowsHide: true,
+    shell: false
+  });
+  return {
+    exitCode: result.status ?? (result.error ? 1 : 1),
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
+  };
+}
+var findNpmCli = (npm) => {
+  const dir = path13.dirname(npm);
+  const candidates = [
+    path13.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path13.join(dir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
+    path13.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+  ];
+  return candidates.find((candidate) => existsSync10(candidate)) ?? null;
+};
+
 // packages/workit-core/src/core/setup.ts
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
 function parseList(raw) {
@@ -54682,7 +55066,7 @@ var resolveTokenPath = (configured, fallback, override) => {
 };
 var readConfigRecord = (file) => {
   try {
-    const value = JSON.parse(readFileSync11(file, "utf8"));
+    const value = JSON.parse(readFileSync12(file, "utf8"));
     return isRecord2(value) ? value : null;
   } catch {
     return null;
@@ -54703,11 +55087,12 @@ function buildSetupPreview(values, opts = {}) {
     const current = readConfigFromDir(state.configDir);
     mutations.push({
       type: "merge-json",
-      path: path13.join(state.configDir, "config.json"),
+      path: path14.join(state.configDir, "config.json"),
       value: {
         locale: values.locale,
         localeOptions: current.localeOptions,
         timezone: values.timezone,
+        ...values.commitPolicy === undefined ? {} : { commitPolicy: values.commitPolicy },
         branchPolicy: mergePreset(values.branchPreset, {
           allowed: values.branchPreset === "custom" ? parseList(values.branchAllowed) : undefined,
           protectedNames: values.branchPreset === "custom" ? parseList(values.branchProtected) : undefined
@@ -54729,17 +55114,17 @@ function buildSetupPreview(values, opts = {}) {
       if (blocked.length === 0) {
         mutations.push({
           type: "update-workspaces",
-          path: path13.join(state.configDir, "workspaces.json"),
+          path: path14.join(state.configDir, "workspaces.json"),
           entries: values.workspaces,
           expectedRevision: diskWorkspaceResult.revision
         });
       }
     }
     if (values.baseUrl.trim()) {
-      const ytPath = path13.join(state.configDir, "youtrack.json");
+      const ytPath = path14.join(state.configDir, "youtrack.json");
       const ytExisting = readConfigRecord(ytPath);
       const ytConfigured = configuredTokenPath(ytExisting, "tokenFile");
-      const tokenPath = resolveTokenPath(ytConfigured, path13.join(state.configDir, "youtrack.token"), values.tokenPaths?.youtrack);
+      const tokenPath = resolveTokenPath(ytConfigured, path14.join(state.configDir, "youtrack.token"), values.tokenPaths?.youtrack);
       const draft = youtrackDraft(values, tokenPath);
       if (ytConfigured !== null && tokenPath !== ytConfigured) {
         delete draft.tokenFile;
@@ -54755,7 +55140,7 @@ function buildSetupPreview(values, opts = {}) {
         path: ytPath,
         value: draft
       });
-      if (existsSync10(tokenPath))
+      if (existsSync11(tokenPath))
         preserved.push(tokenPath);
       else
         mutations.push({
@@ -54767,7 +55152,7 @@ function buildSetupPreview(values, opts = {}) {
         });
     }
     if (values.vcsProvider !== "skip") {
-      const vcsPath = path13.join(state.configDir, "vcs.json");
+      const vcsPath = path14.join(state.configDir, "vcs.json");
       mutations.push({
         type: "merge-json",
         path: vcsPath,
@@ -54781,16 +55166,45 @@ function buildSetupPreview(values, opts = {}) {
         if (platform === "opencode") {
           mutations.push({ type: "register-platform", platform, path: paths.opencodeConfig });
         } else if (platform === "cursor") {
+          const cursorRoot = adapterRoot("cursor", {
+            ...paths,
+            dev: opts.dev ?? env.WORKFLOW_TOOLKIT_DEV ?? null
+          });
+          if (cursorRoot === null) {
+            const commands = planHostInstall("cursor", {
+              home: paths.home,
+              cwd: paths.cwd,
+              env,
+              packageVersion: "latest",
+              targetDir: paths.cursorPluginDir
+            });
+            mutations.push({
+              type: "install-host",
+              platform: "cursor",
+              path: path14.join(paths.home, ".cursor", "plugins", "local", ".workit-package-bootstrap"),
+              commands
+            });
+          }
           mutations.push({ type: "install-adapter", platform, path: paths.cursorPluginDir });
           mutations.push({ type: "register-platform", platform, path: paths.cursorSettings });
           mutations.push({ type: "register-platform", platform, path: paths.cursorMcp });
+        } else if (platform === "codex" || platform === "pi") {
+          const commands = planHostInstall(platform, { home: paths.home, cwd: paths.cwd, env });
+          if (commands.length > 0) {
+            mutations.push({
+              type: "install-host",
+              platform,
+              path: platform === "codex" ? path14.join(env.CODEX_HOME ?? path14.join(paths.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : path14.join(env.PI_CODING_AGENT_DIR ?? path14.join(paths.home, ".pi", "agent"), "settings.json"),
+              commands
+            });
+          }
         }
       }
     }
     if (values.applyProject) {
-      const root = path13.resolve(opts.cwd ?? process.cwd());
-      const gitignorePath = path13.join(root, ".gitignore");
-      const existing = existsSync10(gitignorePath) ? readFileSync11(gitignorePath, "utf8") : "";
+      const root = path14.resolve(opts.cwd ?? process.cwd());
+      const gitignorePath = path14.join(root, ".gitignore");
+      const existing = existsSync11(gitignorePath) ? readFileSync12(gitignorePath, "utf8") : "";
       const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
       const entries = GITIGNORE_ENTRIES.filter((e) => e.trim() !== "" && !existingLines.has(e.trim()));
@@ -54812,16 +55226,16 @@ function buildSetupPreview(values, opts = {}) {
 }
 var resolveSetupPaths = (options, configDir) => {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os6.homedir();
+  const home = options.home ?? env.HOME ?? os7.homedir();
   return {
     home,
     configDir,
     cwd: options.cwd ?? process.cwd(),
     env,
-    opencodeConfig: options.opencodeConfig ?? path13.join(home, ".config", "opencode", "opencode.json"),
-    cursorSettings: options.cursorSettings ?? path13.join(home, ".cursor", "settings.json"),
-    cursorMcp: options.cursorMcp ?? path13.join(home, ".cursor", "mcp.json"),
-    cursorPluginDir: options.cursorPluginDir ?? path13.join(home, ".cursor", "plugins", "local", "workit")
+    opencodeConfig: options.opencodeConfig ?? path14.join(home, ".config", "opencode", "opencode.json"),
+    cursorSettings: options.cursorSettings ?? path14.join(home, ".cursor", "settings.json"),
+    cursorMcp: options.cursorMcp ?? path14.join(home, ".cursor", "mcp.json"),
+    cursorPluginDir: options.cursorPluginDir ?? path14.join(home, ".cursor", "plugins", "local", "workit")
   };
 };
 function resolveApply(preview, options) {
@@ -54835,9 +55249,9 @@ var isRecord2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 var readExisting = (p) => {
   let raw;
   try {
-    raw = readFileSync11(p, "utf8");
+    raw = readFileSync12(p, "utf8");
   } catch {
-    if (existsSync10(p))
+    if (existsSync11(p))
       return { kind: "malformed", error: `${p} is not readable` };
     return { kind: "missing" };
   }
@@ -54861,7 +55275,7 @@ function deepMerge(base, patch) {
 }
 var readFileSafe = (p) => {
   try {
-    return readFileSync11(p, "utf8");
+    return readFileSync12(p, "utf8");
   } catch {
     return null;
   }
@@ -54877,7 +55291,7 @@ var workspaceEntriesAlreadyMatch = (contents, file, entries) => {
   }
 };
 function applyMutation(m) {
-  const dir = path13.dirname(m.path);
+  const dir = path14.dirname(m.path);
   switch (m.type) {
     case "create-file": {
       mkdirSync5(dir, { recursive: true });
@@ -55026,7 +55440,7 @@ function applyMutation(m) {
           detail: "already configured"
         };
       }
-      mkdirSync5(path13.dirname(m.path), { recursive: true });
+      mkdirSync5(path14.dirname(m.path), { recursive: true });
       writeFileSync5(m.path, JSON.stringify(merged, null, 2) + `
 `, "utf8");
       return existing.kind === "record" ? { platform: "core", file: m.path, status: "Configured" } : { platform: "core", file: m.path, status: "Installed" };
@@ -55035,28 +55449,33 @@ function applyMutation(m) {
 }
 var isAdapter = (root, platform) => {
   try {
-    const pkg = JSON.parse(readFileSync11(path13.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync12(path14.join(root, "package.json"), "utf8"));
     return pkg.name === `@brainervirus/workit-${platform}`;
   } catch {
     return false;
   }
 };
-function adapterRoot(platform, res) {
+function adapterRoot(platform, res, preferInstalledAdapter = false) {
   const candidates = [];
+  const stagedCursor = path14.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap", "node_modules", "@brainervirus", "workit-cursor");
+  if (platform === "cursor" && preferInstalledAdapter)
+    candidates.push(stagedCursor);
   if (res.dev) {
-    candidates.push(path13.join(res.dev, "packages", `workit-${platform}`));
+    candidates.push(path14.join(res.dev, "packages", `workit-${platform}`));
   } else {
-    candidates.push(path13.join(packageRoot(), "..", `workit-${platform}`));
-    let dir = path13.resolve(res.cwd);
+    candidates.push(path14.join(packageRoot(), "..", `workit-${platform}`));
+    let dir = path14.resolve(res.cwd);
     while (true) {
-      candidates.push(path13.join(dir, "packages", `workit-${platform}`));
-      const parent = path13.dirname(dir);
+      candidates.push(path14.join(dir, "packages", `workit-${platform}`));
+      const parent = path14.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
     }
   }
-  candidates.push(path13.join(res.home, ".local", "share", "workit", "packages", `workit-${platform}`));
+  candidates.push(path14.join(res.home, ".local", "share", "workit", "packages", `workit-${platform}`));
+  if (platform === "cursor")
+    candidates.push(stagedCursor);
   for (const candidate of candidates) {
     if (isAdapter(candidate, platform))
       return candidate;
@@ -55073,16 +55492,16 @@ var resolveOpenCodePin = (root, opts = {}) => {
   if (!isDevOpenCodeAdapterRoot(root, opts.dev))
     return OPENCODE_NPM_PIN;
   for (const rel of ["src/plugin.ts", "dist/plugin.js"]) {
-    const entry = path13.join(root, rel);
-    if (existsSync10(entry))
+    const entry = path14.join(root, rel);
+    if (existsSync11(entry))
       return `file://${entry}`;
   }
   return null;
 };
 var opencodePin = (root, res) => resolveOpenCodePin(root, { dev: res.dev });
 function applyOpenCode(root, res) {
-  const pin = opencodePin(root, res);
-  if (!pin) {
+  const resolvedPin = opencodePin(root, res);
+  if (!resolvedPin) {
     return {
       platform: "opencode",
       file: res.opencodeConfig,
@@ -55090,7 +55509,7 @@ function applyOpenCode(root, res) {
       detail: "workit-opencode package has no loadable plugin entry (src/plugin.ts or dist/plugin.js)"
     };
   }
-  mkdirSync5(path13.dirname(res.opencodeConfig), { recursive: true });
+  mkdirSync5(path14.dirname(res.opencodeConfig), { recursive: true });
   const existing = readExisting(res.opencodeConfig);
   if (existing.kind === "malformed") {
     return {
@@ -55100,7 +55519,17 @@ function applyOpenCode(root, res) {
       detail: `cannot merge into malformed config: ${existing.error} — repair or remove the file`
     };
   }
-  const merged = mergeOpenCodeConfig(existing.kind === "record" ? existing.value : {}, pin);
+  const configuredPlugins = existing.kind === "record" ? Array.isArray(existing.value.plugins) ? existing.value.plugins : typeof existing.value.plugins === "string" ? [existing.value.plugins] : typeof existing.value.plugin === "string" ? [existing.value.plugin] : Array.isArray(existing.value.plugin) ? existing.value.plugin : [] : [];
+  const configuredPin = configuredPlugins.find((entry) => typeof entry === "string" && isWorkitPlugin(entry));
+  const pin = configuredPin ?? resolvedPin;
+  const base = existing.kind === "record" ? existing.value : {};
+  const merged = existing.kind === "record" && Object.hasOwn(existing.value, "plugins") ? (() => {
+    const plugins = mergeOpenCodePlugins(existing.value.plugins, pin);
+    return {
+      config: { ...existing.value, plugins: plugins.config },
+      changed: plugins.changed.length > 0 ? ["plugins"] : []
+    };
+  })() : mergeOpenCodeConfig(base, pin);
   if (merged.changed.length === 0) {
     return {
       platform: "opencode",
@@ -55125,22 +55554,22 @@ function applyOpenCode(root, res) {
 }
 var samePluginContent = (src, dest, relative = "") => {
   try {
-    for (const entry of readdirSync4(src, { withFileTypes: true })) {
+    for (const entry of readdirSync5(src, { withFileTypes: true })) {
       if (entry.name === "node_modules")
         continue;
-      const source = path13.join(src, entry.name);
-      const installed = path13.join(dest, entry.name);
+      const source = path14.join(src, entry.name);
+      const installed = path14.join(dest, entry.name);
       if (entry.isDirectory()) {
-        if (!statSync3(installed).isDirectory() || !samePluginContent(source, installed, path13.join(relative, entry.name)))
+        if (!statSync4(installed).isDirectory() || !samePluginContent(source, installed, path14.join(relative, entry.name)))
           return false;
-      } else if (!readFileSync11(source).equals(readFileSync11(installed))) {
+      } else if (!readFileSync12(source).equals(readFileSync12(installed))) {
         return false;
       }
     }
-    for (const entry of readdirSync4(dest, { withFileTypes: true })) {
-      if (existsSync10(path13.join(src, entry.name)))
+    for (const entry of readdirSync5(dest, { withFileTypes: true })) {
+      if (existsSync11(path14.join(src, entry.name)))
         continue;
-      const rel = path13.join(relative, entry.name);
+      const rel = path14.join(relative, entry.name);
       if (rel === ".workit-root")
         continue;
       if (relative === "rules" && entry.isFile() && entry.name.endsWith(".mdc"))
@@ -55154,43 +55583,43 @@ var samePluginContent = (src, dest, relative = "") => {
 };
 var preservedCursorRules = (src, dest) => {
   const preserved = new Map;
-  const sourceRules = path13.join(src, "rules");
-  const installedRules = path13.join(dest, "rules");
+  const sourceRules = path14.join(src, "rules");
+  const installedRules = path14.join(dest, "rules");
   try {
-    for (const entry of readdirSync4(installedRules, { withFileTypes: true })) {
+    for (const entry of readdirSync5(installedRules, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".mdc"))
         continue;
-      if (existsSync10(path13.join(sourceRules, entry.name)))
+      if (existsSync11(path14.join(sourceRules, entry.name)))
         continue;
-      preserved.set(entry.name, readFileSync11(path13.join(installedRules, entry.name)));
+      preserved.set(entry.name, readFileSync12(path14.join(installedRules, entry.name)));
     }
   } catch {}
   return preserved;
 };
 function copyPluginDir(src, dest) {
   const realSrc = realpathSync2(src);
-  const marker = path13.join(dest, ".workit-root");
-  const destIsLink = existsSync10(dest) && lstatSync4(dest).isSymbolicLink();
+  const marker = path14.join(dest, ".workit-root");
+  const destIsLink = existsSync11(dest) && lstatSync4(dest).isSymbolicLink();
   const synced = !destIsLink && readFileSafe(marker)?.trim() === realSrc && samePluginContent(realSrc, dest);
   if (synced)
     return "Skipped";
-  const hadDir = existsSync10(dest);
+  const hadDir = existsSync11(dest);
   const rules = preservedCursorRules(realSrc, dest);
-  const parent = path13.dirname(dest);
+  const parent = path14.dirname(dest);
   mkdirSync5(parent, { recursive: true });
-  const swap = mkdtempSync(path13.join(parent, `.${path13.basename(dest)}.swap-`));
-  const stage = path13.join(swap, "stage");
-  const backup = path13.join(swap, "backup");
+  const swap = mkdtempSync(path14.join(parent, `.${path14.basename(dest)}.swap-`));
+  const stage = path14.join(swap, "stage");
+  const backup = path14.join(swap, "backup");
   try {
     cpSync3(realSrc, stage, {
       recursive: true,
-      filter: (entry) => !path13.relative(realSrc, entry).split(path13.sep).includes("node_modules")
+      filter: (entry) => !path14.relative(realSrc, entry).split(path14.sep).includes("node_modules")
     });
     for (const [name, content] of rules) {
-      mkdirSync5(path13.join(stage, "rules"), { recursive: true });
-      writeFileSync5(path13.join(stage, "rules", name), content);
+      mkdirSync5(path14.join(stage, "rules"), { recursive: true });
+      writeFileSync5(path14.join(stage, "rules", name), content);
     }
-    writeFileSync5(path13.join(stage, ".workit-root"), realSrc + `
+    writeFileSync5(path14.join(stage, ".workit-root"), realSrc + `
 `, "utf8");
     if (!samePluginContent(realSrc, stage))
       throw new Error("staged adapter content is incomplete");
@@ -55202,7 +55631,7 @@ function copyPluginDir(src, dest) {
     try {
       renameSync2(stage, dest);
     } catch (error) {
-      if (hadDir && !existsSync10(dest))
+      if (hadDir && !existsSync11(dest))
         renameSync2(backup, dest);
       throw error;
     }
@@ -55213,26 +55642,26 @@ function copyPluginDir(src, dest) {
   return hadDir ? "Configured" : "Installed";
 }
 var removeLegacyCursorDir = (res) => {
-  const legacy = path13.join(res.home, ".cursor", "plugins", "local", "workflow-toolkit");
-  if (legacy === res.cursorPluginDir || !existsSync10(legacy))
+  const legacy = path14.join(res.home, ".cursor", "plugins", "local", "workflow-toolkit");
+  if (legacy === res.cursorPluginDir || !existsSync11(legacy))
     return;
-  const legacyRules = path13.join(legacy, "rules");
-  if (existsSync10(legacyRules)) {
+  const legacyRules = path14.join(legacy, "rules");
+  if (existsSync11(legacyRules)) {
     try {
-      mkdirSync5(path13.join(res.cursorPluginDir, "rules"), { recursive: true });
-      for (const entry of readdirSync4(legacyRules, { withFileTypes: true })) {
+      mkdirSync5(path14.join(res.cursorPluginDir, "rules"), { recursive: true });
+      for (const entry of readdirSync5(legacyRules, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith(".mdc"))
           continue;
-        const target = path13.join(res.cursorPluginDir, "rules", entry.name);
-        if (!existsSync10(target))
-          copyFileSync2(path13.join(legacyRules, entry.name), target);
+        const target = path14.join(res.cursorPluginDir, "rules", entry.name);
+        if (!existsSync11(target))
+          copyFileSync2(path14.join(legacyRules, entry.name), target);
       }
     } catch {}
   }
   rmSync(legacy, { recursive: true, force: true });
 };
 function applyCursorSettings(root, res) {
-  mkdirSync5(path13.dirname(res.cursorSettings), { recursive: true });
+  mkdirSync5(path14.dirname(res.cursorSettings), { recursive: true });
   const settingsExisting = readExisting(res.cursorSettings);
   if (settingsExisting.kind === "malformed") {
     return {
@@ -55260,7 +55689,7 @@ function applyCursorSettings(root, res) {
   };
 }
 function applyCursorMcp(root, res) {
-  mkdirSync5(path13.dirname(res.cursorMcp), { recursive: true });
+  mkdirSync5(path14.dirname(res.cursorMcp), { recursive: true });
   const mcpExisting = readExisting(res.cursorMcp);
   if (mcpExisting.kind === "malformed") {
     return {
@@ -55270,7 +55699,18 @@ function applyCursorMcp(root, res) {
       detail: `cannot merge into malformed config: ${mcpExisting.error} — repair or remove the file`
     };
   }
-  const mcp = mergeCursorMcp(mcpExisting.kind === "record" ? mcpExisting.value : {}, "workit", cursorMcpServerEntry(res.cursorPluginDir));
+  const mcpBase = mcpExisting.kind === "record" ? mcpExisting.value : {};
+  const server = cursorMcpServerEntry(res.cursorPluginDir);
+  const servers = isRecord2(mcpBase.mcpServers) ? mcpBase.mcpServers : {};
+  const current = isRecord2(servers.workit) ? servers.workit : {};
+  const previousArgs = Array.isArray(current.args) ? current.args.map(String) : [];
+  const previousPackage = previousArgs.find((arg) => arg.startsWith("--package=@brainervirus/workit-cursor@") && arg !== `--package=${CURSOR_RUNTIME_PACKAGE}`);
+  if (previousPackage) {
+    const index = server.args.findIndex((arg) => arg.startsWith("--package="));
+    if (index >= 0)
+      server.args[index] = previousPackage;
+  }
+  const mcp = mergeCursorMcp(mcpBase, "workit", server);
   if (mcp.changed.length === 0) {
     return {
       platform: "cursor",
@@ -55288,9 +55728,9 @@ function applyCursorMcp(root, res) {
   };
 }
 function verifyPlatform(platform, res) {
-  if (platform === "opencode" && !existsSync10(res.opencodeConfig))
+  if (platform === "opencode" && !existsSync11(res.opencodeConfig))
     return null;
-  if (platform === "cursor" && !existsSync10(res.cursorSettings) && !existsSync10(res.cursorMcp)) {
+  if (platform === "cursor" && !existsSync11(res.cursorSettings) && !existsSync11(res.cursorMcp)) {
     return null;
   }
   return runDoctor({
@@ -55355,6 +55795,51 @@ function applySetupPreview(preview, options = {}) {
   const rootFor = new Map;
   let cursorCopyOk = false;
   for (const mutation of preview.mutations) {
+    if (mutation.type === "install-host") {
+      const expectedPath = mutation.platform === "cursor" ? path14.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap") : mutation.platform === "codex" ? path14.join(res.env.CODEX_HOME ?? path14.join(res.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : mutation.platform === "pi" ? path14.join(res.env.PI_CODING_AGENT_DIR ?? path14.join(res.home, ".pi", "agent"), "settings.json") : "";
+      if (mutation.path !== expectedPath) {
+        entries.push({
+          platform: mutation.platform,
+          file: mutation.path,
+          status: "Failed",
+          detail: `preview/apply path mismatch: apply resolved ${expectedPath}, the previewed host install was ${mutation.path} — rebuild the preview with the same options`
+        });
+        continue;
+      }
+      const run = options.runHostCommand ?? ((step) => runHostCommand(step, { home: res.home, env: res.env }));
+      const installed = runHostInstall(mutation.commands, run);
+      for (const { command, result } of installed.results) {
+        entries.push({
+          platform: mutation.platform,
+          file: command.command,
+          status: result.exitCode === 0 ? "Installed" : "Failed",
+          detail: result.exitCode === 0 ? `${command.purpose} (${command.args.join(" ")})` : `${command.purpose} failed (${command.args.join(" ")}): ${result.stderr || `exit ${result.exitCode}`}`
+        });
+      }
+      if (!installed.ok && installed.results.length === 0) {
+        entries.push({
+          platform: mutation.platform,
+          file: mutation.platform,
+          status: "Failed",
+          detail: "host installation did not run"
+        });
+      }
+      if (!installed.ok)
+        continue;
+      if (mutation.platform === "cursor" && installed.packageRoot) {
+        rootFor.set("cursor", installed.packageRoot);
+      }
+      const verified = mutation.platform === "codex" ? isCodexWorkitInstalled(res.home, res.env) : mutation.platform === "pi" ? isPiWorkitInstalled(res.home, res.env) : true;
+      if (!verified) {
+        entries.push({
+          platform: mutation.platform,
+          file: mutation.platform,
+          status: "Failed",
+          detail: "the host command succeeded, but Workit registration was not found; inspect the host's native package list and retry"
+        });
+      }
+      continue;
+    }
     if (mutation.type !== "register-platform" && mutation.type !== "install-adapter") {
       entries.push(applyMutation(mutation));
       continue;
@@ -55372,7 +55857,7 @@ function applySetupPreview(preview, options = {}) {
     }
     let root = rootFor.get(platform);
     if (root === undefined) {
-      root = adapterRoot(platform, res);
+      root = adapterRoot(platform, res, options.preferInstalledAdapter);
       rootFor.set(platform, root);
     }
     if (root === null) {
@@ -55468,7 +55953,7 @@ var setupCompletionGuidance = () => [
 ];
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path13.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path14.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -55480,7 +55965,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path13.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path14.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -55529,7 +56014,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync5(path13.dirname(wsPath), { recursive: true });
+  mkdirSync5(path14.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync5(tmp, JSON.stringify({ ...document2, workspaces: next }, null, 2) + `
@@ -55588,6 +56073,201 @@ function validateBaseUrl(url) {
     return "base URL must use https";
   return null;
 }
+function workspaceEditorValue(workspace, field) {
+  const [section, key, leaf] = field.split(".");
+  if (section === "defaultProfile")
+    return workspace.defaultProfile ?? "";
+  if (section === "vcs") {
+    if (key === "account")
+      return workspace.vcs?.account ?? "";
+    return workspace.vcs?.defaultTargetBranch ?? "";
+  }
+  if (section === "youtrack")
+    return key === "baseUrl" ? workspace.youtrack?.baseUrl ?? "" : workspace.youtrack?.link_issues === undefined ? "inherit" : String(workspace.youtrack.link_issues);
+  if (section === "issues")
+    return workspace.issues?.link_on_pr === undefined ? "inherit" : String(workspace.issues.link_on_pr);
+  if (section === "branchPolicy") {
+    const value = workspace.branchPolicy;
+    if (key === "preset")
+      return value?.preset ?? "inherit";
+    if (key === "allowed")
+      return value?.allowed?.join(", ") ?? "";
+    if (key === "protected")
+      return value?.protected?.join(", ") ?? "";
+    if (key === "developBranch")
+      return value?.developBranch ?? "";
+    if (key === "integration")
+      return value?.integration ?? "merge";
+    if (key === "prefixes")
+      return value?.prefixes?.[leaf] ?? "";
+  }
+  if (section === "commitPolicy") {
+    if (key === "preset")
+      return workspace.commitPolicy?.preset ?? "inherit";
+    if (key === "pattern")
+      return workspace.commitPolicy?.pattern ?? "";
+  }
+  return "";
+}
+function setWorkspaceEditorValue(workspace, field, value, defaults = {}) {
+  const [section, key, leaf] = field.split(".");
+  const list = value.split(",").map((item) => item.trim()).filter(Boolean);
+  if (section === "defaultProfile")
+    return { ...workspace, defaultProfile: value.trim() || undefined };
+  if (section === "vcs")
+    return workspace.vcs ? { ...workspace, vcs: { ...workspace.vcs, [key]: value.trim() || undefined } } : workspace;
+  if (section === "youtrack") {
+    const current = workspace.youtrack ?? {};
+    if (key === "baseUrl")
+      return { ...workspace, youtrack: { ...current, baseUrl: value.trim() || undefined } };
+    if (!value || value === "inherit") {
+      const { link_issues: _discard, ...rest } = current;
+      return { ...workspace, youtrack: Object.keys(rest).length ? rest : undefined };
+    }
+    return { ...workspace, youtrack: { ...current, link_issues: value === "true" } };
+  }
+  if (section === "issues") {
+    const current = workspace.issues ?? { provider: "github" };
+    if (!value || value === "inherit") {
+      const { link_on_pr: _discard, ...rest } = current;
+      return { ...workspace, issues: Object.keys(rest).length ? rest : undefined };
+    }
+    return {
+      ...workspace,
+      issues: { ...current, provider: "github", link_on_pr: value === "true" }
+    };
+  }
+  if (section === "branchPolicy") {
+    if (key === "preset" && (!value.trim() || value === "inherit")) {
+      const { branchPolicy: _discard, ...rest } = workspace;
+      return rest;
+    }
+    const current = workspace.branchPolicy ?? { preset: defaults.branchPreset ?? "gitflow" };
+    const branchPolicy = key === "preset" ? { ...current, preset: value || "gitflow" } : key === "allowed" ? { ...current, allowed: list } : key === "protected" ? { ...current, protected: list } : key === "developBranch" ? { ...current, developBranch: value.trim() || undefined } : key === "integration" ? { ...current, integration: value === "pr" ? "pr" : "merge" } : key === "prefixes" ? {
+      ...current,
+      prefixes: {
+        feature: "feature/",
+        bugfix: "bugfix/",
+        release: "release/",
+        hotfix: "hotfix/",
+        ...current.prefixes,
+        [leaf]: value.trim()
+      }
+    } : current;
+    return { ...workspace, branchPolicy };
+  }
+  if (section === "commitPolicy") {
+    if (key === "preset" && (!value.trim() || value === "inherit")) {
+      const { commitPolicy: _discard, ...rest } = workspace;
+      return rest;
+    }
+    const current = workspace.commitPolicy ?? { preset: defaults.commitPreset ?? "conventional" };
+    return {
+      ...workspace,
+      commitPolicy: key === "pattern" ? { ...current, pattern: value || undefined } : { ...current, preset: value }
+    };
+  }
+  return workspace;
+}
+var splitList = (value) => value.split(",").map((item) => item.trim()).filter(Boolean);
+var emptyTrack = () => ({
+  strategy: "gitflow",
+  productionBranch: "main",
+  integrationBranch: "develop",
+  naming: { feature: "feature/{name}", release: "release/{version}", hotfix: "hotfix/{name}" },
+  baseBranch: "develop",
+  mergeBackBranches: ["develop"],
+  pullRequestTarget: "develop",
+  tagNamespace: "",
+  versionSource: { kind: "git-tag" },
+  requiredChecks: []
+});
+function profileEditorValue(profile, field) {
+  const [section, key, leaf] = field.split(".");
+  if (section === "branchPolicy") {
+    const value = profile?.branchPolicy;
+    if (key === "prefixes")
+      return value?.prefixes?.[leaf] ?? "";
+    if (key === "allowed" || key === "protected")
+      return value?.[key]?.join(", ") ?? "";
+    return String(value?.[key] ?? "");
+  }
+  return String(profile?.commitPolicy?.[key] ?? "");
+}
+function setProfileEditorValue(profile, field, value, defaults = {}) {
+  const [section, key, leaf] = field.split(".");
+  if (section === "branchPolicy") {
+    if (key === "preset" && (!value.trim() || value === "inherit")) {
+      const { branchPolicy: _discard, ...rest } = profile;
+      return rest;
+    }
+    const current = profile.branchPolicy ?? { preset: defaults.branchPreset ?? "gitflow" };
+    let branchPolicy;
+    if (key === "preset")
+      branchPolicy = { ...current, preset: value || "gitflow" };
+    else if (key === "allowed" || key === "protected")
+      branchPolicy = { ...current, [key]: splitList(value) };
+    else if (key === "prefixes")
+      branchPolicy = {
+        ...current,
+        prefixes: {
+          feature: "feature/",
+          bugfix: "bugfix/",
+          release: "release/",
+          hotfix: "hotfix/",
+          ...current.prefixes,
+          [leaf]: value
+        }
+      };
+    else if (key === "developBranch")
+      branchPolicy = { ...current, developBranch: value || undefined };
+    else
+      branchPolicy = { ...current, integration: value === "pr" ? "pr" : "merge" };
+    return { ...profile, branchPolicy };
+  }
+  const current = profile.commitPolicy ?? { preset: defaults.commitPreset ?? "conventional" };
+  if (key === "preset" && (!value.trim() || value === "inherit")) {
+    const { commitPolicy: _discard, ...rest } = profile;
+    return rest;
+  }
+  return {
+    ...profile,
+    commitPolicy: key === "pattern" ? { ...current, pattern: value || undefined } : { ...current, preset: value || "conventional" }
+  };
+}
+function trackEditorValue(track, field) {
+  if (field.startsWith("naming."))
+    return track.naming[field.slice(7)];
+  if (field === "mergeBackBranches" || field === "requiredChecks")
+    return track[field].join(", ");
+  if (field.startsWith("versionSource.")) {
+    const key = field.slice(14);
+    if (key === "kind")
+      return track.versionSource.kind;
+    if (key === "path")
+      return track.versionSource.kind === "package-json" ? track.versionSource.path : "";
+    return track.versionSource.kind === "package-json" ? track.versionSource.field : "";
+  }
+  return String(track[field] ?? "");
+}
+function setTrackEditorValue(track, field, value) {
+  if (field.startsWith("naming."))
+    return { ...track, naming: { ...track.naming, [field.slice(7)]: value } };
+  if (field === "mergeBackBranches" || field === "requiredChecks")
+    return { ...track, [field]: splitList(value) };
+  if (field.startsWith("versionSource.")) {
+    const key = field.slice(14);
+    const kind = key === "kind" ? value : track.versionSource.kind;
+    const versionSource = kind === "package-json" ? {
+      kind,
+      path: key === "path" ? value : track.versionSource.kind === kind ? track.versionSource.path : "package.json",
+      field: key === "field" ? value : track.versionSource.kind === kind ? track.versionSource.field : "version"
+    } : kind === "manual" ? { kind } : { kind: "git-tag" };
+    return { ...track, versionSource };
+  }
+  return { ...track, [field]: value };
+}
+var createReleaseTrack = emptyTrack;
 function loadWorkspaces() {
   return loadWorkspacesFrom(configDir());
 }
@@ -55605,8 +56285,8 @@ function applyWizardBranchPolicy(branchPolicy, workspace_root, env = process.env
 }
 
 // packages/workit-cli/src/wizard-state.ts
-import { existsSync as existsSync11, statSync as statSync4 } from "node:fs";
-import path14 from "node:path";
+import { existsSync as existsSync12, statSync as statSync5 } from "node:fs";
+import path15 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 var NEXT = {
   platforms: "locale",
@@ -55625,6 +56305,10 @@ var NEXT = {
   workspaceName: "workspaceGlob",
   workspaceGlob: "workspaceProvider",
   workspaceProvider: null,
+  workspaceAdvanced: null,
+  workspaceAdvancedValue: null,
+  globalCommitPolicy: null,
+  globalCommitPattern: null,
   branchPolicy: "project",
   branchPolicyDevelop: "branchPolicy",
   project: "summary",
@@ -55648,6 +56332,10 @@ var PREV = {
   workspaceName: "workspaces",
   workspaceGlob: "workspaceName",
   workspaceProvider: "workspaceGlob",
+  workspaceAdvanced: "workspaces",
+  workspaceAdvancedValue: "workspaceAdvanced",
+  globalCommitPolicy: "workspaces",
+  globalCommitPattern: "globalCommitPolicy",
   branchPolicy: "workspaces",
   branchPolicyDevelop: "branchPolicy",
   project: "branchPolicy",
@@ -55662,7 +56350,7 @@ function resolveBasePath(values, env = process.env) {
 }
 var isDirectory = (p) => {
   try {
-    return statSync4(p).isDirectory();
+    return statSync5(p).isDirectory();
   } catch {
     return false;
   }
@@ -55671,9 +56359,9 @@ var basePathMessage = (value) => {
   const p = value.trim();
   if (!p)
     return "workspace root path is required";
-  return !path14.isAbsolute(p) || !isDirectory(p) ? `invalid workspace root "${p}" — enter an existing absolute directory` : null;
+  return !path15.isAbsolute(p) || !isDirectory(p) ? `invalid workspace root "${p}" — enter an existing absolute directory` : null;
 };
-var skipsBranchPolicy = (screen, basePath) => (screen === "branchPolicy" || screen === "branchPolicyDevelop") && !existsSync11(path14.join(basePath, ".git"));
+var skipsBranchPolicy = (screen, basePath) => (screen === "branchPolicy" || screen === "branchPolicyDevelop") && !existsSync12(path15.join(basePath, ".git"));
 function nextScreen(screen, preset, tracker, basePath) {
   let next = NEXT[screen];
   while (next && (skipsCustomBranch(next, preset) || skipsBranchPolicy(next, basePath) || skipsYoutrack(next, tracker) || skipsBasePath(next, basePath)))
@@ -55756,6 +56444,7 @@ function createInitialDraft(config = readConfig(), opts = {}) {
       branchPreset: config.branchPolicy.preset,
       branchAllowed: policy.allowed.join(", "),
       branchProtected: policy.protected.join(", "),
+      commitPolicy: { ...config.commitPolicy },
       baseUrl: "",
       basePath: process.env.WORKFLOW_WORKSPACE_ROOT ?? "",
       issueTracker: "youtrack",
@@ -55793,23 +56482,17 @@ function reducer3(draft, action) {
           const next = decodeIssueTracker(action.value, draft.values.issueTracker);
           if (next === draft.values.issueTracker)
             return draft;
-          const stripIssues = (workspace) => {
-            const rest = { ...workspace };
-            delete rest.issues;
-            return rest;
-          };
-          const needsStrip = next !== "github" && (draft.values.workspaces.some((w) => w.issues !== undefined) || draft.workspaceDraft?.issues !== undefined);
           const errors = { ...draft.errors };
           delete errors.baseUrl;
           return {
             ...draft,
             errors,
-            workspaceDraft: needsStrip && draft.workspaceDraft ? stripIssues(draft.workspaceDraft) : draft.workspaceDraft,
+            workspaceDraft: draft.workspaceDraft,
             values: {
               ...draft.values,
               issueTracker: next,
               baseUrl: next === "youtrack" ? draft.values.baseUrl : "",
-              workspaces: needsStrip ? draft.values.workspaces.map(stripIssues) : draft.values.workspaces
+              workspaces: draft.values.workspaces
             }
           };
         }
@@ -55939,6 +56622,18 @@ function reducer3(draft, action) {
         errors: {}
       };
     }
+    case "workspaceAdvancedOpen": {
+      const entry = draft.values.workspaces[action.index];
+      if (!entry)
+        return draft;
+      return {
+        ...draft,
+        screen: "workspaceAdvanced",
+        workspaceIndex: action.index,
+        workspaceDraft: entry.vcs ? { ...entry, vcs: { ...entry.vcs } } : { ...entry },
+        workspaceEditorField: undefined
+      };
+    }
     case "workspaceRemove":
       return {
         ...draft,
@@ -55962,34 +56657,165 @@ function reducer3(draft, action) {
         ...draft,
         workspaceDraft: {
           ...base,
-          vcs: provider === "skip" ? undefined : { provider, defaultTargetBranch: vcs?.defaultTargetBranch }
+          vcs: provider === "skip" ? undefined : { ...vcs, provider }
         }
       };
     }
-    case "workspaceSave": {
-      const wd = draft.workspaceDraft;
-      if (!wd || !wd.name.trim() || !wd.glob.trim())
+    case "workspaceAdvancedSelect":
+      return { ...draft, screen: "workspaceAdvancedValue", workspaceEditorField: action.field };
+    case "workspaceAdvancedSet": {
+      if (!draft.workspaceDraft)
         return draft;
-      const entry = wd.vcs ? { ...wd, vcs: { ...wd.vcs } } : { ...wd, vcs: undefined };
-      const workspaces = draft.workspaceIndex === null ? [...draft.values.workspaces, entry] : draft.values.workspaces.map((w, i) => i === draft.workspaceIndex ? entry : w);
       return {
         ...draft,
-        screen: "workspaces",
-        workspaceDraft: null,
-        workspaceIndex: null,
-        values: { ...draft.values, workspaces },
-        errors: {}
+        workspaceDraft: setWorkspaceEditorValue(draft.workspaceDraft, action.field, action.value, {
+          branchPreset: draft.values.branchPreset,
+          commitPreset: draft.values.commitPolicy.preset
+        }),
+        screen: "workspaceAdvanced"
       };
     }
-  }
-}
-function defaultWorkspaceProvider(vcs, tracker) {
-  if (tracker === "github")
-    return "github";
-  if (tracker === "gitlab")
-    return "gitlab";
-  return vcs === "gitlab" || vcs === "github" ? vcs : null;
-}
+    case "globalCommitOpen":
+      return { ...draft, screen: "globalCommitPolicy" };
+    case "globalCommitEditPattern":
+      return { ...draft, screen: "globalCommitPattern" };
+    case "globalCommitPreset": {
+      const valid = [
+        "conventional",
+        "gitmoji",
+        "ticket-prefix",
+        "freeform",
+        "custom",
+        "auto"
+      ];
+      if (!valid.includes(action.value))
+        return draft;
+      return {
+        ...draft,
+        values: {
+          ...draft.values,
+          commitPolicy: {
+            ...draft.values.commitPolicy,
+            preset: action.value
+          }
+        }
+      };
+    }
+    case "globalCommitPattern":
+      return {
+        ...draft,
+        values: {
+          ...draft.values,
+          commitPolicy: { ...draft.values.commitPolicy, pattern: action.value || undefined }
+        }
+      };
+    case "globalCommitPatternDone":
+      return { ...draft, screen: "globalCommitPolicy" };
+    case "workspaceProfileCreate": {
+      const name = action.name.trim();
+      if (!draft.workspaceDraft || !name || draft.workspaceDraft.profiles?.[name])
+        return draft;
+      const profiles = {
+        ...draft.workspaceDraft.profiles,
+        [name]: { commitPolicy: { preset: "conventional" } }
+      };
+      return { ...draft, workspaceDraft: { ...draft.workspaceDraft, profiles } };
+    }
+    case "workspaceProfileDelete": {
+      if (!draft.workspaceDraft?.profiles?.[action.name])
+        return draft;
+      const profiles = { ...draft.workspaceDraft.profiles };
+      delete profiles[action.name];
+      return {
+        ...draft,
+        workspaceDraft: {
+          ...draft.workspaceDraft,
+          profiles,
+          defaultProfile: draft.workspaceDraft.defaultProfile === action.name ? undefined : draft.workspaceDraft.defaultProfile
+        }
+      };
+    }
+    case "workspaceProfileDefault": {
+      if (!draft.workspaceDraft?.profiles?.[action.name])
+        return draft;
+      return { ...draft, workspaceDraft: { ...draft.workspaceDraft, defaultProfile: action.name } };
+    }
+    case "workspaceProfileSet": {
+      const profile = draft.workspaceDraft?.profiles?.[action.name];
+      if (!draft.workspaceDraft || !profile)
+        return draft;
+      return {
+        ...draft,
+        workspaceDraft: {
+          ...draft.workspaceDraft,
+          profiles: {
+            ...draft.workspaceDraft.profiles,
+            [action.name]: setProfileEditorValue(profile, action.field, action.value, {
+              branchPreset: draft.values.branchPreset,
+              commitPreset: draft.values.commitPolicy.preset
+            })
+          }
+        }
+      };
+    }
+    case "workspaceTrackCreate": {
+      const name = action.name.trim();
+      if (!draft.workspaceDraft || !name || draft.workspaceDraft.releaseTracks?.[name])
+        return draft;
+      return {
+        ...draft,
+        workspaceDraft: {
+          ...draft.workspaceDraft,
+          releaseTracks: { ...draft.workspaceDraft.releaseTracks, [name]: createReleaseTrack() }
+        }
+      };
+    }
+    case "workspaceTrackDelete": {
+      if (!draft.workspaceDraft?.releaseTracks?.[action.name])
+        return draft;
+      const releaseTracks = { ...draft.workspaceDraft.releaseTracks };
+      delete releaseTracks[action.name];
+      return { ...draft, workspaceDraft: { ...draft.workspaceDraft, releaseTracks } };
+    }
+    case "workspaceTrackSet": {
+      const track = draft.workspaceDraft?.releaseTracks?.[action.name];
+      if (!draft.workspaceDraft || !track)
+        return draft;
+      return {
+        ...draft,
+        workspaceDraft: {
+          ...draft.workspaceDraft,
+          releaseTracks: {
+            ...draft.workspaceDraft.releaseTracks,
+            [action.name]: setTrackEditorValue(track, action.field, action.value)
+          }
+        }
+      };
+    }
+    case "workspaceSave": {
+      const wd = draft.workspaceDraft;
+      if (!wd || !wd.name.trim() || !wd.glob.trim())
+        return draft;
+      const entry = wd.vcs ? { ...wd, vcs: { ...wd.vcs } } : { ...wd, vcs: undefined };
+      const workspaces = draft.workspaceIndex === null ? [...draft.values.workspaces, entry] : draft.values.workspaces.map((w, i) => i === draft.workspaceIndex ? entry : w);
+      return {
+        ...draft,
+        screen: "workspaces",
+        workspaceDraft: null,
+        workspaceIndex: null,
+        values: { ...draft.values, workspaces },
+        errors: {}
+      };
+    }
+  }
+}
+function defaultWorkspaceProvider(vcs, tracker) {
+  if (tracker === "github")
+    return "github";
+  if (tracker === "gitlab")
+    return "gitlab";
+  return vcs === "gitlab" || vcs === "github" ? vcs : null;
+}
 function workspaceVcs(vcs, tracker) {
   const provider = defaultWorkspaceProvider(vcs, tracker);
   return provider ? { provider } : undefined;
@@ -56018,32 +56844,30 @@ function workspaceDraftText(draft, field, value) {
 }
 
 // packages/workit-core/src/core/detect-hosts.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5 } from "node:fs";
-import os8 from "node:os";
-import path16 from "node:path";
+import os9 from "node:os";
 
 // packages/workit-core/src/core/uninstall.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12, realpathSync as realpathSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import os7 from "node:os";
-import path15 from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, realpathSync as realpathSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import os8 from "node:os";
+import path16 from "node:path";
 var resolveUninstallPaths = (options = {}) => {
-  const home = options.home ?? options.env?.HOME ?? os7.homedir();
+  const home = options.home ?? options.env?.HOME ?? os8.homedir();
   return {
-    opencodeConfig: options.opencodeConfig ?? path15.join(home, ".config", "opencode", "opencode.json"),
-    cursorSettings: options.cursorSettings ?? path15.join(home, ".cursor", "settings.json"),
-    cursorMcp: options.cursorMcp ?? path15.join(home, ".cursor", "mcp.json"),
-    cursorPluginDir: options.cursorPluginDir ?? path15.join(home, ".cursor", "plugins", "local", "workit"),
-    codexPluginDir: path15.join(home, ".codex", "plugins", "workit"),
-    piConfig: path15.join(home, ".pi", "config.json")
+    opencodeConfig: options.opencodeConfig ?? path16.join(home, ".config", "opencode", "opencode.json"),
+    cursorSettings: options.cursorSettings ?? path16.join(home, ".cursor", "settings.json"),
+    cursorMcp: options.cursorMcp ?? path16.join(home, ".cursor", "mcp.json"),
+    cursorPluginDir: options.cursorPluginDir ?? path16.join(home, ".cursor", "plugins", "local", "workit"),
+    codexPluginDir: path16.join(home, ".codex", "plugins", "workit"),
+    piConfig: path16.join(home, ".pi", "config.json")
   };
 };
 var isRecord3 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 var readJsonRecord = (file) => {
   let raw;
   try {
-    raw = readFileSync12(file, "utf8");
+    raw = readFileSync13(file, "utf8");
   } catch {
-    if (existsSync12(file))
+    if (existsSync13(file))
       return { kind: "malformed", error: `${file} is not readable` };
     return { kind: "missing" };
   }
@@ -56055,8 +56879,8 @@ var readJsonRecord = (file) => {
   }
 };
 var stripTrailingSep = (p) => {
-  const j = path15.join(p);
-  return path15.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
+  const j = path16.join(p);
+  return path16.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
 };
 var CURSOR_LEGACY_IDENTITIES = ["workflow-toolkit", "local/workflow-toolkit"];
 function cleanCursorSettings(settings, pluginDir) {
@@ -56167,7 +56991,7 @@ function planUninstall(paths = {}) {
   const mcpExisting = readJsonRecord(res.cursorMcp);
   const settingsDirty = settingsExisting.kind === "malformed" || settingsExisting.kind === "record" && cleanCursorSettings(settingsExisting.value, res.cursorPluginDir).changed;
   const mcpDirty = mcpExisting.kind === "malformed" || mcpExisting.kind === "record" && cleanCursorMcp(mcpExisting.value).changed;
-  const dirExists = existsSync12(res.cursorPluginDir);
+  const dirExists = existsSync13(res.cursorPluginDir);
   const actions = [];
   if (settingsDirty) {
     actions.push({
@@ -56195,7 +57019,7 @@ function planUninstall(paths = {}) {
     installed: settingsDirty || mcpDirty || dirExists,
     actions
   };
-  const codexInstalled = existsSync12(res.codexPluginDir);
+  const codexInstalled = existsSync13(res.codexPluginDir);
   const codex = {
     host: "codex",
     installed: codexInstalled,
@@ -56217,8 +57041,8 @@ function planUninstall(paths = {}) {
   return { hosts: [opencode, cursor, codex, pi] };
 }
 var canonicalRemoveDirAllowed = (actionPath, res) => {
-  const expected = path15.resolve(res.cursorPluginDir);
-  if (!(actionPath === expected && path15.basename(expected) === "workit" && path15.basename(path15.dirname(expected)) === "local" && path15.basename(path15.dirname(path15.dirname(expected))) === "plugins")) {
+  const expected = path16.resolve(res.cursorPluginDir);
+  if (!(actionPath === expected && path16.basename(expected) === "workit" && path16.basename(path16.dirname(expected)) === "local" && path16.basename(path16.dirname(path16.dirname(expected))) === "plugins")) {
     return false;
   }
   try {
@@ -56242,7 +57066,7 @@ var applyEditJsonRemove = (target, cleaner) => {
 `;
   let current;
   try {
-    current = readFileSync12(target, "utf8");
+    current = readFileSync13(target, "utf8");
   } catch (error) {
     return {
       status: "failed",
@@ -56270,12 +57094,12 @@ function applyUninstall(plan, paths = {}) {
       let status;
       let detail;
       if (action.kind === "remove-dir") {
-        const resolved = path15.resolve(action.path);
-        const allowed = canonicalRemoveDirAllowed(resolved, res) || resolved === path15.resolve(res.codexPluginDir) && path15.basename(resolved) === "workit" && path15.basename(path15.dirname(resolved)) === "plugins";
+        const resolved = path16.resolve(action.path);
+        const allowed = canonicalRemoveDirAllowed(resolved, res) || resolved === path16.resolve(res.codexPluginDir) && path16.basename(resolved) === "workit" && path16.basename(path16.dirname(resolved)) === "plugins";
         if (!allowed) {
           status = "failed";
           detail = `refusing to remove non-canonical plugin directory: ${resolved}`;
-        } else if (!existsSync12(resolved)) {
+        } else if (!existsSync13(resolved)) {
           status = "skipped";
           detail = "directory already absent";
         } else {
@@ -56306,13 +57130,7 @@ function applyUninstall(plan, paths = {}) {
 
 // packages/workit-core/src/core/detect-hosts.ts
 var HOSTS = ["opencode", "cursor", "codex", "pi"];
-var HOME_MARKERS = {
-  opencode: [path16.join(".config", "opencode")],
-  cursor: [".cursor"],
-  codex: [".codex"],
-  pi: [".pi"]
-};
-var WIZARD_HOSTS = ["opencode", "cursor"];
+var WIZARD_HOSTS = [...HOSTS];
 function preselectedPlatforms(detection) {
   return WIZARD_HOSTS.filter((host) => detection[host].detected);
 }
@@ -56326,52 +57144,19 @@ function emptyDetection() {
 }
 function detectHosts(options = {}) {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os8.homedir();
-  const plan = planUninstall(options);
+  const home = options.home ?? env.HOME ?? os9.homedir();
+  const plan = planUninstall({ ...options, home, env });
   const configuredByHost = new Map(plan.hosts.map((h) => [h.host, h.installed]));
   const found = emptyDetection();
   for (const host of HOSTS) {
-    const detected = cliFound(host, env, home) || HOME_MARKERS[host].some((m) => existsSync13(path16.join(home, m)));
+    const detected = findHostExecutable(host, { home, env }) !== null || installedHostApp(host, home, env);
     found[host] = {
       detected,
-      configured: WIZARD_HOSTS.includes(host) && (configuredByHost.get(host) ?? false)
+      configured: host === "codex" ? isCodexWorkitInstalled(home, env) || (configuredByHost.get(host) ?? false) : host === "pi" ? isPiWorkitInstalled(home, env) || (configuredByHost.get(host) ?? false) : configuredByHost.get(host) ?? false
     };
   }
   return found;
 }
-function cliFound(name, env, home) {
-  if (commandOnPath(name, env))
-    return true;
-  const extra = managerBinDirs(home);
-  if (extra.length === 0)
-    return false;
-  return commandOnPath(name, {
-    ...env,
-    PATH: [...(env.PATH ?? "").split(path16.delimiter), ...extra].join(path16.delimiter)
-  });
-}
-var managerBinDirs = (home) => {
-  const dirs = [path16.join(home, ".local", "bin"), path16.join(home, ".asdf", "shims")];
-  const versioned = [
-    [path16.join(home, ".local", "share", "fnm", "node-versions"), path16.join("installation", "bin")],
-    [path16.join(home, ".nvm", "versions", "node"), "bin"]
-  ];
-  for (const [base, tail] of versioned) {
-    let entries;
-    try {
-      entries = readdirSync5(base, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      try {
-        if (entry.isDirectory())
-          dirs.push(path16.join(base, entry.name, tail));
-      } catch {}
-    }
-  }
-  return dirs;
-};
 
 // packages/workit-cli/src/search-select.tsx
 var import_react65 = __toESM(require_react(), 1);
@@ -56469,22 +57254,10 @@ function SearchSelect({
 var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 var PLATFORM_LABELS = [
   { label: "OpenCode", value: "opencode" },
-  { label: "Cursor", value: "cursor" }
+  { label: "Cursor", value: "cursor" },
+  { label: "Codex", value: "codex" },
+  { label: "Pi", value: "pi" }
 ];
-function platformOptions(detection) {
-  return PLATFORM_LABELS.map(({ label, value }) => {
-    const found = detection[value];
-    const tag = found.configured ? " · already configured" : found.detected ? " · detected" : "";
-    return { label: `${label}${tag}`, value };
-  });
-}
-function externalHostGuidance(detection) {
-  return ["codex", "pi"].map((host) => {
-    const found = detection[host];
-    const status = found.configured ? "already configured" : found.detected ? "detected" : "not detected";
-    return host === "codex" ? `Codex · ${status} — plugin/hooks setup: https://github.com/BrainerVirus/workit#readme (Codex CLI / desktop)` : `Pi · ${status} — install separately: pi install @brainervirus/workit-pi`;
-  });
-}
 var BRANCH_PRESETS = [
   { label: "GitFlow", value: "gitflow" },
   { label: "GitHub Flow", value: "github-flow" },
@@ -56522,6 +57295,99 @@ var ISSUE_TRACKERS = [
   { label: "GitLab Issues", value: "gitlab" },
   { label: "None", value: "none" }
 ];
+var WORKSPACE_ADVANCED_FIELDS = [
+  { label: "Hosting provider account", value: "vcs.account" },
+  { label: "Default target branch", value: "vcs.defaultTargetBranch" },
+  { label: "Workspace YouTrack URL", value: "youtrack.baseUrl" },
+  { label: "Link issues in YouTrack", value: "youtrack.link_issues" },
+  { label: "Link GitHub issues on pull requests", value: "issues.link_on_pr" },
+  { label: "Branch preset", value: "branchPolicy.preset" },
+  { label: "Allowed branch patterns", value: "branchPolicy.allowed" },
+  { label: "Protected branches", value: "branchPolicy.protected" },
+  { label: "Develop branch", value: "branchPolicy.developBranch" },
+  { label: "Integration method (pr or merge)", value: "branchPolicy.integration" },
+  { label: "Feature prefix", value: "branchPolicy.prefixes.feature" },
+  { label: "Bugfix prefix", value: "branchPolicy.prefixes.bugfix" },
+  { label: "Release prefix", value: "branchPolicy.prefixes.release" },
+  { label: "Hotfix prefix", value: "branchPolicy.prefixes.hotfix" },
+  { label: "Commit policy preset", value: "commitPolicy.preset" },
+  { label: "Custom commit pattern", value: "commitPolicy.pattern" },
+  { label: "Default profile name", value: "defaultProfile" }
+];
+var PROFILE_FIELDS = [
+  { label: "Branch preset", value: "branchPolicy.preset" },
+  { label: "Allowed patterns", value: "branchPolicy.allowed" },
+  { label: "Protected branches", value: "branchPolicy.protected" },
+  { label: "Develop branch", value: "branchPolicy.developBranch" },
+  { label: "Integration (pr or merge)", value: "branchPolicy.integration" },
+  { label: "Feature prefix", value: "branchPolicy.prefixes.feature" },
+  { label: "Bugfix prefix", value: "branchPolicy.prefixes.bugfix" },
+  { label: "Release prefix", value: "branchPolicy.prefixes.release" },
+  { label: "Hotfix prefix", value: "branchPolicy.prefixes.hotfix" },
+  { label: "Commit preset", value: "commitPolicy.preset" },
+  { label: "Commit pattern", value: "commitPolicy.pattern" }
+];
+var TRACK_FIELDS = [
+  { label: "Strategy", value: "strategy" },
+  { label: "Production branch", value: "productionBranch" },
+  { label: "Integration branch", value: "integrationBranch" },
+  { label: "Feature branch naming", value: "naming.feature" },
+  { label: "Release branch naming", value: "naming.release" },
+  { label: "Hotfix branch naming", value: "naming.hotfix" },
+  { label: "Base branch", value: "baseBranch" },
+  { label: "Merge-back branches", value: "mergeBackBranches" },
+  { label: "Pull request target", value: "pullRequestTarget" },
+  { label: "Tag namespace", value: "tagNamespace" },
+  { label: "Version source (manual, git-tag, package-json)", value: "versionSource.kind" },
+  { label: "Package.json path", value: "versionSource.path" },
+  { label: "Package version field", value: "versionSource.field" },
+  { label: "Required checks", value: "requiredChecks" }
+];
+var enumFieldOptions = (field) => {
+  if (field === "commitPolicy.preset")
+    return [{ label: "Inherit global", value: "inherit" }, ...commitPresetOptions];
+  if (field === "branchPolicy.preset")
+    return [
+      { label: "Inherit global", value: "inherit" },
+      { label: "GitFlow", value: "gitflow" },
+      { label: "GitHub Flow", value: "github-flow" },
+      { label: "Trunk-based", value: "trunk-based" },
+      { label: "Custom", value: "custom" }
+    ];
+  if (field === "strategy")
+    return [
+      { label: "GitFlow", value: "gitflow" },
+      { label: "GitHub Flow", value: "github-flow" },
+      { label: "Trunk-based", value: "trunk-based" },
+      { label: "Custom", value: "custom" }
+    ];
+  if (field.endsWith(".integration"))
+    return [
+      { label: "Pull requests", value: "pr" },
+      { label: "Merge commits", value: "merge" }
+    ];
+  if (field === "versionSource.kind")
+    return [
+      { label: "Package.json", value: "package-json" },
+      { label: "Git tag", value: "git-tag" },
+      { label: "Manual", value: "manual" }
+    ];
+  if (field === "youtrack.link_issues" || field === "issues.link_on_pr")
+    return [
+      { label: "Inherit global behavior", value: "inherit" },
+      { label: "Enabled", value: "true" },
+      { label: "Disabled", value: "false" }
+    ];
+  return null;
+};
+var commitPresetOptions = [
+  { label: "Conventional commits", value: "conventional" },
+  { label: "Gitmoji", value: "gitmoji" },
+  { label: "Ticket prefix", value: "ticket-prefix" },
+  { label: "Freeform", value: "freeform" },
+  { label: "Custom pattern", value: "custom" },
+  { label: "Auto-detect", value: "auto" }
+];
 var TIMEZONE_FALLBACK = [
   "UTC",
   "America/New_York",
@@ -56560,6 +57426,8 @@ var TEXT_SCREENS = new Set([
   "basePath",
   "workspaceName",
   "workspaceGlob",
+  "workspaceAdvancedValue",
+  "globalCommitPattern",
   "branchPolicyDevelop"
 ]);
 var SEARCH_SCREENS = new Set(["locale", "timezone"]);
@@ -56604,6 +57472,479 @@ function SelectList({
     }, option.value, true, undefined, this))
   }, undefined, false, undefined, this);
 }
+function HostPicker({
+  detection,
+  selected,
+  onChange,
+  onSubmit
+}) {
+  const available = PLATFORM_LABELS.filter(({ value }) => detection[value].detected).map(({ value }) => value);
+  const options = [
+    { label: "Select all available", value: "__all" },
+    { label: "Clear all", value: "__none" },
+    ...PLATFORM_LABELS.map(({ label, value }) => ({ label, value }))
+  ];
+  const [index, setIndex] = import_react66.useState(0);
+  const indexRef = import_react66.useRef(index);
+  const [chosen, setChosen] = import_react66.useState(selected);
+  const chosenRef = import_react66.useRef(chosen);
+  import_react66.useEffect(() => {
+    indexRef.current = index;
+  }, [index]);
+  import_react66.useEffect(() => {
+    chosenRef.current = chosen;
+  }, [chosen]);
+  const update = (next) => {
+    chosenRef.current = next;
+    setChosen(next);
+    onChange(next);
+  };
+  use_input_default((input, key) => {
+    if (key.upArrow || key.downArrow) {
+      const next = Math.max(0, Math.min(options.length - 1, indexRef.current + (key.downArrow ? 1 : -1)));
+      indexRef.current = next;
+      setIndex(next);
+      return;
+    }
+    if (input === " ") {
+      const option = options[indexRef.current];
+      if (option.value === "__all")
+        update([...available]);
+      else if (option.value === "__none")
+        update([]);
+      else if (detection[option.value].detected) {
+        const next = chosenRef.current.includes(option.value) ? chosenRef.current.filter((host) => host !== option.value) : [...chosenRef.current, option.value];
+        update(next);
+      }
+    } else if (key.return) {
+      const option = options[indexRef.current];
+      if (option.value === "__all")
+        update([...available]);
+      else if (option.value === "__none")
+        update([]);
+      onSubmit(chosenRef.current);
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+    flexDirection: "column",
+    gap: 0,
+    children: options.map((option, row) => {
+      const host = option.value === "__all" || option.value === "__none" ? null : option.value;
+      const detected = host === null || detection[host].detected;
+      const checked = host !== null && chosen.includes(host);
+      const label = host === null ? option.label : `${checked ? "[✓]" : "[ ]"} ${option.label}${detection[host].configured ? " · already configured" : detection[host].detected ? " · detected" : " · unavailable"}`;
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        color: row === index ? "cyan" : undefined,
+        dimColor: !detected,
+        children: [
+          row === index ? "❯ " : "  ",
+          label
+        ]
+      }, option.value, true, undefined, this);
+    })
+  }, undefined, false, undefined, this);
+}
+function WorkspaceCollectionEditor({
+  draft,
+  dispatch
+}) {
+  const [mode, setMode] = import_react66.useState("main");
+  const [name, setName] = import_react66.useState("");
+  const [field, setField] = import_react66.useState(null);
+  const [nameError, setNameError] = import_react66.useState("");
+  const workspace = draft.workspaceDraft;
+  const profileNames = Object.keys(workspace?.profiles ?? {});
+  const trackNames = Object.keys(workspace?.releaseTracks ?? {});
+  if (!workspace)
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      color: "red",
+      children: "Workspace draft is unavailable."
+    }, undefined, false, undefined, this);
+  if (mode === "profiles") {
+    const options = [
+      ...profileNames.flatMap((profile) => [
+        { label: `Edit profile ${profile}`, value: `edit:${profile}` },
+        { label: `Set ${profile} as default`, value: `default:${profile}` },
+        { label: `Delete profile ${profile}`, value: `delete:${profile}` }
+      ]),
+      { label: "Create profile", value: "create" },
+      { label: "Back to advanced settings", value: "back" }
+    ];
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: [
+            "Profiles · default: ",
+            workspace.defaultProfile ?? "none"
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Profiles can override branch rules and commit conventions."
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+          options,
+          value: "back",
+          onSelect: (value) => {
+            const profileName = value.slice(value.indexOf(":") + 1);
+            if (value === "create") {
+              setNameError("");
+              setName("");
+              setMode("profileName");
+            } else if (value.startsWith("edit:")) {
+              setName(profileName);
+              setMode("profileEdit");
+            } else if (value.startsWith("default:"))
+              dispatch({ type: "workspaceProfileDefault", name: profileName });
+            else if (value.startsWith("delete:"))
+              dispatch({ type: "workspaceProfileDelete", name: profileName });
+            else
+              setMode("main");
+          }
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (mode === "profileName")
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: "Create profile"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Profile name:"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+          onSubmit: (value) => {
+            const next = value.trim();
+            if (!next) {
+              setNameError("Enter a profile name.");
+              return;
+            }
+            if (workspace.profiles?.[next]) {
+              setNameError(`Profile ${next} already exists. Choose a different name or edit it from the list.`);
+              return;
+            }
+            dispatch({ type: "workspaceProfileCreate", name: next });
+            setName(next);
+            setMode("profileEdit");
+          }
+        }, undefined, false, undefined, this),
+        nameError && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          color: "red",
+          children: nameError
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Enter to create · Esc Back"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  if (mode === "profileEdit" || mode === "profileValue") {
+    const selected = workspace.profiles?.[name];
+    if (mode === "profileValue" && field) {
+      const item = PROFILE_FIELDS.find((entry) => entry.value === field);
+      const choices = enumFieldOptions(field);
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            bold: true,
+            children: [
+              "Profile ",
+              name,
+              " · ",
+              item?.label
+            ]
+          }, undefined, true, undefined, this),
+          choices ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options: choices,
+            value: selected ? profileEditorValue(selected, field) : choices[0].value,
+            onSelect: (value) => {
+              dispatch({
+                type: "workspaceProfileSet",
+                name,
+                field,
+                value
+              });
+              setMode("profileEdit");
+            }
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+            defaultValue: selected ? profileEditorValue(selected, field) : "",
+            onSubmit: (value) => {
+              dispatch({
+                type: "workspaceProfileSet",
+                name,
+                field,
+                value
+              });
+              setMode("profileEdit");
+            }
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Enter to save · Esc Back"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    const options = [
+      ...PROFILE_FIELDS,
+      { label: "Done editing", value: "done" }
+    ];
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: [
+            "Edit profile · ",
+            name
+          ]
+        }, undefined, true, undefined, this),
+        PROFILE_FIELDS.map((item) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            item.label,
+            ": ",
+            selected ? profileEditorValue(selected, item.value) || "unset" : ""
+          ]
+        }, item.value, true, undefined, this)),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+          options,
+          value: "done",
+          onSelect: (value) => {
+            if (value === "done")
+              setMode("profiles");
+            else {
+              setField(value);
+              setMode("profileValue");
+            }
+          }
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (mode === "tracks") {
+    const options = [
+      ...trackNames.flatMap((track) => [
+        { label: `Edit release track ${track}`, value: `edit:${track}` },
+        { label: `Delete release track ${track}`, value: `delete:${track}` }
+      ]),
+      { label: "Create release track", value: "create" },
+      { label: "Back to advanced settings", value: "back" }
+    ];
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: "Named release tracks"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Each track has its own branches, naming, version source, and checks."
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+          options,
+          value: "back",
+          onSelect: (value) => {
+            const trackName = value.slice(value.indexOf(":") + 1);
+            if (value === "create") {
+              setNameError("");
+              setName("");
+              setMode("trackName");
+            } else if (value.startsWith("edit:")) {
+              setName(trackName);
+              setMode("trackEdit");
+            } else if (value.startsWith("delete:"))
+              dispatch({ type: "workspaceTrackDelete", name: trackName });
+            else
+              setMode("main");
+          }
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (mode === "trackName")
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: "Create release track"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Track name:"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+          onSubmit: (value) => {
+            const next = value.trim();
+            if (!next) {
+              setNameError("Enter a release-track name.");
+              return;
+            }
+            if (workspace.releaseTracks?.[next]) {
+              setNameError(`Release track ${next} already exists. Choose a different name or edit it from the list.`);
+              return;
+            }
+            dispatch({ type: "workspaceTrackCreate", name: next });
+            setName(next);
+            setMode("trackEdit");
+          }
+        }, undefined, false, undefined, this),
+        nameError && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          color: "red",
+          children: nameError
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: "Enter to create · Esc Back"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  if (mode === "trackEdit" || mode === "trackValue") {
+    const selected = workspace.releaseTracks?.[name];
+    if (mode === "trackValue" && field) {
+      const item = TRACK_FIELDS.find((entry) => entry.value === field);
+      const choices = enumFieldOptions(field);
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            bold: true,
+            children: [
+              "Release track ",
+              name,
+              " · ",
+              item?.label
+            ]
+          }, undefined, true, undefined, this),
+          choices ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options: choices,
+            value: selected ? trackEditorValue(selected, field) : choices[0].value,
+            onSelect: (value) => {
+              dispatch({
+                type: "workspaceTrackSet",
+                name,
+                field,
+                value
+              });
+              setMode("trackEdit");
+            }
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+            defaultValue: selected ? trackEditorValue(selected, field) : "",
+            onSubmit: (value) => {
+              dispatch({
+                type: "workspaceTrackSet",
+                name,
+                field,
+                value
+              });
+              setMode("trackEdit");
+            }
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Lists use comma-separated values · Enter to save · Esc Back"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    const options = [...TRACK_FIELDS, { label: "Done editing", value: "done" }];
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          children: [
+            "Edit release track · ",
+            name
+          ]
+        }, undefined, true, undefined, this),
+        TRACK_FIELDS.map((item) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            item.label,
+            ": ",
+            selected ? trackEditorValue(selected, item.value) || "unset" : ""
+          ]
+        }, item.value, true, undefined, this)),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+          options,
+          value: "done",
+          onSelect: (value) => {
+            if (value === "done")
+              setMode("tracks");
+            else {
+              setField(value);
+              setMode("trackValue");
+            }
+          }
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const options = [
+    ...WORKSPACE_ADVANCED_FIELDS,
+    { label: "Manage profiles", value: "profiles" },
+    { label: "Manage release tracks", value: "tracks" },
+    { label: "Save workspace settings", value: "save" }
+  ];
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+    flexDirection: "column",
+    gap: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        bold: true,
+        children: [
+          "Advanced workspace settings · ",
+          workspace.name
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        dimColor: true,
+        children: "Choose a setting to edit. Lists use comma-separated values; blank clears an override."
+      }, undefined, false, undefined, this),
+      [...WORKSPACE_ADVANCED_FIELDS].map(({ label, value }) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          label,
+          ": ",
+          workspaceEditorValue(workspace, value) || "inherited / unset"
+        ]
+      }, value, true, undefined, this)),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+        options,
+        value: "save",
+        onSelect: (value) => {
+          if (value === "save")
+            dispatch({ type: "workspaceSave" });
+          else if (value === "profiles")
+            setMode("profiles");
+          else if (value === "tracks")
+            setMode("tracks");
+          else
+            dispatch({ type: "workspaceAdvancedSelect", field: value });
+        }
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
 function effectivePolicy(values) {
   return mergePreset(values.branchPreset, {
     allowed: parseList(values.branchAllowed),
@@ -56815,6 +58156,8 @@ function describeMutation(m) {
       return `+ register ${m.platform}: ${m.path}`;
     case "install-adapter":
       return `+ copy adapter ${m.platform}: ${m.path}`;
+    case "install-host":
+      return `+ install ${m.platform}: ${m.commands.map((command) => command.command).join(", ")}`;
     case "set-token-path":
       return `+ change ${m.key} in ${m.path} → ${m.value}`;
   }
@@ -56870,28 +58213,21 @@ function Screen({
             children: "Step 1 — Platforms"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-            children: "This wizard configures OpenCode and Cursor only."
+            children: "Choose the detected tools where Workit should be configured."
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Select the tools to configure (space to toggle):"
+            children: "Use Space to toggle, or choose Select all available / Clear all."
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(MultiSelect, {
-            options: platformOptions(detection),
-            defaultValue: draft.values.platforms,
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(HostPicker, {
+            detection,
+            selected: draft.values.platforms,
             onChange: (values) => dispatch({ type: "set", field: "platforms", value: values }),
             onSubmit: (values) => {
               dispatch({ type: "set", field: "platforms", value: values });
               dispatch({ type: "next" });
             }
           }, undefined, false, undefined, this),
-          externalHostGuidance(detection).map((guidance) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-            children: guidance
-          }, guidance, false, undefined, this)),
-          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-            dimColor: true,
-            children: "For legacy installations, use `workit cutover` to preview migration."
-          }, undefined, false, undefined, this),
           draft.errors.platforms && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             color: "red",
             children: draft.errors.platforms
@@ -57260,7 +58596,12 @@ function Screen({
         })),
         { label: "Add workspace", value: "add" },
         { label: `Use current project (${base})`, value: "current" },
-        { label: "Done", value: "done" }
+        { label: "Done", value: "done" },
+        { label: "Advanced global commit policy", value: "global-commit" },
+        ...draft.values.workspaces.map((w, i) => ({
+          label: `Advanced settings for ${w.name}`,
+          value: `advanced:${i}`
+        }))
       ];
       return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
         flexDirection: "column",
@@ -57300,6 +58641,10 @@ function Screen({
                 dispatch({ type: "workspaceEdit", index: Number(value.slice(5)) });
               else if (value.startsWith("remove:"))
                 dispatch({ type: "workspaceRemove", index: Number(value.slice(7)) });
+              else if (value.startsWith("advanced:"))
+                dispatch({ type: "workspaceAdvancedOpen", index: Number(value.slice(9)) });
+              else if (value === "global-commit")
+                dispatch({ type: "globalCommitOpen" });
               else if (value === "add")
                 dispatch({ type: "workspaceAdd" });
               else if (value === "current")
@@ -57334,93 +58679,222 @@ function Screen({
             onChange: (value) => dispatch({ type: "workspaceDraftName", value }),
             onSubmit: () => dispatch({ type: "next" })
           }, undefined, false, undefined, this),
-          draft.errors.workspaceName && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-            color: "red",
-            children: draft.errors.workspaceName
+          draft.errors.workspaceName && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            color: "red",
+            children: draft.errors.workspaceName
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Enter to continue · Esc Back"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    case "workspaceGlob": {
+      const glob = draft.workspaceDraft?.glob ?? "";
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            bold: true,
+            children: "Step 5 — Workspaces · Pattern"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Workspace pattern (glob, e.g. /work/**):"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+            placeholder: SCREEN_PLACEHOLDERS.workspaceGlob,
+            defaultValue: glob,
+            onChange: (value) => dispatch({ type: "workspaceDraftGlob", value }),
+            onSubmit: () => dispatch({ type: "next" })
+          }, undefined, false, undefined, this),
+          glob.trim() !== "" && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+            flexDirection: "column",
+            gap: 0,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                bold: true,
+                children: "Match preview (shared matcher):"
+              }, undefined, false, undefined, this),
+              workspacePreviewTargets(resolveBasePath(draft.values)).map((target) => {
+                const matches = matchWorkspace(glob, target);
+                return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                  color: matches ? "green" : "red",
+                  children: [
+                    matches ? "✓ matches" : "✗ no match",
+                    " ",
+                    target
+                  ]
+                }, target, true, undefined, this);
+              })
+            ]
+          }, undefined, true, undefined, this),
+          draft.errors.workspaceGlob && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            color: "red",
+            children: draft.errors.workspaceGlob
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Enter to continue · Esc Back"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    case "workspaceProvider":
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            bold: true,
+            children: "Step 5 — Workspaces · Provider"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Version control provider for this workspace:"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options: VCS_PROVIDERS,
+            value: draft.workspaceDraft?.vcs?.provider ?? "skip",
+            onChange: (value) => dispatch({ type: "workspaceDraftProvider", value }),
+            onSelect: (value) => {
+              dispatch({ type: "workspaceDraftProvider", value });
+              dispatch({ type: "workspaceSave" });
+            }
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Enter to save · b Back · Esc Cancel"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    case "workspaceAdvanced": {
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(WorkspaceCollectionEditor, {
+        draft,
+        dispatch
+      }, undefined, false, undefined, this);
+    }
+    case "workspaceAdvancedValue": {
+      const field = draft.workspaceEditorField;
+      const current = draft.workspaceDraft && field ? workspaceEditorValue(draft.workspaceDraft, field) : "";
+      const label = WORKSPACE_ADVANCED_FIELDS.find((entry) => entry.value === field)?.label ?? "Setting";
+      const choices = field ? enumFieldOptions(field) : null;
+      const profileChoices = field === "defaultProfile" ? [
+        { label: "Inherit / no default profile", value: "" },
+        ...Object.keys(draft.workspaceDraft?.profiles ?? {}).map((name) => ({
+          label: name,
+          value: name
+        }))
+      ] : null;
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            bold: true,
+            children: [
+              "Advanced workspace settings · ",
+              label
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Leave empty to clear this override. Use comma-separated values for lists."
+          }, undefined, false, undefined, this),
+          profileChoices ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options: profileChoices,
+            value: current,
+            onSelect: (value) => field && dispatch({ type: "workspaceAdvancedSet", field, value })
+          }, undefined, false, undefined, this) : choices ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options: choices,
+            value: current || choices[0].value,
+            onSelect: (value) => field && dispatch({ type: "workspaceAdvancedSet", field, value })
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+            defaultValue: current,
+            onSubmit: (value) => field && dispatch({ type: "workspaceAdvancedSet", field, value })
+          }, undefined, false, undefined, this),
+          field?.endsWith("integration") && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
+            children: "Enter pr or merge."
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Enter to continue · Esc Back"
+            children: "Enter to save · Esc Back"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this);
-    case "workspaceGlob": {
-      const glob = draft.workspaceDraft?.glob ?? "";
+    }
+    case "globalCommitPolicy": {
+      const options = [
+        { label: "Conventional commits", value: "conventional" },
+        { label: "Gitmoji", value: "gitmoji" },
+        { label: "Ticket prefix", value: "ticket-prefix" },
+        { label: "Freeform", value: "freeform" },
+        { label: "Custom pattern", value: "custom" },
+        { label: "Auto-detect", value: "auto" },
+        { label: "Edit custom pattern…", value: "pattern" },
+        { label: "Done", value: "done" }
+      ];
       return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
         flexDirection: "column",
         gap: 1,
         children: [
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             bold: true,
-            children: "Step 5 — Workspaces · Pattern"
+            children: "Advanced global commit policy"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Workspace pattern (glob, e.g. /work/**):"
+            children: "Default convention used when a workspace has no commit override."
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
-            placeholder: SCREEN_PLACEHOLDERS.workspaceGlob,
-            defaultValue: glob,
-            onChange: (value) => dispatch({ type: "workspaceDraftGlob", value }),
-            onSubmit: () => dispatch({ type: "next" })
-          }, undefined, false, undefined, this),
-          glob.trim() !== "" && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
-            flexDirection: "column",
-            gap: 0,
+          draft.values.commitPolicy.pattern && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            dimColor: true,
             children: [
-              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-                bold: true,
-                children: "Match preview (shared matcher):"
-              }, undefined, false, undefined, this),
-              workspacePreviewTargets(resolveBasePath(draft.values)).map((target) => {
-                const matches = matchWorkspace(glob, target);
-                return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-                  color: matches ? "green" : "red",
-                  children: [
-                    matches ? "✓ matches" : "✗ no match",
-                    " ",
-                    target
-                  ]
-                }, target, true, undefined, this);
-              })
+              "Custom pattern: ",
+              draft.values.commitPolicy.pattern
             ]
           }, undefined, true, undefined, this),
-          draft.errors.workspaceGlob && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
-            color: "red",
-            children: draft.errors.workspaceGlob
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
+            options,
+            value: draft.values.commitPolicy.preset,
+            onSelect: (value) => {
+              if (value === "pattern")
+                dispatch({ type: "globalCommitEditPattern" });
+              else if (value === "done")
+                dispatch({ type: "back" });
+              else
+                dispatch({ type: "globalCommitPreset", value });
+            }
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Enter to continue · Esc Back"
+            children: "Enter to select · b Back"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this);
     }
-    case "workspaceProvider":
+    case "globalCommitPattern":
       return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
         flexDirection: "column",
         gap: 1,
         children: [
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             bold: true,
-            children: "Step 5 — Workspaces · Provider"
+            children: "Advanced global commit policy · Custom pattern"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Version control provider for this workspace:"
+            children: "Regular expression matched against the commit subject line."
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(SelectList, {
-            options: VCS_PROVIDERS,
-            value: draft.workspaceDraft?.vcs?.provider ?? "skip",
-            onChange: (value) => dispatch({ type: "workspaceDraftProvider", value }),
-            onSelect: (value) => {
-              dispatch({ type: "workspaceDraftProvider", value });
-              dispatch({ type: "workspaceSave" });
-            }
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(TextInput, {
+            defaultValue: draft.values.commitPolicy.pattern ?? "",
+            onChange: (value) => dispatch({ type: "globalCommitPattern", value }),
+            onSubmit: () => dispatch({ type: "globalCommitPatternDone" })
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: "Enter to save · b Back · Esc Cancel"
+            children: "Enter to save · Esc Back"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this);
@@ -57494,6 +58968,36 @@ function Screen({
     case "summary": {
       const policy = effectivePolicy(draft.values);
       const preview = buildSetupPreview(draft.values, { cwd: resolveBasePath(draft.values) });
+      const policyPreview = (() => {
+        try {
+          const current = readConfig();
+          const config = {
+            ...current,
+            branchPolicy: mergePreset(draft.values.branchPreset, {
+              allowed: parseList(draft.values.branchAllowed),
+              protectedNames: parseList(draft.values.branchProtected)
+            }, current),
+            commitPolicy: draft.values.commitPolicy
+          };
+          const checkout = resolveBasePath(draft.values);
+          const workspace = resolveWorkspaceFromEntries(checkout, draft.values.workspaces);
+          const resolved = resolveWorkspacePolicy(config, workspace);
+          if (resolved.status === "invalid")
+            return { error: resolved.error };
+          return {
+            error: null,
+            workspace: workspace?.name ?? null,
+            branchSource: resolved.provenance.branchPolicy,
+            commitSource: resolved.provenance.commitPolicy,
+            target: resolved.branchPolicy.defaultTargetBranch,
+            branchPreset: resolved.branchPolicy.preset,
+            commitPreset: resolved.commitPolicy.preset
+          };
+        } catch (error) {
+          return { error: error instanceof Error ? error.message : String(error) };
+        }
+      })();
+      const canApply = preview.ok && policyPreview.error === null;
       return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
         flexDirection: "column",
         gap: 1,
@@ -57544,6 +59048,52 @@ function Screen({
               policy.protected.join(", ")
             ]
           }, undefined, true, undefined, this),
+          policyPreview.error === null ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+            flexDirection: "column",
+            gap: 0,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                children: [
+                  "Sample checkout: ",
+                  /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                    color: "green",
+                    children: resolveBasePath(draft.values)
+                  }, undefined, false, undefined, this),
+                  policyPreview.workspace ? ` · workspace ${policyPreview.workspace}` : " · no matching workspace"
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                children: [
+                  "Effective branch policy: ",
+                  /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                    color: "green",
+                    children: policyPreview.branchPreset
+                  }, undefined, false, undefined, this),
+                  " · target ",
+                  policyPreview.target,
+                  " · source ",
+                  policyPreview.branchSource
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                children: [
+                  "Effective commit policy: ",
+                  /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+                    color: "green",
+                    children: policyPreview.commitPreset
+                  }, undefined, false, undefined, this),
+                  " · source ",
+                  policyPreview.commitSource
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+            color: "red",
+            children: [
+              "Policy preview failed: ",
+              policyPreview.error
+            ]
+          }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             children: [
               "YouTrack base URL:",
@@ -57592,7 +59142,7 @@ function Screen({
               }, o.envKey, true, undefined, this))
             ]
           }, undefined, true, undefined, this),
-          preview.ok ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+          canApply ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
             flexDirection: "column",
             gap: 0,
             children: [
@@ -57600,9 +59150,9 @@ function Screen({
                 bold: true,
                 children: "Will apply:"
               }, undefined, false, undefined, this),
-              preview.mutations.map((m) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+              preview.mutations.map((m, index) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
                 children: describeMutation(m)
-              }, `${m.type}:${m.path}`, false, undefined, this)),
+              }, `${m.type}:${index}`, false, undefined, this)),
               preview.preserved.map((p) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
                 color: "green",
                 children: [
@@ -57631,7 +59181,7 @@ function Screen({
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          preview.ok && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ConfirmInput, {
+          canApply && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ConfirmInput, {
             defaultChoice: "confirm",
             submitOnEnter: false,
             onConfirm: () => dispatch({ type: "apply" }),
@@ -57639,7 +59189,7 @@ function Screen({
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
             dimColor: true,
-            children: preview.ok ? "y to apply · b Back · Esc Cancel" : "b Back · Esc Cancel"
+            children: canApply ? "y to apply · b Back · Esc Cancel" : "b Back · Esc Cancel"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this);
@@ -57658,7 +59208,7 @@ function Screen({
 
 // packages/workit-core/src/core/logger.ts
 import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync6, unlinkSync as unlinkSync4 } from "node:fs";
-import os9 from "node:os";
+import os10 from "node:os";
 import path17 from "node:path";
 var REDACTED = "[REDACTED]";
 var DEFAULT_MAX_RATE = 20;
@@ -57713,10 +59263,10 @@ var resolveStateDir = () => {
   const override = process.env.WORKFLOW_TOOLKIT_STATE;
   if (override)
     return override;
-  const home = os9.homedir();
+  const home = os10.homedir();
   if (process.env.XDG_STATE_HOME)
     return path17.join(process.env.XDG_STATE_HOME, "workit");
-  switch (os9.platform()) {
+  switch (os10.platform()) {
     case "darwin":
       return path17.join(home, "Library", "Application Support", "workit");
     case "win32":
@@ -57725,7 +59275,7 @@ var resolveStateDir = () => {
       return path17.join(process.env.HOME ?? home, ".local", "state", "workit");
   }
 };
-var homePattern = new RegExp(`${escapeRegExp2(os9.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var homePattern = new RegExp(`${escapeRegExp2(os10.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
 var applyPatterns = (value) => {
   let out = value;
   out = out.replace(SECRET_VALUE, REDACTED);
@@ -58115,11 +59665,11 @@ async function runCutoverCommand(argv, deps = {}) {
 }
 
 // packages/workit-cli/src/task.ts
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync20 } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync17, realpathSync as realpathSync10 } from "node:fs";
 import path27 from "node:path";
 
@@ -59792,7 +61342,7 @@ function assertProductWriteAllowed(input) {
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash10 } from "node:crypto";
 import * as fs10 from "node:fs";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import path25 from "node:path";
 
 // packages/workit-core/src/core/authority.ts
@@ -59802,11 +61352,11 @@ import path24 from "node:path";
 
 // packages/workit-core/src/core/auto-approval.ts
 import { createHash as createHash8 } from "node:crypto";
-import { readFileSync as readFileSync15, realpathSync as realpathSync5 } from "node:fs";
+import { readFileSync as readFileSync16, realpathSync as realpathSync5 } from "node:fs";
 import path23 from "node:path";
 
 // packages/workit-core/src/core/branch.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
 import path22 from "node:path";
@@ -59911,11 +61461,11 @@ var gitContext = (workspaceRoot, paths = []) => {
 // packages/workit-core/src/core/vcs-config.ts
 import fs8 from "node:fs";
 import path21 from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path21.join(configDir(), "vcs.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync3("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync4("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -59952,7 +61502,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync3("ssh", ["-G", host], {
+  const resolved = spawnSync4("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -60031,8 +61581,8 @@ function vcsConfig(mode, cwd) {
   const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
   const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
   const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
-  const linkIssues = provider === "gitlab" && typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
-  const youtrackBaseUrl = provider === "gitlab" && typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
+  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
+  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
   let issuesProvider = null;
   let linkOnPr = null;
   if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
@@ -60103,7 +61653,7 @@ function vcsCliIdentity(cwd) {
     PATH: process.env.PATH ?? "",
     ...provider === "github" ? { GH_HOST: host } : { GITLAB_HOST: host }
   };
-  const result = spawnSync3(bin, ["api", "user"], {
+  const result = spawnSync4(bin, ["api", "user"], {
     cwd: root,
     encoding: "utf8",
     env
@@ -60145,7 +61695,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync3("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync4("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -60161,7 +61711,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync3("glab", ["api", ...args], {
+    const run = (args) => spawnSync4("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -60181,7 +61731,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync3("gh", [
+    const r = spawnSync4("gh", [
       "pr",
       "list",
       "--repo",
@@ -60454,7 +62004,7 @@ var branchSetup = ({
   };
   const readManifest = () => {
     try {
-      return JSON.parse(readFileSync14(manifestPath, "utf8"));
+      return JSON.parse(readFileSync15(manifestPath, "utf8"));
     } catch {
       return {};
     }
@@ -60650,7 +62200,7 @@ var OPERATION_CLASS = {
 var operationAutoClass = (operation) => typeof operation === "string" ? OPERATION_CLASS[operation] ?? null : null;
 var digestOf = (configDirPath) => {
   try {
-    const raw = readFileSync15(`${configDirPath}/workspaces.json`, "utf8");
+    const raw = readFileSync16(`${configDirPath}/workspaces.json`, "utf8");
     return createHash8("sha256").update(raw).digest("hex");
   } catch {
     return null;
@@ -61458,7 +63008,7 @@ var compareCodeUnits2 = (left, right) => {
   return left.length - right.length;
 };
 var gitPaths = (root) => {
-  const result = spawnSync4("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -61471,7 +63021,7 @@ var gitPaths = (root) => {
     };
   }
   const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path25.sep).join("/")) : [];
-  const stagedDeleted = spawnSync4("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  const stagedDeleted = spawnSync5("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
@@ -61602,7 +63152,7 @@ function captureCandidate(root, scope, environment = []) {
   const values = supplied.sort((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync4("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync5("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -65090,7 +66640,7 @@ function resolveInside(root, candidate) {
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync10(root);
-  const result = spawnSync5(executable, args, {
+  const result = spawnSync6(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -65106,7 +66656,7 @@ function run2(root, executable, args, env = {}) {
 // packages/workit-core/src/core/pr-create.ts
 import fs11 from "node:fs";
 import path28 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import { pathToFileURL } from "node:url";
 var remoteRepoPath = (remote) => {
   const raw = remote.trim();
@@ -65208,11 +66758,11 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 function repoRoot2(cwd) {
-  const result = spawnSync6("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
+  const result = spawnSync7("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
   return result.status === 0 ? (result.stdout ?? "").trim() : cwd;
 }
 var pushRemote = (cwd) => {
-  const result = spawnSync6("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync7("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -65272,7 +66822,7 @@ var pushTargetIsStable = (cwd, remote) => {
   const target = safePushUrl(remote);
   if (!target)
     return false;
-  const result = spawnSync6("git", ["config", "--get-regexp", "^url\\..*\\.(insteadof|pushinsteadof)$"], { cwd, encoding: "utf8" });
+  const result = spawnSync7("git", ["config", "--get-regexp", "^url\\..*\\.(insteadof|pushinsteadof)$"], { cwd, encoding: "utf8" });
   if (result.status !== 0 && result.status !== 1)
     return false;
   const prefixes = (result.stdout ?? "").split(/\r?\n/u).map((line) => line.trim().slice(line.trim().indexOf(" ") + 1)).filter(Boolean);
@@ -65320,12 +66870,12 @@ function prCreate(env, cwd) {
   const resolvedDefault = String(cfg.defaultTargetBranch ?? policy.defaultTargetBranch ?? "develop");
   const target = targetOverride || resolvedDefault;
   const title = String(env.WF_PR_TITLE ?? "");
-  const br = spawnSync6("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const br = spawnSync7("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd: root,
     encoding: "utf8"
   });
   const branch = br.status === 0 ? (br.stdout ?? "").trim() : "";
-  const sourceResult = branch ? spawnSync6("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
+  const sourceResult = branch ? spawnSync7("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
     cwd: root,
     encoding: "utf8"
   }) : null;
@@ -65334,7 +66884,7 @@ function prCreate(env, cwd) {
     return { error: "approved PR source branch and commit are incomplete" };
   if (env.WORKIT_EXPECTED_SOURCE_BRANCH && env.WORKIT_EXPECTED_SOURCE_BRANCH !== branch || env.WORKIT_EXPECTED_SOURCE_COMMIT && env.WORKIT_EXPECTED_SOURCE_COMMIT !== sourceCommit)
     return { error: "approved PR source branch or commit changed before execution" };
-  const mergeBaseResult = policy.integration === "merge" ? spawnSync6("git", ["rev-parse", "--verify", `refs/heads/${target}`], {
+  const mergeBaseResult = policy.integration === "merge" ? spawnSync7("git", ["rev-parse", "--verify", `refs/heads/${target}`], {
     cwd: root,
     encoding: "utf8"
   }) : null;
@@ -65350,7 +66900,7 @@ function prCreate(env, cwd) {
           targetBranch: target,
           stderr: "source or target branch commit could not be resolved"
         };
-      const merge = spawnSync6("git", ["merge", "--no-ff", sourceCommit, "-m", title], {
+      const merge = spawnSync7("git", ["merge", "--no-ff", sourceCommit, "-m", title], {
         cwd: root,
         encoding: "utf8"
       });
@@ -65361,16 +66911,16 @@ function prCreate(env, cwd) {
           targetBranch: target,
           stderr: (merge.stderr ?? "").slice(0, 800)
         };
-      const mergedCommit = spawnSync6("git", ["rev-parse", "HEAD"], {
+      const mergedCommit = spawnSync7("git", ["rev-parse", "HEAD"], {
         cwd: root,
         encoding: "utf8"
       });
       if (mergedCommit.status !== 0)
         return { error: "merge commit could not be resolved", mode: "merge" };
-      const updateTarget = spawnSync6("git", ["update-ref", `refs/heads/${target}`, mergedCommit.stdout.trim(), mergeBaseCommit], { cwd: root, encoding: "utf8" });
+      const updateTarget = spawnSync7("git", ["update-ref", `refs/heads/${target}`, mergedCommit.stdout.trim(), mergeBaseCommit], { cwd: root, encoding: "utf8" });
       if (updateTarget.status !== 0)
         return { error: "merge target branch changed before update", mode: "merge" };
-      const push = spawnSync6("git", ["push", targetUrl, `${mergedCommit.stdout.trim()}:refs/heads/${target}`], { cwd: root, encoding: "utf8", env: { ...process.env, PATH: process.env.PATH ?? "" } });
+      const push = spawnSync7("git", ["push", targetUrl, `${mergedCommit.stdout.trim()}:refs/heads/${target}`], { cwd: root, encoding: "utf8", env: { ...process.env, PATH: process.env.PATH ?? "" } });
       if (push.status !== 0)
         return {
           error: "push failed",
@@ -65387,7 +66937,7 @@ function prCreate(env, cwd) {
         output: (push.stdout ?? "").trim()
       };
     };
-    const co = spawnSync6("git", ["checkout", "--detach", mergeBaseCommit], {
+    const co = spawnSync7("git", ["checkout", "--detach", mergeBaseCommit], {
       cwd: root,
       encoding: "utf8"
     });
@@ -65399,7 +66949,7 @@ function prCreate(env, cwd) {
         stderr: (co.stderr ?? "").slice(0, 800)
       };
     const result = finish();
-    spawnSync6("git", ["checkout", branch], { cwd: root, encoding: "utf8" });
+    spawnSync7("git", ["checkout", branch], { cwd: root, encoding: "utf8" });
     return result;
   }
   const pr = cfg.pr ?? {};
@@ -65425,7 +66975,7 @@ function prCreate(env, cwd) {
   const push = pr.pushBranch !== false;
   const skipConfirm = pr.confirmSkip !== false;
   const remoteBranchTip = () => {
-    const read = spawnSync6("git", ["ls-remote", targetUrl, `refs/heads/${branch}`], {
+    const read = spawnSync7("git", ["ls-remote", targetUrl, `refs/heads/${branch}`], {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -65441,7 +66991,7 @@ function prCreate(env, cwd) {
       stderr: branch ? "source branch commit could not be resolved" : "empty current branch (detached HEAD or unborn HEAD)"
     };
   if (push) {
-    const pushed = spawnSync6("git", ["push", "-u", targetUrl, `${sourceCommit}:refs/heads/${branch}`], { cwd: root, encoding: "utf8", env: { ...process.env, PATH: process.env.PATH ?? "" } });
+    const pushed = spawnSync7("git", ["push", "-u", targetUrl, `${sourceCommit}:refs/heads/${branch}`], { cwd: root, encoding: "utf8", env: { ...process.env, PATH: process.env.PATH ?? "" } });
     if (pushed.status !== 0)
       return { error: "push failed", provider, stderr: (pushed.stderr ?? "").slice(0, 800) };
   }
@@ -65486,12 +67036,12 @@ function prCreate(env, cwd) {
       cmd.push("--draft");
     cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GH_HOST: identity.host };
   }
-  const result = spawnSync6(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
+  const result = spawnSync7(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
   if (result.status !== 0) {
     const err = (result.stderr ?? result.stdout ?? "").trim();
     let hint = null;
     if (provider === "gitlab" && (err.includes("409") || err.toLowerCase().includes("already exists"))) {
-      const list = spawnSync6("glab", ["mr", "list", `--source-branch=${branch}`, "--output=json"], {
+      const list = spawnSync7("glab", ["mr", "list", `--source-branch=${branch}`, "--output=json"], {
         cwd: root,
         encoding: "utf8",
         env: cmdEnv
@@ -65550,7 +67100,7 @@ function mergePr(cwd, opts) {
     return { error: "approved hosting account changed before execution" };
   if (!/^[a-f0-9]{40,64}$/i.test(opts.sourceCommit))
     return { error: "approved merge source commit is invalid" };
-  const currentCommit = spawnSync6("git", ["rev-parse", "--verify", `refs/heads/${opts.source}`], {
+  const currentCommit = spawnSync7("git", ["rev-parse", "--verify", `refs/heads/${opts.source}`], {
     cwd: root,
     encoding: "utf8"
   });
@@ -65564,7 +67114,7 @@ function mergePr(cwd, opts) {
     return { error: `workflow CLI missing (required for ${provider})` };
   const owner = repoPath.split("/")[0];
   const endpoint = provider === "github" ? `repos/${repository.replace(/^[^/]+\//u, "")}/pulls?state=open&head=${encodeURIComponent(`${owner}:${opts.source}`)}&base=${encodeURIComponent(opts.target)}&per_page=100` : `projects/${encodeURIComponent(repoPath)}/merge_requests?state=opened&source_branch=${encodeURIComponent(opts.source)}&target_branch=${encodeURIComponent(opts.target)}&per_page=100`;
-  const listOpen = () => spawnSync6(provider === "github" ? "gh" : "glab", ["api", endpoint], {
+  const listOpen = () => spawnSync7(provider === "github" ? "gh" : "glab", ["api", endpoint], {
     cwd: root,
     encoding: "utf8",
     env: {
@@ -65624,7 +67174,7 @@ function mergePr(cwd, opts) {
       cmd.push("--delete-branch");
     cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GH_HOST: identity.host };
   }
-  const result = spawnSync6(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
+  const result = spawnSync7(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
   if (result.status !== 0)
     return {
       error: "merge failed",
@@ -65641,8 +67191,8 @@ function mergePr(cwd, opts) {
 }
 
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync18, readdirSync as readdirSync9 } from "node:fs";
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync18, readFileSync as readFileSync19, readdirSync as readdirSync9 } from "node:fs";
 import path29 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
@@ -65670,7 +67220,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync7("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync8("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -65812,7 +67362,7 @@ var packageScripts = (cwd, keys) => {
   if (!existsSync18(pkgPath))
     return [];
   try {
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
     return keys.filter((k) => pkg.scripts && typeof pkg.scripts[k] === "string").map((k) => `${k}: ${pkg.scripts?.[k]}`);
   } catch {
     return [];
@@ -65846,7 +67396,7 @@ var documentationFiles = (cwd) => {
 var readTrimmed = (file, maxLines) => {
   if (!existsSync18(file))
     return "";
-  const lines = readFileSync18(file, "utf8").split(`
+  const lines = readFileSync19(file, "utf8").split(`
 `);
   return lines.slice(0, maxLines).join(`
 `);
@@ -66034,7 +67584,7 @@ function docsRefreshContext(root, range) {
   const pkgPath = path29.join(cwd, "package.json");
   if (existsSync18(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
 `;
     } catch {}
@@ -66111,7 +67661,7 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 var repoPathFromRemote = (remote) => {
   let rest = (remote || "").trim().replace(/\/+$/, "");
   if (!rest)
@@ -66132,7 +67682,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync8(bin, args, {
+    const out = spawnSync9(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -66865,7 +68415,7 @@ async function logTimeUpdate(input, operation = defaultOperations) {
 // packages/workit-core/src/core/external-action-effects.ts
 import fs13 from "node:fs";
 import path31 from "node:path";
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 var run3 = (root, args) => {
   return run2(root, "git", args);
 };
@@ -67265,7 +68815,7 @@ var hostingProvider = (root, remote) => {
 };
 var remoteBranchTip = (root, provider, host, repo, branch) => {
   const endpoint = provider === "github" ? `repos/${repo}/git/ref/heads/${branch.split("/").map(encodeURIComponent).join("/")}` : `projects/${encodeURIComponent(repo)}/repository/branches/${encodeURIComponent(branch)}`;
-  const response = spawnSync9(provider === "github" ? "gh" : "glab", ["api", endpoint], {
+  const response = spawnSync10(provider === "github" ? "gh" : "glab", ["api", endpoint], {
     cwd: root,
     encoding: "utf8",
     env: hostingCliEnv(provider, host)
@@ -67273,7 +68823,7 @@ var remoteBranchTip = (root, provider, host, repo, branch) => {
   if (response.status !== 0) {
     if (/\b404\b/.test(response.stderr ?? "")) {
       const project = provider === "github" ? `repos/${repo}` : `projects/${encodeURIComponent(repo)}`;
-      const visible = spawnSync9(provider === "github" ? "gh" : "glab", ["api", project], {
+      const visible = spawnSync10(provider === "github" ? "gh" : "glab", ["api", project], {
         cwd: root,
         encoding: "utf8",
         env: hostingCliEnv(provider, host)
@@ -67329,7 +68879,7 @@ var mergedBranch = (root, branch) => {
       outcome: "not_started"
     });
   const endpoint = provider === "github" ? `repos/${repo}/pulls?state=closed&head=${encodeURIComponent(`${repo.split("/")[0]}:${branch}`)}&per_page=100` : `projects/${encodeURIComponent(repo)}/merge_requests?state=merged&source_branch=${encodeURIComponent(branch)}&per_page=100`;
-  const response = spawnSync9(provider === "github" ? "gh" : "glab", ["api", endpoint], {
+  const response = spawnSync10(provider === "github" ? "gh" : "glab", ["api", endpoint], {
     cwd: root,
     encoding: "utf8",
     env: hostingCliEnv(provider, auth.host)
@@ -67391,7 +68941,7 @@ var readHostingAction = async (root, resolved, actionRef) => {
       return unknownHostingEvidence(operation);
     const endpoint = cfg.provider === "github" ? `repos/${repo}/pulls?state=all&head=${encodeURIComponent(`${repo.split("/")[0]}:${branch}`)}&base=${encodeURIComponent(target)}&per_page=100&page=1` : `projects/${encodeURIComponent(repo)}/merge_requests?state=all&source_branch=${encodeURIComponent(branch)}&target_branch=${encodeURIComponent(target)}&per_page=100&page=1`;
     const cli = cfg.provider === "github" ? "gh" : "glab";
-    const response = spawnSync9(cli, ["api", endpoint], {
+    const response = spawnSync10(cli, ["api", endpoint], {
       cwd: root,
       encoding: "utf8",
       env: hostingCliEnv(cfg.provider, auth.host)
@@ -68478,7 +70028,7 @@ async function payloadValue(raw, deps) {
     return { ok: true, value: {} };
   let source;
   try {
-    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync19(raw.slice(1))) : raw;
+    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync20(raw.slice(1))) : raw;
   } catch (error) {
     return {
       ok: false,
@@ -69191,6 +70741,498 @@ async function runActionCommand(argv, deps = {}) {
   return result.ok ? 0 : 1;
 }
 
+// packages/workit-cli/src/upgrade.ts
+import { spawnSync as spawnSync11 } from "node:child_process";
+import {
+  existsSync as existsSync19,
+  readFileSync as readFileSync21,
+  mkdirSync as mkdirSync9,
+  copyFileSync as copyFileSync3,
+  chmodSync,
+  cpSync as cpSync4,
+  lstatSync as lstatSync8
+} from "node:fs";
+import path32 from "node:path";
+import os11 from "node:os";
+import { createHash as createHash11 } from "node:crypto";
+var HOSTS2 = ["opencode", "cursor", "codex", "pi"];
+var upgradePaths = (deps) => {
+  const home = deps.home ?? deps.env?.HOME ?? os11.homedir();
+  const env = {
+    ...process.env,
+    ...deps.home || deps.env?.HOME ? {
+      HOME: home,
+      CODEX_HOME: path32.join(home, ".codex"),
+      PI_CODING_AGENT_DIR: path32.join(home, ".pi/agent"),
+      XDG_CONFIG_HOME: path32.join(home, ".config"),
+      WORKFLOW_TOOLKIT_CONFIG: undefined,
+      WORKFLOW_TOOLKIT_CONFIG_DIR: undefined
+    } : {},
+    ...deps.env,
+    HOME: home
+  };
+  const xdg = env.XDG_CONFIG_HOME || path32.join(home, ".config");
+  return {
+    home,
+    env,
+    configDir: env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path32.join(xdg, "workit"),
+    opencodeConfig: path32.join(xdg, "opencode/opencode.json"),
+    piSettings: path32.join(env.PI_CODING_AGENT_DIR ?? path32.join(home, ".pi/agent"), "settings.json"),
+    codexConfig: path32.join(env.CODEX_HOME ?? path32.join(home, ".codex"), "config.toml")
+  };
+};
+var object2 = (file) => {
+  if (!existsSync19(file))
+    return null;
+  let data;
+  try {
+    data = JSON.parse(readFileSync21(file, "utf8"));
+  } catch {
+    throw new Error(`${file} is not valid JSON; use the native host to inspect JSONC settings`);
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data))
+    throw new Error(`${file} is not a configuration object`);
+  return data;
+};
+var digest2 = (file) => existsSync19(file) ? createHash11("sha256").update(readFileSync21(file)).digest("hex") : "missing";
+var runner = (deps) => deps.run ?? ((command, args) => {
+  const { home, env } = upgradePaths(deps);
+  let step;
+  try {
+    step = hostCommand(command, args, { home, env });
+  } catch {
+    return { status: 1, stdout: "" };
+  }
+  const result = runHostCommand(step, { home, env });
+  return { status: result.exitCode, stdout: result.stdout };
+});
+var classify = (host, selector) => ({
+  host,
+  selector,
+  kind: selector === `@brainervirus/workit-${host}` || selector === `@brainervirus/workit-${host}@latest` || selector === `npm:@brainervirus/workit-${host}` || selector === `npm:@brainervirus/workit-${host}@latest` ? "floating" : new RegExp(`^(?:npm:)?@brainervirus/workit-${host}@[^/]+$`).test(selector) ? "pinned" : "local"
+});
+var sources = (paths, run, hosts) => {
+  const { home, opencodeConfig, piSettings } = paths;
+  const result = [];
+  if (hosts.includes("opencode") && existsSync19(opencodeConfig + "c"))
+    throw new Error("OpenCode JSONC config is present; inspect effective native configuration before updating");
+  const oc = hosts.includes("opencode") ? object2(opencodeConfig) : null;
+  if (oc && [oc.plugins, oc.plugin].some((value) => value !== undefined && !Array.isArray(value)))
+    throw new Error("OpenCode plugin registrations must be arrays");
+  const plugins = [...oc?.plugins ?? [], ...oc?.plugin ?? []];
+  for (const pin of plugins)
+    if (typeof pin === "string" && isWorkitPlugin(pin))
+      result.push(classify("opencode", pin));
+  const cursor = hosts.includes("cursor") ? object2(path32.join(home, ".cursor/plugins/local/workit/package.json")) : null;
+  if (cursor?.name === "@brainervirus/workit-cursor") {
+    const mcp = object2(path32.join(home, ".cursor/mcp.json"));
+    const args = mcp?.mcpServers?.workit?.args ?? [];
+    const selector = args.find((arg) => typeof arg === "string" && arg.startsWith("--package="));
+    result.push(classify("cursor", typeof selector === "string" ? selector.slice(10) : "local"));
+  }
+  const pi = hosts.includes("pi") ? object2(piSettings) : null;
+  if (pi?.packages !== undefined && !Array.isArray(pi.packages))
+    throw new Error("Pi package registrations must be an array");
+  for (const entry of pi?.packages ?? []) {
+    const source = typeof entry === "string" ? entry : entry?.source;
+    if (typeof source !== "string")
+      continue;
+    const npm = /^(?:npm:)?@brainervirus\/workit-pi(?:@[^/]+)?$/.test(source);
+    const local = path32.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path32.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
+    if (npm || local)
+      result.push(classify("pi", source));
+  }
+  const listing = hosts.includes("codex") ? run("codex", ["plugin", "list", "--json"]) : { status: 1, stdout: "" };
+  if (hosts.includes("codex") && listing.status !== 0) {
+    let available = false;
+    try {
+      hostCommand("codex", [], { home, env: paths.env });
+      available = true;
+    } catch {}
+    if (available || existsSync19(paths.codexConfig))
+      throw new Error("Codex plugin inventory failed; inspect the native host before upgrading");
+  }
+  if (listing.status === 0) {
+    let installed;
+    try {
+      installed = JSON.parse(listing.stdout).installed ?? [];
+    } catch {
+      throw new Error("Codex plugin inventory could not be parsed");
+    }
+    if (!Array.isArray(installed))
+      throw new Error("Codex plugin inventory is malformed");
+    for (const plugin of installed) {
+      if (plugin.name !== "workit")
+        continue;
+      const source = plugin.source;
+      const npm = plugin.marketplaceName === "workflow-toolkit" && source?.source === "npm" && source?.package === "@brainervirus/workit-codex";
+      result.push({
+        ...classify("codex", npm ? `${source.package}${source.version ? `@${source.version}` : ""}` : "local"),
+        installedVersion: plugin.version
+      });
+    }
+  }
+  for (const source of result) {
+    if (source.host === "cursor")
+      source.installedVersion = cursor?.version;
+    if (source.host === "pi" && source.kind === "floating") {
+      const inventory = run("pi", ["list"]);
+      if (inventory.status === 0)
+        source.installedVersion = piInstalledVersion(inventory.stdout, source.selector);
+    }
+  }
+  return result;
+};
+var piInstalledVersion = (listing, selector) => {
+  const lines = listing.split(/\r?\n/).map((line) => line.trim());
+  const index = lines.indexOf(selector);
+  if (index < 0 || !lines[index + 1] || !path32.isAbsolute(lines[index + 1]))
+    return;
+  const pkg = object2(path32.join(lines[index + 1], "package.json"));
+  return pkg?.name === "@brainervirus/workit-pi" ? pkg.version : undefined;
+};
+var versionAtLeast = (installed, latest) => {
+  if (!/^\d+\.\d+\.\d+$/.test(installed))
+    return false;
+  const current = installed.split(".").map(Number);
+  const target = latest.split(".").map(Number);
+  for (let index = 0;index < 3; index++) {
+    if (current[index] !== target[index])
+      return current[index] > target[index];
+  }
+  return true;
+};
+function previewUpgrade(hosts = HOSTS2, deps = {}) {
+  const paths = upgradePaths(deps);
+  const { home, configDir } = paths;
+  const run = runner(deps);
+  const state = readSetupState(configDir);
+  const plan = {
+    ok: true,
+    blocked: [],
+    skipped: [],
+    entries: [],
+    configDigests: {},
+    migrations: []
+  };
+  for (const file of [state.config, state.workspaces, state.youtrack, state.vcs]) {
+    if (file.status === "malformed")
+      plan.blocked.push(file.error ?? file.file);
+    plan.configDigests[file.file] = digest2(file.file);
+  }
+  for (const file of [
+    paths.opencodeConfig,
+    paths.opencodeConfig + "c",
+    path32.join(home, ".cursor/settings.json"),
+    path32.join(home, ".cursor/mcp.json"),
+    path32.join(home, ".cursor/plugins/local/workit/package.json"),
+    paths.codexConfig,
+    paths.piSettings
+  ])
+    plan.configDigests[file] = digest2(file);
+  try {
+    const config = object2(state.config.file);
+    if (config && Object.hasOwn(config, "trustedPaths"))
+      plan.migrations.push({
+        id: "2.0-remove-ignored-trusted-paths",
+        file: state.config.file,
+        description: "Remove ignored Workit trustedPaths; native host permissions remain unchanged"
+      });
+    const installedSources = sources(paths, run, hosts);
+    for (const host of ["opencode", "pi"]) {
+      if (new Set(installedSources.filter((source) => source.host === host).map((source) => source.selector)).size > 1)
+        plan.blocked.push(`${host}: conflicting Workit registrations; reconcile them in the native host before upgrading`);
+    }
+    for (const source of installedSources.filter((source, index, list) => list.findIndex((entry) => entry.host === source.host && entry.selector === source.selector) === index)) {
+      if (source.kind !== "floating") {
+        plan.skipped.push({
+          host: source.host,
+          reason: `${source.kind} source preserved; change its source explicitly to upgrade`
+        });
+        continue;
+      }
+      if (source.host === "opencode") {
+        plan.skipped.push({
+          host: source.host,
+          reason: "OpenCode server plugin preserved: scoped native updates are unavailable in qualified 2.0.21; Workit never updates unrelated plugins"
+        });
+        continue;
+      }
+      const latest = run("npm", ["view", `@brainervirus/workit-${source.host}`, "version"]);
+      if (latest.status !== 0 || !/^\d+\.\d+\.\d+$/.test(latest.stdout.trim())) {
+        plan.blocked.push(`${source.host}: registry version unavailable; existing installation preserved`);
+        continue;
+      }
+      if (source.installedVersion && versionAtLeast(source.installedVersion, latest.stdout.trim())) {
+        plan.skipped.push({
+          host: source.host,
+          reason: `already current (${source.installedVersion})`
+        });
+        continue;
+      }
+      const commands = source.host === "pi" ? [{ command: "pi", args: ["update", "--extension", source.selector] }] : source.host === "codex" ? [{ command: "codex", args: ["plugin", "add", "workit@workflow-toolkit", "--json"] }] : planHostInstall("cursor", {
+        home,
+        env: deps.env,
+        cwd: home,
+        packageVersion: latest.stdout.trim(),
+        targetDir: path32.join(home, ".cursor/plugins/local/workit")
+      });
+      plan.entries.push({
+        host: source.host,
+        selector: source.selector,
+        latest: latest.stdout.trim(),
+        commands
+      });
+    }
+  } catch (error) {
+    plan.blocked.push(error instanceof Error ? error.message : "installed source could not be read");
+  }
+  plan.ok = plan.blocked.length === 0;
+  return plan;
+}
+function applyUpgrade(plan, deps = {}) {
+  if (!plan.ok)
+    return { ok: false, error: plan.blocked.join("; ") };
+  if (!plan.entries.length && !plan.migrations.length && !plan.cli)
+    return { ok: true };
+  for (const [file, expected] of Object.entries(plan.configDigests))
+    if (digest2(file) !== expected)
+      return { ok: false, error: `configuration changed; preview again: ${file}` };
+  const { home, env, configDir } = upgradePaths(deps);
+  const active = deps.activeHosts?.() ?? runningHosts(deps);
+  if (plan.entries.some((entry) => active.includes(entry.host)))
+    return {
+      ok: false,
+      error: "Stop the selected running hosts before upgrading their loaded plugins"
+    };
+  const backup = path32.join(home, ".local/state/workit/upgrades", new Date().toISOString().replaceAll(":", "-"));
+  mkdirSync9(backup, { recursive: true, mode: 448 });
+  for (const file of Object.keys(plan.configDigests))
+    if (existsSync19(file)) {
+      const target = path32.join(backup, createHash11("sha256").update(file).digest("hex").slice(0, 12) + "-" + path32.basename(file));
+      copyFileSync3(file, target);
+      chmodSync(target, 384);
+    }
+  for (const migration of plan.migrations) {
+    const value = object2(migration.file);
+    if (migration.id !== "2.0-remove-ignored-trusted-paths" || !value)
+      return {
+        ok: false,
+        backup,
+        error: "Unknown configuration migration; upgrade the CLI before applying"
+      };
+    delete value.trustedPaths;
+    writeFileAtomic(migration.file, JSON.stringify(value, null, 2) + `
+`, 384);
+  }
+  const run = runner(deps);
+  const cursorRoot = path32.join(home, ".cursor/plugins/local/workit");
+  if (plan.entries.some((entry) => entry.host === "cursor") && existsSync19(cursorRoot))
+    cpSync4(cursorRoot, path32.join(backup, "cursor-package"), { recursive: true });
+  for (const entry of plan.entries) {
+    if (entry.host === "opencode")
+      return {
+        ok: false,
+        backup,
+        error: "Scoped OpenCode server-plugin updates are unsupported; registration preserved"
+      };
+    if (entry.host === "cursor") {
+      const preview = {
+        ok: true,
+        blocked: [],
+        preserved: [],
+        overrides: [],
+        platforms: ["cursor"],
+        state: readSetupState(configDir),
+        mutations: [
+          {
+            type: "install-host",
+            platform: "cursor",
+            path: path32.join(home, ".cursor/plugins/local/.workit-package-bootstrap"),
+            commands: entry.commands.map((command) => ({
+              ...command,
+              purpose: command.purpose ?? "Upgrade Cursor"
+            }))
+          },
+          {
+            type: "install-adapter",
+            platform: "cursor",
+            path: path32.join(home, ".cursor/plugins/local/workit")
+          }
+        ]
+      };
+      const result = applySetupPreview(preview, {
+        home,
+        env,
+        cwd: home,
+        preferInstalledAdapter: true,
+        runHostCommand: (command) => {
+          const outcome = run(command.command, command.args);
+          return { exitCode: outcome.status ?? 1, stdout: outcome.stdout, stderr: "" };
+        }
+      });
+      const pkg = object2(path32.join(home, ".cursor/plugins/local/workit/package.json"));
+      if (!result.ok || pkg?.version !== entry.latest)
+        return {
+          ok: false,
+          backup,
+          error: "Cursor update did not verify the requested package version; inspect the installer before retrying"
+        };
+      continue;
+    }
+    for (const command of entry.commands)
+      if (run(command.command, command.args).status !== 0)
+        return {
+          ok: false,
+          backup,
+          error: `${entry.host}: update failed; inspect the native host before retrying`
+        };
+    const verify = entry.host === "codex" ? run("codex", ["plugin", "list", "--json"]) : run("pi", ["list"]);
+    if (verify.status !== 0)
+      return { ok: false, backup, error: `${entry.host}: update verification failed` };
+    if (entry.host === "codex") {
+      let installed = [];
+      try {
+        installed = JSON.parse(verify.stdout).installed ?? [];
+      } catch {}
+      if (!installed.some((plugin) => plugin.name === "workit" && plugin.marketplaceName === "workflow-toolkit" && plugin.version === entry.latest))
+        return { ok: false, backup, error: "Codex did not report the requested Workit version" };
+    }
+    if (entry.host === "pi" && piInstalledVersion(verify.stdout, entry.selector) !== entry.latest)
+      return { ok: false, backup, error: "Pi did not report the requested Workit package version" };
+  }
+  if (plan.cli) {
+    const currentRoot = run("npm", ["root", "--global"]);
+    if (currentRoot.status !== 0 || currentRoot.stdout.trim() !== plan.cli.root)
+      return { ok: false, backup, error: "Global npm location changed; preview again" };
+    const cliBackup = path32.join(backup, "cli-package");
+    cpSync4(path32.join(plan.cli.root, "@brainervirus/workit-cli"), cliBackup, { recursive: true });
+    if (run("npm", ["install", "--global", `@brainervirus/workit-cli@${plan.cli.latest}`]).status !== 0)
+      return {
+        ok: false,
+        backup,
+        error: `CLI update failed; preserved package at ${cliBackup}; use npm to repair or run node ${path32.join(cliBackup, "dist/index.js")}`
+      };
+    const installed = object2(path32.join(plan.cli.root, "@brainervirus/workit-cli/package.json"));
+    if (installed?.name !== "@brainervirus/workit-cli" || installed.version !== plan.cli.latest)
+      return {
+        ok: false,
+        backup,
+        error: `CLI update did not verify the requested version; preserved package at ${cliBackup}`
+      };
+  }
+  return { ok: true, backup };
+}
+async function runUpgradeCommand(argv, deps = {}) {
+  const out = deps.out ?? process.stdout;
+  const flags = new Set(argv);
+  const unknown = argv.filter((arg) => !["--apply", "--confirm", "--json", "--cli"].includes(arg) && !arg.startsWith("--hosts="));
+  const hostFlag = argv.find((arg) => arg.startsWith("--hosts="))?.slice(8);
+  const raw = hostFlag === "none" ? [] : hostFlag?.split(",") ?? HOSTS2;
+  if (unknown.length || raw.some((host) => !HOSTS2.includes(host))) {
+    out.write(`Usage: workit upgrade [--hosts=opencode,cursor,codex,pi|none] [--cli] [--apply --confirm] [--json]
+`);
+    return 2;
+  }
+  const plan = previewUpgrade(raw, deps);
+  if (flags.has("--cli")) {
+    const run = runner(deps);
+    const root = run("npm", ["root", "--global"]);
+    if (root.status !== 0 || !path32.isAbsolute(root.stdout.trim())) {
+      plan.blocked.push("Global npm location could not be verified");
+    } else {
+      const packageFile = path32.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
+      const pkg = object2(packageFile);
+      if (pkg?.name !== "@brainervirus/workit-cli" || lstatSync8(path32.dirname(packageFile)).isSymbolicLink()) {
+        plan.skipped.push({
+          host: "cli",
+          reason: "No managed global CLI install (local links preserved); use npx @brainervirus/workit-cli@latest"
+        });
+      } else {
+        const latest = run("npm", ["view", "@brainervirus/workit-cli", "version"]);
+        if (latest.status !== 0 || !/^\d+\.\d+\.\d+$/.test(latest.stdout.trim()))
+          plan.blocked.push("CLI registry version unavailable; existing installation preserved");
+        else if (!versionAtLeast(pkg.version, latest.stdout.trim())) {
+          plan.cli = { latest: latest.stdout.trim(), root: root.stdout.trim() };
+          plan.configDigests[packageFile] = digest2(packageFile);
+        } else
+          plan.skipped.push({ host: "cli", reason: `already current (${pkg.version})` });
+      }
+    }
+    plan.ok = plan.blocked.length === 0;
+  }
+  if (!flags.has("--apply")) {
+    out.write(JSON.stringify(plan, null, 2) + `
+`);
+    return plan.ok ? 0 : 1;
+  }
+  if (!flags.has("--confirm")) {
+    out.write(`Apply requires --confirm after reviewing the upgrade preview.
+`);
+    return 2;
+  }
+  const result = applyUpgrade(plan, deps);
+  out.write(JSON.stringify(result, null, 2) + `
+`);
+  return result.ok ? 0 : 1;
+}
+async function runLaunchCommand(argv, deps = {}) {
+  const [host, ...args] = argv;
+  if (!HOSTS2.includes(host)) {
+    (deps.out ?? process.stdout).write(`Usage: workit launch <opencode|cursor|codex|pi> [--auto-upgrade] [-- host arguments]
+`);
+    return 2;
+  }
+  const auto = args[0] === "--auto-upgrade";
+  const rest = auto ? args.slice(1) : args;
+  const hostArgs = rest[0] === "--" ? rest.slice(1) : rest;
+  const { home, env } = upgradePaths(deps);
+  let launch;
+  if (!deps.run) {
+    try {
+      launch = hostCommand(host, hostArgs, { home, env });
+    } catch (error) {
+      (deps.out ?? process.stderr).write(`${error instanceof Error ? error.message : "Host executable unavailable"}
+`);
+      return 1;
+    }
+  }
+  if (auto) {
+    const plan = previewUpgrade([host], deps);
+    if (plan.ok) {
+      for (const skipped of plan.skipped)
+        (deps.out ?? process.stderr).write(`${skipped.host}: ${skipped.reason}
+`);
+      const result = applyUpgrade(plan, deps);
+      if (!result.ok) {
+        (deps.out ?? process.stdout).write(`${result.error}
+`);
+        return 1;
+      }
+    } else if (plan.blocked.every((reason) => reason.includes("registry version unavailable"))) {
+      (deps.out ?? process.stderr).write(`Upgrade unavailable: ${plan.blocked.join("; ")}. Starting the unchanged host.
+`);
+    } else {
+      (deps.out ?? process.stderr).write(`Upgrade blocked: ${plan.blocked.join("; ")}
+`);
+      return 1;
+    }
+  }
+  if (deps.run)
+    return deps.run(host, hostArgs).status ?? 1;
+  return spawnSync11(launch.command, launch.args, {
+    stdio: "inherit",
+    env
+  }).status ?? 1;
+}
+var runningHosts = (deps) => {
+  const run = runner(deps);
+  const list = process.platform === "win32" ? run("tasklist", ["/fo", "csv", "/nh"]) : run("ps", ["-eo", "comm="]);
+  if (list.status !== 0)
+    return HOSTS2;
+  return HOSTS2.filter((host) => new RegExp(`(?:^|[\\/",\\s])${host}(?:\\.exe)?(?:[",\\s]|$)`, "im").test(list.stdout));
+};
+
 // packages/workit-cli/src/index.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
 var logger = createLogger({
@@ -69215,6 +71257,8 @@ var HELP = `workit — workflow rails for agentic coding
 
 Usage:
   workit init      Run the interactive setup wizard
+  workit upgrade   Preview upgrades (--apply --confirm; --hosts=a,b; --cli for the CLI)
+  workit launch <host> [--auto-upgrade] [-- args]  Upgrade before host startup
   workit doctor    Verify the offline installation health (add --json for a machine-readable report)
   workit uninstall Remove workit host registrations interactively (~/.config/workit is kept)
   workit cutover   Preview or apply an explicit v1 cutover (apply requires --confirm)
@@ -69223,7 +71267,7 @@ ${COMMAND_DESCRIPTIONS.map(([cmd, desc]) => `  ${cmd.padEnd(helpColumn)}${desc}`
   action payloads: ${externalActionHelp}
   workit           Show this help
 
-Run \`npx workit init\` to configure platforms, YouTrack, VCS and project hygiene.
+Run \`npx @brainervirus/workit-cli init\` to configure platforms, YouTrack, VCS and project hygiene.
 `;
 function printApplySummary(result) {
   for (const entry of result.entries) {
@@ -69437,7 +71481,11 @@ if (__require.main == __require.module) {
     logger.error(EVENT.uncaughtFailure, { phase: "uncaughtException", ...errorDetail(err) });
     process.exit(1);
   });
-  if (subcommand === "init") {
+  if (subcommand === "upgrade") {
+    process.exit(await runUpgradeCommand(args.slice(1)));
+  } else if (subcommand === "launch") {
+    process.exit(await runLaunchCommand(args.slice(1)));
+  } else if (subcommand === "init") {
     await runInit();
   } else if (subcommand === "doctor") {
     runDoctorCommand(args);