@brimveyn/aimux 1.22.5 → 1.22.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.22.5",
+  "version": "1.22.7",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, Kimi side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",

package/src/app-runtime/side-effects.ts

@@ -1,7 +1,6 @@
 import { isAutoCommitEnabled } from '@brimveyn/aimux-config'
 
 import type { SideEffect } from '../input/modes/types'
-import type { AssistantId, PendingWorkspaceLaunch } from '../state/types'
 import type { SideEffectContext } from './side-effect-context'
 
 import { loadConfig, saveConfig } from '../config'
@@ -9,7 +8,6 @@ import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
 import { countDirtyFiles } from '../git/move-workspace'
 import { getCurrentBranch, getDefaultBranch, listLocalBranches } from '../git/worktree'
-import { assistantAcceptsPromptArg } from '../pty/command-registry'
 import { allLeafIds, getGroupIdForTab } from '../state/layout-tree'
 import { saveCurrentProject } from '../state/project-save'
 import { getActiveWorkspace, getActiveWorkspacePath } from '../state/project-workspaces'
@@ -39,7 +37,6 @@ import {
   handleSwitchProjectEffect,
   restartTabSession,
 } from './project-actions'
-import { injectPromptWhenReady } from './prompt-injection'
 import { getSelectedAssistantOption, getSelectedProject, getSelectedSnippet } from './selection'
 import {
   changeSelectedSetting,
@@ -48,7 +45,6 @@ import {
   resetSelectedSetting,
 } from './settings-actions'
 import {
-  findSetupTab,
   handleAskAgentForSetupScriptEffect,
   handleConfigureSetupScriptEffect,
   handlePromoteSetupTabEffect,
@@ -64,17 +60,16 @@ import {
   confirmSplitSelection,
   createTabSession,
   executeSplitPane,
-  launchAssistant,
+  launchWithPrompt,
   startExistingTab,
 } from './tab-actions'
 import {
-  createAimuxTempWorkspace,
   isForceableWorkspaceDeleteError,
   runDeleteWorkspace,
   runMoveWorkspace,
   setProjectDefaultBaseRef,
 } from './workspace-actions'
-import { placeholderWorkspaceName, renameWorkspaceFromPrompt } from './workspace-naming'
+import { launchPendingWorkspace, startWorkspaceCreation } from './workspace-launch'
 
 function handleProjectSelection(ctx: SideEffectContext): void {
   const { backend, dispatch, state } = ctx
@@ -214,79 +209,6 @@ function hoistBranch(branches: string[], first: string | undefined): string[] {
   return [first, ...branches.filter((branch) => branch !== first)]
 }
 
-/**
- * Setup runs concurrently with the agent by design, so say so rather than
- * letting the agent run tests against a half-installed tree and draw the wrong
- * conclusion. Only prefixed when a setup is actually live.
- */
-function buildWorkspacePrompt(ctx: SideEffectContext, pending: PendingWorkspaceLaunch): string {
-  const setupRunning = findSetupTab(ctx.getState().tabs, pending.workspaceId)?.status === 'running'
-  if (!setupRunning) return pending.prompt
-  return `Note: a setup script is currently installing this workspace's dependencies in the background. Wait for it to finish before running builds, tests, or anything that reads installed dependencies.\n\n${pending.prompt}`
-}
-
-/**
- * Name the workspace after what its prompt describes, using the assistant the
- * user just picked. Background work that must never block or fail the launch.
- *
- * Always `pending.prompt`, never the setup-annotated variant built for the
- * agent — the note is guidance, not part of what the user asked for.
- */
-function renameWorkspaceFromLaunch(
-  ctx: SideEffectContext,
-  pending: PendingWorkspaceLaunch,
-  assistant: AssistantId
-): void {
-  const workspace = ctx
-    .getState()
-    .projects.find((entry) => entry.id === pending.projectId)
-    ?.workspaces?.find((entry) => entry.id === pending.workspaceId)
-  if (!workspace) return
-
-  void renameWorkspaceFromPrompt(
-    { projectId: pending.projectId, prompt: pending.prompt, provider: assistant, workspace },
-    {
-      applyName: (projectId, workspaceId, patch) =>
-        ctx.dispatch({ patch, projectId, type: 'update-workspace-record', workspaceId }),
-    }
-  )
-}
-
-/**
- * The `<C-p>` flow: create a workspace in the current project, then chain into
- * the new-tab modal rather than leaving the user in an empty workspace.
- */
-async function createWorkspaceFromModal(
-  ctx: SideEffectContext,
-  projectId: string,
-  params: {
-    prompt: string
-    baseRef?: string
-  }
-): Promise<void> {
-  // A name derived locally from the prompt, so the sidebar reads right from the
-  // first frame. The model-generated one replaces it a few seconds later.
-  // The branch is left to `createAimuxTempWorkspace`, which suffixes it with a
-  // timestamp: two workspaces started from the same prompt must not collide on
-  // the branch name before the model has had a chance to distinguish them.
-  const workspace = await createAimuxTempWorkspace(
-    ctx,
-    projectId,
-    placeholderWorkspaceName(params.prompt),
-    undefined,
-    params.baseRef
-  )
-  // Undefined means the create was rejected (e.g. branch already checked out);
-  // the modal stays open showing the error.
-  if (!workspace) return
-
-  ctx.dispatch({ type: 'close-modal' })
-  ctx.dispatch({
-    pendingWorkspace: { projectId, prompt: params.prompt, workspaceId: workspace.id },
-    type: 'open-new-tab-modal',
-  })
-}
-
 export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): void {
   const { backend, dispatch, state } = ctx
 
@@ -313,47 +235,16 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
     }
     case 'launch-selected-assistant': {
       const assistant = getSelectedAssistantOption(state).id
-      // Chained from `<C-p>`: pin the tab to the workspace just created, hand it
-      // the prompt, and name the workspace with the assistant the user picked.
-      // Otherwise the tab lands in the project's active workspace, which
-      // launchAssistant resolves itself.
-      const pending = state.modal.type === 'new-tab' ? state.modal.pendingWorkspace : undefined
-      // Normalized to '' so "is there a prompt" is one comparison rather than a
-      // null check repeated at each decision below.
-      const prompt = pending
-        ? buildWorkspacePrompt(ctx, pending)
-        : ((state.modal.type === 'new-tab' ? state.modal.pendingPrompt : undefined) ?? '')
-
-      // Hand the prompt to the CLI at spawn where the CLI takes one. Pasting it
-      // into a live TUI works — it is what this flow did — but it means polling
-      // for readiness, probing the screen, and retrying. An argv slot has none of
-      // those failure modes.
-      const atSpawn = prompt !== '' && assistantAcceptsPromptArg(assistant, state.customCommands)
-      logInputDebug('app.launchSelectedAssistant', {
-        assistant,
-        chained: pending != null,
-        modal: state.modal.type,
-        promptAtSpawn: atSpawn,
-        promptLength: prompt.length,
-      })
-
-      const tabId = launchAssistant(
-        ctx,
-        assistant,
-        pending?.workspaceId,
-        atSpawn ? [prompt] : undefined
-      )
-      // Delivery is decided and done here, chained or not: two call sites meant
-      // the prompt could be built twice, from two different reads of the store.
-      if (prompt !== '' && !atSpawn) {
-        void injectPromptWhenReady({
-          backend: ctx.backend,
-          getState: ctx.getState,
-          prompt,
-          tabId,
-        })
+      const newTab = state.modal.type === 'new-tab' ? state.modal : undefined
+      // Chained from `<C-p>`: the tab is pinned to the workspace being cut, and
+      // waits for it. Otherwise it lands in the project's active workspace,
+      // which launchAssistant resolves itself.
+      if (newTab?.pendingWorkspace) {
+        launchPendingWorkspace(ctx, assistant, newTab.pendingWorkspace)
+        return
       }
-      if (pending) renameWorkspaceFromLaunch(ctx, pending, assistant)
+      // Normalized to '' so "is there a prompt" stays one comparison.
+      launchWithPrompt(ctx, assistant, newTab?.pendingPrompt ?? '', undefined)
       return
     }
     case 'edit-selected-assistant': {
@@ -389,18 +280,10 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       const projectId = state.currentProjectId
       if (!(projectId != null && projectId !== '')) return
       const { baseRef, prompt } = state.modal
-      void (async () => {
-        try {
-          await enqueueGitOp(async () =>
-            createWorkspaceFromModal(ctx, projectId, {
-              baseRef: baseRef !== '' ? baseRef : undefined,
-              prompt,
-            })
-          )
-        } catch (error) {
-          toast.error(error instanceof Error ? error.message : String(error))
-        }
-      })()
+      startWorkspaceCreation(ctx, projectId, {
+        baseRef: baseRef !== '' ? baseRef : undefined,
+        prompt,
+      })
       return
     }
     case 'confirm-selected-project': {

package/src/app-runtime/tab-actions.ts

@@ -4,6 +4,7 @@ import type { SideEffectContext } from './side-effect-context'
 import { logInputDebug } from '../debug/input-log'
 import { createPrefixedId } from '../platform/id'
 import {
+  assistantAcceptsPromptArg,
   getAllAssistantOptions,
   getAssistantOption,
   isCommandAvailable,
@@ -20,6 +21,7 @@ import {
 } from '../state/layout-tree'
 import { getActiveWorkspace, getCurrentProject } from '../state/project-workspaces'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
+import { injectPromptWhenReady } from './prompt-injection'
 import { getSelectedAssistantOption } from './selection'
 
 /**
@@ -171,6 +173,40 @@ export function launchAssistant(
   return tab.id
 }
 
+/**
+ * Spawn the assistant and get `prompt` in front of it.
+ *
+ * Handed over at spawn where the CLI takes one. Pasting it into a live TUI
+ * works — it is what the `<C-p>` flow did — but it means polling for readiness,
+ * probing the screen, and retrying. An argv slot has none of those failure
+ * modes. Deciding it here means the prompt cannot be built twice, from two
+ * different reads of the store.
+ */
+export function launchWithPrompt(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  prompt: string,
+  workspaceId: string | undefined
+): void {
+  const atSpawn = prompt !== '' && assistantAcceptsPromptArg(assistant, ctx.state.customCommands)
+  logInputDebug('app.launchSelectedAssistant', {
+    assistant,
+    chained: workspaceId != null,
+    promptAtSpawn: atSpawn,
+    promptLength: prompt.length,
+  })
+
+  const tabId = launchAssistant(ctx, assistant, workspaceId, atSpawn ? [prompt] : undefined)
+  if (prompt !== '' && !atSpawn) {
+    void injectPromptWhenReady({
+      backend: ctx.backend,
+      getState: ctx.getState,
+      prompt,
+      tabId,
+    })
+  }
+}
+
 export function getTabProjectPath(
   ctx: SideEffectContext,
   tab: Pick<TabSession, 'workspaceId'>

package/src/app-runtime/workspace-actions.ts

@@ -16,6 +16,7 @@ import {
   pruneGitWorktrees,
   removeGitWorktree,
 } from '../git/worktree'
+import { copyWorktreeFiles } from '../git/worktree-files'
 import { createPrefixedId } from '../platform/id'
 import {
   assertSafeAimuxWorktreePath,
@@ -23,7 +24,7 @@ import {
   makeWorktreePath,
   sanitizePathSegment,
 } from '../platform/worktree-paths'
-import { shouldRefreshBase } from '../settings/flags'
+import { shouldRefreshBase, worktreeCopyPatterns } from '../settings/flags'
 import { saveProjectCatalog } from '../state/project-catalog'
 import { pruneSnapshotOfWorkspace } from '../state/project-persistence'
 import { getActiveWorkspace, getActiveWorkspacePath } from '../state/project-workspaces'
@@ -93,14 +94,27 @@ function normalizeBranchName(branch: string | undefined): string | undefined {
 export async function createAimuxTempWorkspace(
   ctx: SideEffectContext,
   projectId: string,
-  requestedName?: string,
-  requestedBranchName?: string,
-  requestedBaseRef?: string,
-  sourceWorkspaceId?: string
+  options: {
+    name?: string
+    branchName?: string
+    baseRef?: string
+    sourceWorkspaceId?: string
+    /**
+     * Pre-allocated by callers that must name the workspace before git is done
+     * cutting it — the `<C-p>` chain pins a tab to it while it is still being
+     * created.
+     */
+    workspaceId?: string
+  } = {}
 ): Promise<WorkspaceRecord | undefined> {
+  const {
+    baseRef: requestedBaseRef,
+    branchName: requestedBranchName,
+    name: requestedName,
+  } = options
   const project = ctx.state.projects.find((entry) => entry.id === projectId)
   const source =
-    project?.workspaces?.find((entry) => entry.id === sourceWorkspaceId) ??
+    project?.workspaces?.find((entry) => entry.id === options.sourceWorkspaceId) ??
     getActiveWorkspace(project)
   const sourcePath = source?.path ?? getActiveWorkspacePath(project)
   if (!project || !(sourcePath != null && sourcePath !== '')) return undefined
@@ -110,7 +124,7 @@ export async function createAimuxTempWorkspace(
   const repoRoot = (await getMainWorktreeRoot(sourcePath)) ?? source?.repoRoot ?? sourcePath
   const baseBranch = (await getCurrentBranch(sourcePath)) ?? source?.branch ?? 'HEAD'
   const baseRef = requestedBaseRef ?? baseBranch
-  const workspaceId = createPrefixedId('workspace')
+  const workspaceId = options.workspaceId ?? createPrefixedId('workspace')
   const trimmedName = requestedName?.trim()
   const workspaceName =
     trimmedName != null && trimmedName !== ''
@@ -120,7 +134,11 @@ export async function createAimuxTempWorkspace(
   const branchName =
     trimmedBranch != null && trimmedBranch !== ''
       ? trimmedBranch
-      : `aimux/${sanitizePathSegment(workspaceName, 40)}-${Date.now().toString(36)}`
+      : // Placeholder only: the model replaces it with a conventional
+        // `<type>/<subject>` branch seconds later. Kept in the `aimux/`
+        // namespace and lowercased so what survives a failed generation still
+        // reads as a throwaway branch rather than a shouted prompt.
+        `aimux/${sanitizePathSegment(workspaceName, 40).toLowerCase()}-${Date.now().toString(36)}`
   const targetPath = makeWorktreePath({ repoRoot, workspaceId, workspaceName })
 
   const existingWorkspace = (await listGitWorktrees(repoRoot)).find(
@@ -147,6 +165,7 @@ export async function createAimuxTempWorkspace(
     repoPath: repoRoot,
     targetPath,
   })
+  await copyWorktreeFiles(repoRoot, targetPath, worktreeCopyPatterns())
   const now = new Date().toISOString()
 
   const workspace: WorkspaceRecord = {
@@ -209,12 +228,15 @@ export async function runDeleteWorkspace(
 
   const repoPath = resolveWorkspaceGitDir(project, workspace)
   const isAimuxTemp = workspace.source === 'aimux-temp' && workspace.createdByAimux
-  // Drop the throwaway aimux branch alongside the workspace so deleted temp
-  // workspaces don't accumulate in the repo or haunt the base picker. Scoped to
-  // the `aimux/` namespace (matches the picker filter); best-effort.
+  // Drop the throwaway branch alongside the workspace so deleted temp
+  // workspaces don't accumulate in the repo. Scoped by the record rather than by
+  // a name prefix: auto-naming renames the branch to a conventional
+  // `<type>/<subject>`, indistinguishable from a hand-made one, and
+  // `aimux-temp` + `createdByAimux` is exactly "aimux created this branch".
+  // Best-effort; git refuses while another worktree still has it checked out.
   const cleanupAimuxBranch = async (): Promise<void> => {
     const branch = workspace.branch
-    if (isAimuxTemp && branch != null && branch !== '' && branch.startsWith('aimux/')) {
+    if (isAimuxTemp && branch != null && branch !== '') {
       await deleteGitBranch(repoPath, branch)
     }
   }

package/src/app-runtime/workspace-launch.ts

@@ -0,0 +1,135 @@
+import type { AssistantId, PendingWorkspaceLaunch, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { enqueueGitOp } from '../git/command-queue'
+import { createPrefixedId } from '../platform/id'
+import { hasSetupScript } from '../state/project-data'
+import { findWorkspace } from '../state/project-workspaces'
+import { toast } from '../state/toast-store'
+import { findSetupTab } from './setup-actions'
+import { launchWithPrompt } from './tab-actions'
+import { createAimuxTempWorkspace } from './workspace-actions'
+import { placeholderWorkspaceName, renameWorkspaceFromPrompt } from './workspace-naming'
+
+/**
+ * The `<C-p>` worktree being cut while its assistant picker is already open.
+ * A barrier, not a value: what the launch needs to know — did the worktree
+ * land — is read back from the store, which is the only thing that can still
+ * be true a tick later.
+ *
+ * Single-slot: only one create-workspace modal can be open, so only one chain
+ * can ever be in flight.
+ */
+let pendingWorkspaceCreate: Promise<void> | null = null
+
+/**
+ * The `<C-p>` flow: chain into the new-tab modal *now* and cut the worktree in
+ * the background. `git fetch` + `worktree add` take seconds, and the next
+ * question — which assistant — does not depend on either, so making the user
+ * watch a frozen modal buys nothing. `launchPendingWorkspace` waits this out,
+ * so the tab still lands in a finished workspace.
+ */
+export function startWorkspaceCreation(
+  ctx: SideEffectContext,
+  projectId: string,
+  params: {
+    prompt: string
+    baseRef?: string
+  }
+): void {
+  // Allocated here rather than by the create: the picker below pins its tab to
+  // this workspace before git has produced anything to pin to.
+  const workspaceId = createPrefixedId('workspace')
+  pendingWorkspaceCreate = (async () => {
+    try {
+      await enqueueGitOp(async () =>
+        // A name derived locally from the prompt, so the sidebar reads right from
+        // the first frame. The model-generated one replaces it a few seconds later.
+        // The branch is left to `createAimuxTempWorkspace`, which suffixes it with
+        // a timestamp: two workspaces started from the same prompt must not
+        // collide on the branch name before the model has distinguished them.
+        createAimuxTempWorkspace(ctx, projectId, {
+          baseRef: params.baseRef,
+          name: placeholderWorkspaceName(params.prompt),
+          workspaceId,
+        })
+      )
+    } catch (error) {
+      // The modal that would have shown this inline is already gone, so the
+      // toast is the only channel left. The launch reads the missing record.
+      toast.error(error instanceof Error ? error.message : String(error))
+    }
+  })()
+  ctx.dispatch({ type: 'close-modal' })
+  ctx.dispatch({
+    pendingWorkspace: { projectId, prompt: params.prompt, workspaceId },
+    type: 'open-new-tab-modal',
+  })
+}
+
+/**
+ * Setup runs concurrently with the agent by design, so say so rather than
+ * letting the agent run tests against a half-installed tree and draw the wrong
+ * conclusion. Only prefixed when a setup is actually live.
+ */
+function buildWorkspacePrompt(ctx: SideEffectContext, pending: PendingWorkspaceLaunch): string {
+  const setupTab = findSetupTab(ctx.getState().tabs, pending.workspaceId)
+  // No setup tab yet does not mean no setup: the workspace can land in the
+  // store the same tick the user picks, and the runner only spawns on the next
+  // render. A project with a script is about to run it, so say so.
+  const setupRunning = setupTab ? setupTab.status === 'running' : hasSetupScript(pending.projectId)
+  if (!setupRunning) return pending.prompt
+  return `Note: a setup script is currently installing this workspace's dependencies in the background. Wait for it to finish before running builds, tests, or anything that reads installed dependencies.\n\n${pending.prompt}`
+}
+
+/**
+ * Name the workspace after what its prompt describes, using the assistant the
+ * user just picked. Background work that must never block or fail the launch.
+ *
+ * Always `pending.prompt`, never the setup-annotated variant built for the
+ * agent — the note is guidance, not part of what the user asked for.
+ */
+function renameWorkspaceFromLaunch(
+  ctx: SideEffectContext,
+  pending: PendingWorkspaceLaunch,
+  workspace: WorkspaceRecord,
+  assistant: AssistantId
+): void {
+  void renameWorkspaceFromPrompt(
+    { projectId: pending.projectId, prompt: pending.prompt, provider: assistant, workspace },
+    {
+      applyName: (projectId, workspaceId, patch) =>
+        ctx.dispatch({ patch, projectId, type: 'update-workspace-record', workspaceId }),
+    }
+  )
+}
+
+/**
+ * Pin the tab to the workspace `<C-p>` is cutting, hand it the prompt, and name
+ * the workspace after what it describes.
+ *
+ * Waits for the worktree first: spawning early would drop the tab in the
+ * project checkout instead, since that is what an unresolvable workspace id
+ * falls back to.
+ */
+export function launchPendingWorkspace(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  pending: PendingWorkspaceLaunch
+): void {
+  const creating = pendingWorkspaceCreate
+  pendingWorkspaceCreate = null
+  void (async () => {
+    await creating
+    // Read the store again: the record landed after `ctx.state` was captured,
+    // and its absence is how a failed create says "do not spawn".
+    const fresh = { ...ctx, state: ctx.getState() }
+    const found = findWorkspace(fresh.state.projects, pending.workspaceId)
+    if (!found) {
+      toast.error('Workspace creation failed — no tab was opened')
+      return
+    }
+    launchWithPrompt(fresh, assistant, buildWorkspacePrompt(fresh, pending), pending.workspaceId)
+    renameWorkspaceFromLaunch(fresh, pending, found.workspace, assistant)
+  })()
+}

package/src/app-runtime/workspace-naming.ts

@@ -5,24 +5,22 @@
 // the generated one replaces it in place when it arrives. The heuristic result
 // is not a stopgap to be embarrassed about — when no headless CLI is installed
 // it is the final name, and it is still derived from what the user asked for.
+//
+// The branch is not a slug of that name. A tab title belongs to the user and
+// speaks their language; a branch name is read by git, by reviewers and by CI,
+// so the model is asked for it separately, in English and under a
+// conventional-commit type. A branch is only renamed when the model returns one
+// in that shape — the placeholder is a better outcome than a bad convention.
 
 import type { AssistantId, WorkspaceRecord } from '../state/types'
 
 import { heuristicTitle } from '../auto-rename/heuristic-title'
-import { generateTabTitle, type TitleSpawnFn } from '../auto-rename/title-runner'
+import { generateWorkspaceNaming, type TitleSpawnFn } from '../auto-rename/title-runner'
 import { renameGitBranch } from '../git/worktree'
-import { sanitizePathSegment } from '../platform/worktree-paths'
 
 /** Model naming is best-effort background work; it must never outlive the app. */
 const NAMING_TIMEOUT_MS = 30_000
 
-export const BRANCH_PREFIX = 'aimux/'
-const BRANCH_SLUG_MAX = 40
-
-export function branchNameFor(name: string): string {
-  return `${BRANCH_PREFIX}${sanitizePathSegment(name, BRANCH_SLUG_MAX).toLowerCase()}`
-}
-
 /**
  * The name a workspace carries until the model answers. Undefined when the
  * prompt yields nothing usable, which lets `createAimuxTempWorkspace` fall back
@@ -60,7 +58,7 @@ export async function renameWorkspaceFromPrompt(
   target: WorkspaceNamingTarget,
   deps: WorkspaceNamingDeps
 ): Promise<void> {
-  const result = await generateTabTitle({
+  const result = await generateWorkspaceNaming({
     firstPrompt: target.prompt,
     provider: target.provider,
     signal: deps.signal ?? new AbortController().signal,
@@ -70,21 +68,24 @@ export async function renameWorkspaceFromPrompt(
   if (result.status !== 'ok') return
 
   const { workspace } = target
-  if (result.title === workspace.name) return
-
-  const branch = branchNameFor(result.title)
+  const { branch } = result
   const rename = deps.renameBranch ?? renameGitBranch
   // Renamed from inside the workspace, not the main checkout: the branch is
   // that worktree's current branch, which is the form git always accepts.
   // Renaming first means a refusal (the name is taken) leaves the record
   // pointing at the branch that actually exists.
-  const branchRenamed =
-    workspace.branch != null && workspace.branch !== '' && branch !== workspace.branch
-      ? await rename(workspace.path, workspace.branch, branch)
-      : false
+  const renamedBranch =
+    branch != null &&
+    workspace.branch != null &&
+    workspace.branch !== '' &&
+    branch !== workspace.branch &&
+    (await rename(workspace.path, workspace.branch, branch))
+      ? branch
+      : undefined
 
+  if (result.title === workspace.name && renamedBranch == null) return
   deps.applyName(target.projectId, workspace.id, {
     name: result.title,
-    ...(branchRenamed ? { branch } : null),
+    ...(renamedBranch == null ? null : { branch: renamedBranch }),
   })
 }

package/src/app.tsx

@@ -82,12 +82,18 @@ export function App({
   resolvedConfig: ResolvedConfig
   userConfig: AimuxUserConfig
 }) {
-  // Publish the auto-commit enabled flag before any children render so
-  // actions (which live outside React) can read it synchronously.
-  setAutoCommitEnabled(resolvedConfig.autoCommit.enabled)
-  setMultiRepoConfig(resolvedConfig.multiRepo)
-  setExternalEditorConfig(resolvedConfig.externalEditor)
-  setStatusBarSeparator(resolvedConfig.statusBar?.separator)
+  // Publish the config-file baseline into the runtime singletons before any
+  // children render, so actions (which live outside React) can read them
+  // synchronously. Lazy initializer, not the render body: this component
+  // re-renders on every dispatch, and re-running these would overwrite what the
+  // settings screen has since applied on top of the baseline (`hydrateSettings`).
+  useState(() => {
+    setAutoCommitEnabled(resolvedConfig.autoCommit.enabled)
+    setMultiRepoConfig(resolvedConfig.multiRepo)
+    setExternalEditorConfig(resolvedConfig.externalEditor)
+    setStatusBarSeparator(resolvedConfig.statusBar?.separator)
+    return null
+  })
 
   const keymapHandlers = useMemo(
     () => {