bosun 0.28.3 → 0.29.0

package/.env.example

@@ -303,6 +303,74 @@ TELEGRAM_MINIAPP_ENABLED=false
 # Optional free-form constraints/scoping notes
 # PROJECT_REQUIREMENTS_NOTES=
 
+# ─── Branch Strategy ──────────────────────────────────────────────────
+# How agents work on branches for each task:
+#
+#   worktree (default) — Each task gets an isolated ve/<id>-<slug> sub-branch
+#                         that PRs back into the module/base branch.
+#                         Best for: independent, high-parallelism work.
+#
+#   direct             — Agents push directly onto the module branch
+#                         (no ve/ sub-branch). All work is sequential on that
+#                         branch. Conflicts are resolved in real time.
+#                         Best for: fast iteration on a well-scoped module.
+#
+# TASK_BRANCH_MODE=worktree
+#
+# Auto-detect origin/<module> as base_branch from conventional commit task titles
+# e.g. "[m] feat(veid): add verification" → base_branch = origin/veid
+# TASK_BRANCH_AUTO_MODULE=true
+#
+# Prefix used when building module branch refs (default: origin/)
+# MODULE_BRANCH_PREFIX=origin/
+#
+# Default upstream target branch (main branch) for upstream sync and PRs
+# DEFAULT_TARGET_BRANCH=main
+#
+# Merge origin/main into module branches before each push (keeps branches in
+# sync with upstream continuously). Conflicts abort the merge and are resolved
+# by the next agent working on that branch. Default: true
+# TASK_UPSTREAM_SYNC_MAIN=true
+
+# ─── GitHub App (Bosun[botswain] Identity + Auth) ────────────────────────────
+# App: https://github.com/apps/bosun-botswain  (slug: bosun-botswain)
+# Bot identity: bosun-botswain[bot]  (appears as contributor on every agent commit)
+#
+# Numeric App ID (shown on the App settings page under "About"):
+# BOSUN_GITHUB_APP_ID=2911413
+#
+# OAuth Client ID (from App settings → Client ID):
+# BOSUN_GITHUB_CLIENT_ID=Iv23liZpVhGePGka9gcL
+#
+# OAuth Client Secret (only needed for callback-based OAuth, not for Device Flow):
+# BOSUN_GITHUB_CLIENT_SECRET=
+#
+# Webhook secret (set this in App settings → Webhook, and keep in sync):
+# BOSUN_GITHUB_WEBHOOK_SECRET=
+#
+# Path to the PEM private key downloaded from App settings → Generate a private key:
+# BOSUN_GITHUB_PRIVATE_KEY_PATH=/path/to/bosun-botswain.pem
+#
+# ─── Authentication Method ───────────────────────────────────────────────
+# RECOMMENDED: Device Flow (like VS Code / Roo Code — no public URL needed!)
+#   1. Set BOSUN_GITHUB_CLIENT_ID above
+#   2. Enable "Device Flow" in GitHub App settings (Settings → Optional features)
+#   3. Go to Settings → GitHub in the Bosun UI and click "Sign in with GitHub"
+#   4. That's it — no callback URL, no tunnel URL, no client secret needed
+#
+# ALTERNATIVE: OAuth Callback (requires a stable public URL)
+#   Set BOSUN_GITHUB_CLIENT_ID + BOSUN_GITHUB_CLIENT_SECRET
+#   Register callback URL in App settings:
+#     https://<your-bosun-public-url>/api/github/callback
+#
+# WEBHOOKS (optional — for real-time PR/issue sync):
+#   Register webhook URL in App settings:
+#     https://<your-bosun-public-url>/api/webhooks/github/app
+#   Webhooks require a stable public URL. Without them, Bosun polls instead.
+#
+# Leave BOSUN_GITHUB_APP_ID unset to disable co-author trailer injection.
+# BOSUN_GITHUB_APP_ID=
+
 # ─── Kanban Backend ──────────────────────────────────────────────────────────
 # Task-board backend:
 #   internal - local task-store source of truth (recommended primary)

package/agent-prompts.mjs

@@ -173,11 +173,12 @@ Return exactly one fenced json block with this shape:
 {
   "tasks": [
     {
-      "title": "[m] Example task title",
+      "title": "[m] feat(veid): example task title",
       "description": "Problem statement and scope",
       "implementation_steps": ["step 1", "step 2"],
       "acceptance_criteria": ["criterion 1", "criterion 2"],
-      "verification": ["test/check 1", "test/check 2"]
+      "verification": ["test/check 1", "test/check 2"],
+      "base_branch": "origin/veid"
     }
   ]
 }
@@ -187,6 +188,11 @@ Rules:
 - Provide at least the requested task count unless blocked by duplicate safeguards.
 - Keep titles unique and specific.
 - Keep file overlap low across tasks to maximize parallel execution.
+- **Module branch routing:** When the task title follows conventional commit format
+  \`feat(module):\` or \`fix(module):\`, set \`base_branch\` to \`origin/<module>\`.
+  This routes the task to the module's dedicated branch for parallel, isolated development.
+  Examples: \`feat(veid):\` → \`"base_branch": "origin/veid"\`, \`fix(market):\` → \`"base_branch": "origin/market"\`.
+  Omit \`base_branch\` for cross-cutting tasks that span multiple modules.
 `,
   monitorMonitor: `# Bosun-Monitor Agent
 
@@ -240,14 +246,14 @@ You are running as a **Bosun-managed task agent**.  Environment variables
 **After committing:**
 - If a precommit hook auto-applies additional formatting changes, add those
   to a follow-up commit before pushing.
-- Merge any upstream changes from the base branch before pushing:
-  \`git fetch origin && git merge origin/<base-branch> --no-edit\`
-  Resolve any conflicts that arise.
+- Merge any upstream changes — BOTH from the base (module) branch AND from main:
+  \`git fetch origin && git merge origin/<base-branch> --no-edit && git merge origin/main --no-edit\`
+  Resolve any conflicts that arise before pushing.
 - Push: \`git push --set-upstream origin {{BRANCH}}\`
 - After a successful push, open a Pull Request:
   \`gh pr create --title "{{TASK_TITLE}}" --body "Closes task {{TASK_ID}}"\`
 - **Do NOT** run \`gh pr merge\` — the orchestrator handles merges after CI.
-
+{{COAUTHOR_INSTRUCTION}}
 **Do NOT:**
 - Bypass pre-push hooks (\`git push --no-verify\` is forbidden).
 - Use \`git add .\` — stage files individually.

package/agent-work-analyzer.mjs

@@ -12,8 +12,8 @@
  * - Cost anomaly detection (unusually expensive sessions)
  */
 
-import { readFile, writeFile, appendFile, stat, watch } from "fs/promises";
-import { createReadStream, existsSync } from "fs";
+import { readFile, writeFile, appendFile, stat, watch, mkdir } from "fs/promises";
+import { createReadStream, existsSync, mkdirSync } from "fs";
 import { createInterface } from "readline";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
@@ -73,30 +73,54 @@ export async function startAnalyzer() {
 
   console.log("[agent-work-analyzer] Starting...");
 
-  // Ensure alerts log exists
-  if (!existsSync(ALERTS_LOG)) {
-    await writeFile(ALERTS_LOG, "");
+  // Ensure parent directory and alerts log exist
+  try {
+    const alertsDir = dirname(ALERTS_LOG);
+    if (!existsSync(alertsDir)) {
+      await mkdir(alertsDir, { recursive: true });
+    }
+    if (!existsSync(ALERTS_LOG)) {
+      await writeFile(ALERTS_LOG, "");
+    }
+  } catch (err) {
+    console.warn(`[agent-work-analyzer] Failed to init alerts log: ${err.message}`);
   }
 
   // Initial read of existing log
   if (existsSync(AGENT_WORK_STREAM)) {
     filePosition = await processLogFile(filePosition);
+  } else {
+    // Ensure the stream file exists so the watcher doesn't throw
+    try {
+      await writeFile(AGENT_WORK_STREAM, "");
+    } catch {
+      // May fail if another process creates it first — that's fine
+    }
   }
 
-  // Watch for changes
+  // Watch for changes — retry loop handles the case where the file
+  // is deleted and recreated (e.g. log rotation).
   console.log(`[agent-work-analyzer] Watching: ${AGENT_WORK_STREAM}`);
 
-  const watcher = watch(AGENT_WORK_STREAM, { persistent: true });
-
-  try {
-    for await (const event of watcher) {
-      if (event.eventType === "change") {
-        filePosition = await processLogFile(filePosition);
+  while (isRunning) {
+    try {
+      const watcher = watch(AGENT_WORK_STREAM, { persistent: true });
+      for await (const event of watcher) {
+        if (!isRunning) break;
+        if (event.eventType === "change") {
+          filePosition = await processLogFile(filePosition);
+        }
+      }
+    } catch (err) {
+      if (!isRunning) break;
+      if (err.code === "ENOENT") {
+        // File was deleted — wait a bit and retry
+        await new Promise((r) => setTimeout(r, 5000));
+        continue;
       }
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") {
       console.error(`[agent-work-analyzer] Watcher error: ${err.message}`);
+      // Wait before retrying to avoid busy-loop
+      await new Promise((r) => setTimeout(r, 10000));
     }
   }
 }

package/cli.mjs

@@ -979,7 +979,10 @@ async function main() {
           const logDir = monitorPath ? resolve(dirname(monitorPath), "logs") : resolve(__dirname, "logs");
           const daemonLog = existsSync(DAEMON_LOG) ? DAEMON_LOG : resolve(logDir, "daemon.log");
           const monitorLog = resolve(logDir, "monitor.log");
-          const logFile = existsSync(daemonLog) ? daemonLog : monitorLog;
+          // Prefer monitor.log — that's where the real activity goes.
+          // daemon.log only has the startup line; monitor.mjs intercepts
+          // all console output and writes to monitor.log.
+          const logFile = existsSync(monitorLog) ? monitorLog : daemonLog;
 
           if (existsSync(logFile)) {
             console.log(

package/codex-config.mjs

@@ -373,11 +373,18 @@ function normalizeWritableRoots(input, { repoRoot } = {}) {
     if (repo) {
       addRoot(repo);
       addRoot(resolve(repo, ".git"));
+      // Worktree checkout paths (used by task-executor)
+      addRoot(resolve(repo, ".cache", "worktrees"));
+      // Cache directories for agent work logs, build artifacts, etc.
+      addRoot(resolve(repo, ".cache"));
       const parent = dirname(repo);
       if (parent && parent !== repo) addRoot(parent);
     }
   }
 
+  // /tmp is needed for sandbox temp files, pip installs, etc.
+  addRoot("/tmp");
+
   return Array.from(roots);
 }
 

package/monitor.mjs

@@ -312,7 +312,10 @@ function startAgentWorkAnalyzer() {
   if (agentWorkAnalyzerActive) return;
   if (process.env.AGENT_WORK_ANALYZER_ENABLED === "false") return;
   try {
-    void startAnalyzer();
+    startAnalyzer().catch((err) => {
+      console.warn(`[monitor] agent-work analyzer async error: ${err.message}`);
+      agentWorkAnalyzerActive = false;
+    });
     agentWorkAnalyzerActive = true;
     console.log("[monitor] agent-work analyzer started");
   } catch (err) {
@@ -1531,8 +1534,9 @@ async function handleMonitorFailure(reason, err) {
 
     if (telegramToken && telegramChatId) {
       try {
+        const shortMsg = message.length > 200 ? message.slice(0, 200) + "…" : message;
         await sendTelegramMessage(
-          `⚠️ bosun exception (${reason}). Attempting recovery (count=${failureCount}).`,
+          `⚠️ bosun exception (${reason}): ${shortMsg}\n\nAttempting recovery (count=${failureCount}).`,
         );
       } catch {
         /* suppress Telegram errors during failure handling */
@@ -7551,6 +7555,27 @@ async function buildPlannerRuntimeContext(reason, details, numTasks) {
   };
 }
 
+/**
+ * Extract a conventional-commit scope from a task title and return the
+ * corresponding module branch ref (e.g. "origin/veid").
+ * Respects TASK_BRANCH_AUTO_MODULE env var (default: true) and
+ * MODULE_BRANCH_PREFIX (default: "origin/").
+ */
+function extractModuleBaseBranchFromTitle(title) {
+  const enabled = (process.env.TASK_BRANCH_AUTO_MODULE ?? "true") !== "false";
+  if (!enabled || !title) return null;
+  const match = String(title).match(
+    /(?:^\[[^\]]+\]\s*)?(?:feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)\(([^)]+)\)/i,
+  );
+  if (!match) return null;
+  const scope = match[1].toLowerCase().trim();
+  // Exclude generic scopes that don't map to real module branches
+  const generic = new Set(["deps", "app", "sdk", "cli", "api"]);
+  if (generic.has(scope)) return null;
+  const prefix = (process.env.MODULE_BRANCH_PREFIX || "origin/").replace(/\/*$/, "/");
+  return `${prefix}${scope}`;
+}
+
 function buildPlannerTaskDescription({
   plannerPrompt,
   reason,
@@ -7620,8 +7645,13 @@ function buildPlannerTaskDescription({
     "4. Prioritize reliability and unblockers first when errors/review backlog is elevated.",
     "5. Avoid duplicates with existing todo/inprogress/review tasks and open PRs.",
     "6. Prefer task sets that can run in parallel with minimal file overlap.",
-    "7. If a task should target a non-default epic/base branch, include `base_branch` in the JSON task object.",
-  ].join("\n");
+    "7. **Module branch routing (important):** When a task's title follows conventional commit format",
+    "   `feat(module):` or `fix(module):`, ALWAYS set `base_branch` to `origin/<module>` in the JSON.",
+    "   This enables parallel branch-per-module execution where all work for a module accumulates on",
+    "   its dedicated branch and integrates upstream changes continuously.",
+    "   Examples: `feat(veid):` → `origin/veid`, `fix(market):` → `origin/market`.",
+    "   Do NOT set base_branch for cross-cutting tasks that modify many modules.",
+    "8. If a task should target a non-default epic/base branch for other reasons, include `base_branch` in the JSON task object.",].join("\n");
 }
 
 function normalizePlannerTitleForComparison(title) {
@@ -7798,7 +7828,12 @@ async function materializePlannerTasksToKanban(projectId, tasks) {
       title: task.title,
       description: task.description,
       status: "todo",
-      ...(task.baseBranch ? { baseBranch: task.baseBranch } : {}),
+      // Honour explicit baseBranch from planner JSON, then fall back to
+      // module auto-detection via conventional commit scope in the title.
+      ...(() => {
+        const b = task.baseBranch || task.base_branch || extractModuleBaseBranchFromTitle(task.title);
+        return b ? { baseBranch: b } : {};
+      })(),
     });
     if (createdTask?.id) {
       created.push({ id: createdTask.id, title: task.title });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.28.3",
+  "version": "0.29.0",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/primary-agent.mjs

@@ -362,9 +362,13 @@ export async function execPrimaryPrompt(userMessage, options = {}) {
       );
 
       if (result) {
+        // Extract human-readable text from structured responses
+        const text = typeof result === "string"
+          ? result
+          : result.finalResponse || result.text || result.message || JSON.stringify(result);
         tracker.recordEvent(sessionId, {
           role: "assistant",
-          content: typeof result === "string" ? result : JSON.stringify(result),
+          content: text,
           timestamp: new Date().toISOString(),
           _sessionType: sessionType,
         });

package/setup.mjs

@@ -1627,7 +1627,13 @@ function buildDefaultWritableRoots(repoRoot) {
     if (parent && parent !== repo) roots.add(parent);
     roots.add(repo);
     roots.add(resolve(repo, ".git"));
+    // Worktree checkout paths (used by task-executor)
+    roots.add(resolve(repo, ".cache", "worktrees"));
+    // Cache directories for agent work logs, build artifacts, etc.
+    roots.add(resolve(repo, ".cache"));
   }
+  // /tmp needed for sandbox temp files, pip installs, etc.
+  roots.add("/tmp");
   return Array.from(roots).join(",");
 }
 

package/task-executor.mjs

@@ -113,6 +113,35 @@ const CODEX_TASK_LABELS = (() => {
 
 /** Watchdog interval: how often to check for stalled agent slots */
 const WATCHDOG_INTERVAL_MS = 60_000; // 1 minute
+
+/**
+ * Returns the Co-authored-by trailer for bosun-botswain[bot], or empty string
+ * if the GitHub App ID is not configured. Used to attribute agent commits to
+ * the Bosun GitHub App so the bot shows up as a contributor.
+ *
+ * To enable: set BOSUN_GITHUB_APP_ID=<your-app-id> in .env
+ * App noreply email format: <id>+bosun-botswain[bot]@users.noreply.github.com
+ */
+function getBosunCoAuthorLine() {
+  const appId = String(process.env.BOSUN_GITHUB_APP_ID || "").trim();
+  if (!appId) return "";
+  return `Co-authored-by: bosun-botswain[bot] <${appId}+bosun-botswain[bot]@users.noreply.github.com>`;
+}
+
+/**
+ * Returns a prompt instruction block telling the agent to append the Bosun
+ * co-author trailer to every commit. Empty string when app ID not configured.
+ */
+function getBosunCoAuthorInstruction() {
+  const line = getBosunCoAuthorLine();
+  if (!line) return "";
+  return `\n**Attribution (required — do not omit):**
+Every commit message MUST end with a blank line then this exact trailer:
+\`\`\`
+${line}
+\`\`\`
+`;
+}
 /** Grace period after task timeout before watchdog force-kills the slot */
 const WATCHDOG_GRACE_MS = 10 * 60_000; // 10 minutes — generous buffer, stream analysis handles real issues
 /** Max age for in-progress tasks to auto-resume after monitor restart */
@@ -212,11 +241,30 @@ function normalizeBranchName(value) {
 function extractScopeFromTitle(title) {
   if (!title) return null;
   const match = String(title).match(
-    /(?:^\[P\d+\]\s*)?(?:feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)\(([^)]+)\)/i,
+    /(?:^\[[^\]]+\]\s*)?(?:feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)\(([^)]+)\)/i,
   );
   return match ? match[1].toLowerCase().trim() : null;
 }
 
+/**
+ * If TASK_BRANCH_AUTO_MODULE=true (default), extract the conventional-commit
+ * scope from a task title and return the corresponding module branch ref.
+ *
+ * e.g. "[m] feat(veid): add verification" → "origin/veid"
+ *       "[s] fix(market): resolve bid race" → "origin/market"
+ */
+function resolveModuleAutoBaseBranch(title) {
+  const enabled = (process.env.TASK_BRANCH_AUTO_MODULE ?? "true") !== "false";
+  if (!enabled) return null;
+  const scope = extractScopeFromTitle(title);
+  if (!scope) return null;
+  // Exclude generic scopes that don't map to real module branches
+  const generic = new Set(["deps", "app", "sdk", "cli", "api"]);
+  if (generic.has(scope)) return null;
+  const prefix = (process.env.MODULE_BRANCH_PREFIX || "origin/").replace(/\/*$/, "/");
+  return `${prefix}${scope}`;
+}
+
 function collectTaskLabels(task) {
   const labels = [];
   if (!task) return labels;
@@ -350,6 +398,10 @@ function resolveTaskBaseBranch(task, branchRouting, defaultTargetBranch) {
   const fromConfig = resolveUpstreamFromConfig(task, branchRouting);
   if (fromConfig) return normalizeBranchName(fromConfig);
 
+  // Auto-detect module branch from conventional commit scope in title
+  const moduleAuto = resolveModuleAutoBaseBranch(task.title || task.name);
+  if (moduleAuto) return normalizeBranchName(moduleAuto);
+
   return normalizeBranchName(defaultTargetBranch);
 }
 
@@ -3285,12 +3337,25 @@ class TaskExecutor {
     const requestedBranch = String(
       options?.branch || options?.resumeBranch || "",
     ).trim();
+    // Resolve base branch first so direct-mode can reuse it for the working branch
+    const baseBranch = this._resolveTaskBaseBranch(task);
+    // Branch name strategy:
+    //   TASK_BRANCH_MODE=direct  → work directly on the module branch (no ve/ sub-branch),
+    //                              enabling sequential in-place work with real-time conflict
+    //                              resolution by the same team of agents.
+    //   TASK_BRANCH_MODE=worktree (default) → create an isolated ve/<id>-<slug> sub-branch
+    //                              that PRs back into the module/base branch.
+    const branchMode = (process.env.TASK_BRANCH_MODE || "worktree").trim().toLowerCase();
+    const directModeBranch =
+      branchMode === "direct" && baseBranch
+        ? normalizeBranchName(baseBranch)?.replace(/^origin\//, "") || null
+        : null;
     const branch =
       requestedBranch ||
       task.branchName ||
       task.meta?.branch_name ||
+      directModeBranch ||
       `ve/${taskId.substring(0, 8)}-${slugify(taskTitle)}`;
-    const baseBranch = this._resolveTaskBaseBranch(task);
     const taskRepoContext = this._resolveTaskRepoContext(task);
     const executionRepoRoot = taskRepoContext.repoRoot || this.repoRoot;
     const executionRepoSlug = taskRepoContext.repoSlug || this.repoSlug;
@@ -4124,6 +4189,7 @@ class TaskExecutor {
         REPO_ROOT: promptRepoRoot,
         TASK_WORKSPACE: promptWorkspace,
         TASK_REPOSITORY: promptRepository,
+        COAUTHOR_INSTRUCTION: getBosunCoAuthorInstruction(),
       },
       fallbackPrompt,
     );
@@ -4196,6 +4262,11 @@ class TaskExecutor {
       `3. Re-run tests to verify`,
       `4. Commit and push your fixes`,
       ``,
+      ...(getBosunCoAuthorLine() ? [
+        `Attribution: append this trailer after each commit message body (blank line before it):`,
+        getBosunCoAuthorLine(),
+        ``,
+      ] : []),
       `Original task description:`,
       task.description || "See task URL for details.",
     ].join("\n");
@@ -5101,6 +5172,58 @@ class TaskExecutor {
         /* best-effort upstream rebase */
       }
 
+      // Additionally sync with origin/main (or DEFAULT_TARGET_BRANCH) so that
+      // module branches continuously absorb upstream changes before each push.
+      // This surfaces conflicts early — if a merge conflict occurs, we abort the
+      // merge and push as-is; the NEXT agent working on this branch will encounter
+      // the conflict immediately and resolve it inline (no separate conflict-fix task).
+      try {
+        const mainBranch =
+          process.env.DEFAULT_TARGET_BRANCH ||
+          process.env.VK_TARGET_BRANCH?.replace(/^origin\//, "") ||
+          "main";
+        const syncEnabled =
+          (process.env.TASK_UPSTREAM_SYNC_MAIN ?? "true") !== "false";
+        // Only sync main when base branch is NOT already main itself
+        const isMainBase = baseInfo.branch === mainBranch || baseBranch === "main";
+        if (syncEnabled && !isMainBase) {
+          spawnSync("git", ["fetch", "origin", mainBranch, "--quiet"], {
+            cwd: worktreePath,
+            encoding: "utf8",
+            timeout: 30_000,
+          });
+          const mainMergeResult = spawnSync(
+            "git",
+            ["merge", `origin/${mainBranch}`, "--no-edit", "--no-ff", "-X", "ours"],
+            {
+              cwd: worktreePath,
+              encoding: "utf8",
+              timeout: 60_000,
+            },
+          );
+          if (mainMergeResult.status !== 0) {
+            // Conflicts or error — abort and continue with push as-is.
+            // The unresolved divergence will be visible to the next agent.
+            console.warn(
+              `${TAG} upstream main merge (origin/${mainBranch}) had conflicts on ` +
+              `${branch} — aborting merge, pushing branch as-is. ` +
+              `Next agent on this branch will resolve conflicts.`,
+            );
+            spawnSync("git", ["merge", "--abort"], {
+              cwd: worktreePath,
+              encoding: "utf8",
+              timeout: 10_000,
+            });
+          } else {
+            console.log(
+              `${TAG} synced ${branch} with origin/${mainBranch} before push.`,
+            );
+          }
+        }
+      } catch {
+        /* best-effort upstream main sync */
+      }
+
       const safety = evaluateBranchSafetyForPush(worktreePath, {
         baseBranch,
         remote: "origin",