@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -0,0 +1,366 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+import type { AppState, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { moveWorkspace } from '../git/move-workspace'
+import {
+  createGitWorktree,
+  deleteGitBranch,
+  getCurrentBranch,
+  getHeadSha,
+  getMainWorktreeRoot,
+  listGitWorktrees,
+  pruneGitWorktrees,
+  removeGitWorktree,
+} from '../git/worktree'
+import { createPrefixedId } from '../platform/id'
+import {
+  assertSafeAimuxWorktreePath,
+  isInsideAimuxWorktreeRoot,
+  makeWorktreePath,
+  sanitizePathSegment,
+} from '../platform/worktree-paths'
+import { saveProjectCatalog } from '../state/project-catalog'
+import { pruneSnapshotOfWorkspace } from '../state/project-persistence'
+import { getActiveWorkspace, getActiveWorkspacePath } from '../state/project-workspaces'
+import { toast } from '../state/toast-store'
+
+/**
+ * Rewrite one project and hand back the whole list, ready for `set-projects`.
+ *
+ * Reads the *live* store rather than `ctx.state`: callers reach here after
+ * seconds of git work, and `ctx.state` is the render snapshot from before it.
+ * Since `set-projects` replaces the array wholesale, a stale read does not just
+ * miss an update — it reverts it. Workspace naming lands asynchronously, so
+ * that window is wide open.
+ */
+export function replaceProject(
+  ctx: SideEffectContext,
+  projectId: string,
+  next: (project: AppState['projects'][number]) => AppState['projects'][number]
+): AppState['projects'] {
+  return ctx
+    .getState()
+    .projects.map((project) => (project.id === projectId ? next(project) : project))
+}
+
+export function handleSwitchWorkspace(
+  ctx: SideEffectContext,
+  projectId: string,
+  workspaceId: string
+): void {
+  const project = ctx.state.projects.find((entry) => entry.id === projectId)
+  const workspace = project?.workspaces?.find((entry) => entry.id === workspaceId)
+  if (!project || !workspace) return
+  const projects = replaceProject(ctx, projectId, (entry) => ({
+    ...entry,
+    activeWorkspaceId: workspaceId,
+    updatedAt: new Date().toISOString(),
+  }))
+  saveProjectCatalog(projects)
+  ctx.dispatch({ projects, type: 'set-projects' })
+}
+
+function normalizeBranchName(branch: string | undefined): string | undefined {
+  return branch?.replace(/^refs\/heads\//, '').trim()
+}
+
+export async function createAimuxTempWorkspace(
+  ctx: SideEffectContext,
+  projectId: string,
+  requestedName?: string,
+  requestedBranchName?: string,
+  requestedBaseRef?: string,
+  sourceWorkspaceId?: string
+): Promise<WorkspaceRecord | undefined> {
+  const project = ctx.state.projects.find((entry) => entry.id === projectId)
+  const source =
+    project?.workspaces?.find((entry) => entry.id === sourceWorkspaceId) ??
+    getActiveWorkspace(project)
+  const sourcePath = source?.path ?? getActiveWorkspacePath(project)
+  if (!project || !(sourcePath != null && sourcePath !== '')) return undefined
+
+  // Resolve the *main* repo checkout, never the active linked workspace, so the
+  // record's repoRoot stays valid after sibling workspaces are deleted.
+  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 trimmedName = requestedName?.trim()
+  const workspaceName =
+    trimmedName != null && trimmedName !== ''
+      ? trimmedName
+      : `wt-${sanitizePathSegment(project.name, 12)}`
+  const trimmedBranch = requestedBranchName?.trim()
+  const branchName =
+    trimmedBranch != null && trimmedBranch !== ''
+      ? trimmedBranch
+      : `aimux/${sanitizePathSegment(workspaceName, 40)}-${Date.now().toString(36)}`
+  const targetPath = makeWorktreePath({ repoRoot, workspaceId, workspaceName })
+
+  const existingWorkspace = (await listGitWorktrees(repoRoot)).find(
+    (entry) =>
+      entry.prunable !== true &&
+      normalizeBranchName(entry.branch) === normalizeBranchName(branchName)
+  )
+  if (existingWorkspace) {
+    ctx.dispatch({
+      message: `Branch already checked out in another workspace: ${existingWorkspace.path}`,
+      type: 'set-create-workspace-branch-error',
+    })
+    return undefined
+  }
+
+  await mkdir(dirname(targetPath), { recursive: true })
+  await assertSafeAimuxWorktreePath(targetPath)
+  await createGitWorktree({ baseRef, branchName, repoPath: repoRoot, targetPath })
+  const now = new Date().toISOString()
+
+  const workspace: WorkspaceRecord = {
+    baseRef,
+    branch: branchName,
+    commitSha: await getHeadSha(targetPath),
+    createdAt: now,
+    createdByAimux: true,
+    id: workspaceId,
+    name: workspaceName,
+    path: targetPath,
+    repoRoot,
+    source: 'aimux-temp',
+    updatedAt: now,
+  }
+  const projects = replaceProject(ctx, projectId, (entry) => ({
+    ...entry,
+    activeWorkspaceId: workspace.id,
+    updatedAt: now,
+    workspaces: [...(entry.workspaces ?? []), workspace],
+  }))
+  saveProjectCatalog(projects)
+  ctx.dispatch({ projects, type: 'set-projects' })
+  toast.success(`Created workspace ${branchName}`)
+  return workspace
+}
+
+// Dispose and close every tab pinned to a workspace (timers, pty project, state).
+function disposeWorkspaceTabs(ctx: SideEffectContext, workspaceId: string): void {
+  for (const tab of ctx.state.tabs.filter((entry) => entry.workspaceId === workspaceId)) {
+    ctx.clearIdleTimer(tab.id)
+    ctx.clearStartupGrace(tab.id)
+    ctx.backend.disposeSession(tab.id)
+    ctx.dispatch({ tabId: tab.id, type: 'close-tab' })
+  }
+}
+
+export async function runDeleteWorkspace(
+  ctx: SideEffectContext,
+  projectId: string,
+  workspaceId: string,
+  force: boolean,
+  closeTabs = false
+): Promise<void> {
+  const project = ctx.state.projects.find((entry) => entry.id === projectId)
+  const workspace = project?.workspaces?.find((entry) => entry.id === workspaceId)
+  if (!project) throw new Error('project not found')
+  if (!workspace) throw new Error('workspace not found')
+  if ((project.workspaces?.length ?? 0) <= 1) throw new Error('at least one workspace must remain')
+  if (workspace.source === 'primary') throw new Error('root workspace cannot be deleted')
+
+  const tabsInWorkspace = ctx.state.tabs.filter((tab) => tab.workspaceId === workspaceId)
+  // The active-tabs guard asks the modal user to confirm before closing tabs.
+  // `closeTabs` (the sidebar's "Remove workspace") opts into closing them
+  // directly without forcing the git removal, so dirty temp workspaces are still
+  // protected by the non-force `git worktree remove`.
+  if (tabsInWorkspace.length > 0 && !force && !closeTabs) {
+    throw new ActiveWorkspaceTabsError(tabsInWorkspace.length)
+  }
+
+  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.
+  const cleanupAimuxBranch = async (): Promise<void> => {
+    const branch = workspace.branch
+    if (isAimuxTemp && branch != null && branch !== '' && branch.startsWith('aimux/')) {
+      await deleteGitBranch(repoPath, branch)
+    }
+  }
+
+  // Run git ops FIRST. If any throws (dirty workspace, etc.) the catch in the
+  // delete-workspace side effect handler re-prompts force or toasts the error —
+  // tabs stay open and the row stays in the sidebar, so the UI matches reality
+  // instead of leaving tabs closed against a workspace that still exists.
+  if (isAimuxTemp && isInsideAimuxWorktreeRoot(workspace.path) && !existsSync(workspace.path)) {
+    // The dir vanished but git may still pin the branch to a stale workspace entry.
+    await pruneGitWorktrees(repoPath)
+  } else if (isAimuxTemp && isInsideAimuxWorktreeRoot(workspace.path)) {
+    await assertSafeAimuxWorktreePath(workspace.path)
+    await removeGitWorktree({ force, repoPath, targetPath: workspace.path })
+  } else if (workspace.source === 'aimux-temp' || workspace.createdByAimux) {
+    throw new Error(`refusing unsafe workspace delete: ${workspace.path}`)
+  }
+
+  await cleanupAimuxBranch()
+
+  // Only after git success: close tabs + retire the record. Re-read state so
+  // we don't operate on the snapshot captured before the awaits above.
+  disposeWorkspaceTabs({ ...ctx, state: ctx.getState() }, workspaceId)
+  const latest = ctx.getState()
+  const latestProject = latest.projects.find((entry) => entry.id === projectId)
+  if (latestProject) {
+    removeWorkspaceRecordFromProject(
+      { ...ctx, state: latest },
+      projectId,
+      latestProject,
+      workspaceId
+    )
+  }
+}
+
+// A workspace's stored repoRoot can point at a sibling workspace that was since
+// deleted. Git commands only need *some* existing workspace of the repo (they
+// share the common git dir), so fall back to the main checkout or any live
+// workspace path rather than letting `git -C` fail on a vanished directory.
+function resolveWorkspaceGitDir(
+  project: NonNullable<SideEffectContext['state']['projects'][number]>,
+  workspace: WorkspaceRecord
+): string {
+  const candidates = [
+    project.workspaces?.find((entry) => entry.source === 'primary')?.path,
+    workspace.repoRoot,
+    ...(project.workspaces ?? [])
+      .filter((entry) => entry.id !== workspace.id)
+      .map((entry) => entry.path),
+  ]
+  return candidates.find((path) => path !== undefined && existsSync(path)) ?? workspace.repoRoot
+}
+
+export async function runMoveWorkspace(
+  ctx: SideEffectContext,
+  projectId: string,
+  sourceWorkspaceId: string,
+  targetWorkspaceId: string,
+  deleteSource: boolean,
+  stashTarget: boolean,
+  keepConflicts: boolean
+): Promise<void> {
+  const project = ctx.state.projects.find((entry) => entry.id === projectId)
+  const source = project?.workspaces?.find((entry) => entry.id === sourceWorkspaceId)
+  const target = project?.workspaces?.find((entry) => entry.id === targetWorkspaceId)
+  if (!project) throw new Error('project not found')
+  if (!source || !target) throw new Error('workspace not found')
+  if (source.id === target.id) throw new Error('source and target are the same workspace')
+  if (source.branch == null || source.branch === '') {
+    throw new Error('source workspace has no branch to move')
+  }
+  if (deleteSource && source.source === 'primary') {
+    throw new Error('the primary workspace cannot be deleted')
+  }
+
+  const sourceLabel = source.branch ?? source.name
+  const targetLabel = target.branch ?? target.name
+  const result = await moveWorkspace({
+    keepConflicts,
+    sourceBranch: source.branch,
+    sourcePath: source.path,
+    stashTarget,
+    targetPath: target.path,
+  })
+
+  // Recoverable failures open a confirm dialog carrying retry params; both
+  // workspaces are already back in their original state, so confirming simply
+  // re-dispatches move-workspace with the matching flag.
+  if (result.kind === 'needs-stash' || result.kind === 'conflict') {
+    ctx.dispatch({
+      deleteSource,
+      files: result.files,
+      projectId,
+      sourceLabel,
+      sourceWorkspaceId,
+      targetLabel,
+      targetWorkspaceId,
+      type: 'open-workspace-move-confirm',
+      variant: result.kind === 'needs-stash' ? 'stash-target' : 'keep-conflicts',
+    })
+    return
+  }
+  if (result.kind === 'conflict-kept') {
+    // Never delete the source here — its work only landed half-resolved. The
+    // auto-commit driver is safe against this state: git refuses to commit
+    // with unmerged index entries, so it fails loudly instead of committing
+    // conflict markers.
+    handleSwitchWorkspace({ ...ctx, state: ctx.getState() }, projectId, targetWorkspaceId)
+    toast.warning(
+      `Left conflict markers in ${targetLabel} (${result.files.length} file(s)) — resolve & commit there; ${sourceLabel} kept`
+    )
+    return
+  }
+  if (result.kind === 'error') {
+    toast.error(`Move failed: ${result.message}`)
+    return
+  }
+
+  // Land on the target. When deleting the source, close its terminals and
+  // switch to the target up front, synchronously, BEFORE the slow
+  // `git worktree remove`. Closing the source's active tab re-syncs the active
+  // workspace to a default tab (withActiveTabWorkspace); doing the close+switch in
+  // one batch lands on the target with no intermediate render, so the removal
+  // runs with the target already active instead of flashing/sticking to a
+  // default workspace. Re-read state each step so we never resurrect the source.
+  if (deleteSource) {
+    disposeWorkspaceTabs({ ...ctx, state: ctx.getState() }, sourceWorkspaceId)
+    handleSwitchWorkspace({ ...ctx, state: ctx.getState() }, projectId, targetWorkspaceId)
+    await runDeleteWorkspace({ ...ctx, state: ctx.getState() }, projectId, sourceWorkspaceId, true)
+  } else {
+    handleSwitchWorkspace({ ...ctx, state: ctx.getState() }, projectId, targetWorkspaceId)
+  }
+  const stashNote = result.stashedTarget
+    ? ` · target's previous changes stashed (recover with git stash pop)`
+    : ''
+  toast.success(
+    `Moved ${sourceLabel} → ${targetLabel} · ${result.filesChanged} file(s) staged — review & commit${stashNote}`
+  )
+}
+
+export function removeWorkspaceRecordFromProject(
+  ctx: SideEffectContext,
+  projectId: string,
+  project: NonNullable<SideEffectContext['state']['projects'][number]>,
+  workspaceId: string
+): void {
+  const projects = replaceProject(ctx, projectId, (entry) => {
+    // Filtered from `entry`, not from the `project` this was called with: a
+    // workspace created while the delete's git work ran is in one and not the
+    // other, and rebuilding from the stale copy would delete it too.
+    const remaining = (entry.workspaces ?? []).filter((w) => w.id !== workspaceId)
+    return {
+      ...entry,
+      activeWorkspaceId: (entry.activeWorkspaceId === workspaceId
+        ? remaining[0]
+        : getActiveWorkspace(entry)
+      )?.id,
+      projectSnapshot: pruneSnapshotOfWorkspace(entry.projectSnapshot, workspaceId),
+      updatedAt: new Date().toISOString(),
+      workspaces: remaining,
+    }
+  })
+  saveProjectCatalog(projects)
+  ctx.dispatch({ projects, type: 'set-projects' })
+}
+
+export function isForceableWorkspaceDeleteError(message: string): boolean {
+  return /active assistant tabs|dirty|uncommitted|modified|untracked|not clean|contains.*changes/i.test(
+    message
+  )
+}
+
+class ActiveWorkspaceTabsError extends Error {
+  constructor(tabCount: number) {
+    super(
+      `active assistant tabs are using this workspace (${tabCount}) — they will be closed if you confirm.`
+    )
+  }
+}

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

@@ -0,0 +1,138 @@
+/**
+ * Per-workspace activity, and the notification sound that goes with it.
+ *
+ * The store only holds tabs for the project the client is attached to, but the
+ * daemon broadcasts every tab's status with its `workspaceId` (v18). So the
+ * table of "which tab is doing what" lives here, module-owned, and only the
+ * aggregate per workspace is dispatched into `AppState.workspaceActivity` —
+ * which is what the sidebar draws for every project, current or not.
+ *
+ * Both notification sounds are triggered from here so the glyph and the sound
+ * can never disagree about what happened:
+ *   - a tab entering `waiting-input` (the agent is asking something),
+ *   - a tab completing a turn (the daemon's settled end-of-turn signal).
+ * Neither fires for the tab you are looking at.
+ */
+import type { TabActivity } from '../state/types'
+
+import { playNotificationSound } from '../settings/sections/notifications'
+import { appStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+
+interface Entry {
+  status: TabActivity
+  workspaceId: string | undefined
+  /**
+   * Whether this client has seen the tab do something since the last turn it
+   * announced. The daemon's end-of-turn timer is per-process: restart it (an
+   * update, `restart-daemon`) and every surviving idle PTY produces a
+   * turn-complete a settle window later. Requiring an observed `working` /
+   * `waiting-input` first is what keeps that restart from ticking every
+   * workspace and ringing.
+   */
+  armed: boolean
+}
+
+// A tab in another project never sends this client its `tabExit`, so an entry
+// here can outlive its PTY. The daemon emits a final `idle` for a tab it stops
+// seeing (the tick cleanup in `assistant-status-detection-loop.ts`), which is
+// what keeps a tab that died mid-turn from pinning a spinner to a workspace
+// row forever; the entry itself is left behind, contributing nothing.
+const entries = new Map<string, Entry>()
+
+/** The two flags a set of tabs adds up to. Pure, and the reason it is exported. */
+export function aggregate(statuses: readonly TabActivity[]): {
+  working: boolean
+  waiting: boolean
+} {
+  return {
+    waiting: statuses.includes('waiting-input'),
+    working: statuses.includes('working'),
+  }
+}
+
+function publish(workspaceId: string | undefined): void {
+  if (workspaceId == null || workspaceId === '') return
+  const statuses: TabActivity[] = []
+  for (const entry of entries.values()) {
+    if (entry.workspaceId === workspaceId) statuses.push(entry.status)
+  }
+  const { waiting, working } = aggregate(statuses)
+  dispatchGlobal({ type: 'set-workspace-activity', waiting, working, workspaceId })
+}
+
+/** True when this tab is the one on screen — no sound, no unseen-tick, for it. */
+function isBeingWatched(tabId: string): boolean {
+  return appStore.getState().activeTabId === tabId
+}
+
+export function recordTabStatus(
+  tabId: string,
+  status: TabActivity,
+  workspaceId: string | undefined,
+  options?: { silent?: boolean }
+): void {
+  const previous = entries.get(tabId)
+  const armed = status === 'working' || status === 'waiting-input' || (previous?.armed ?? false)
+  // An event that carries no workspace does not mean the tab lost one. A tab
+  // created before the daemon recorded workspaces has none in its registry,
+  // but the client's own snapshot does — and the attach seeded us with it, so
+  // keep it rather than blanking the row on the next status change.
+  const known = workspaceId ?? previous?.workspaceId
+  entries.set(tabId, { armed, status, workspaceId: known })
+  // A tab can be reassigned to another workspace (workspace move); the one it
+  // left has one tab fewer and has to be recomputed too.
+  if (previous && previous.workspaceId !== known) publish(previous.workspaceId)
+  publish(known)
+
+  if (
+    options?.silent !== true &&
+    status === 'waiting-input' &&
+    previous?.status !== 'waiting-input' &&
+    !isBeingWatched(tabId)
+  ) {
+    playNotificationSound()
+  }
+}
+
+/**
+ * Seed from the tabs an attach handed us, so a workspace whose agent has been
+ * waiting since before this client started says so on the first paint instead
+ * of waiting for a transition that already happened. Silent by definition:
+ * nothing here is news.
+ */
+export function seedTabActivity(
+  tabs: readonly { id: string; activity?: TabActivity; workspaceId?: string }[]
+): void {
+  for (const tab of tabs) {
+    recordTabStatus(tab.id, tab.activity ?? 'idle', tab.workspaceId, { silent: true })
+  }
+}
+
+export function recordTurnComplete(tabId: string, workspaceId: string | undefined): void {
+  const entry = entries.get(tabId)
+  // Nothing observed since the last turn — this is a restarted daemon
+  // re-announcing the end of a turn that ended before we were listening.
+  if (entry?.armed !== true) return
+  entry.armed = false
+  if (isBeingWatched(tabId)) return
+  if (workspaceId != null && workspaceId !== '') {
+    dispatchGlobal({ type: 'mark-workspace-done', workspaceId })
+  }
+  // The workspace tick says where to look; this says which tab rang. A no-op
+  // for a tab this client doesn't hold — its workspace row is the answer there.
+  dispatchGlobal({ tabId, type: 'mark-tab-unseen' })
+  playNotificationSound()
+}
+
+export function forgetTabActivity(tabId: string): void {
+  const entry = entries.get(tabId)
+  if (!entry) return
+  entries.delete(tabId)
+  publish(entry.workspaceId)
+}
+
+/** Test seam: drop every remembered tab. */
+export function resetWorkspaceActivity(): void {
+  entries.clear()
+}

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

@@ -0,0 +1,90 @@
+// Names a workspace after the prompt that created it.
+//
+// Two stages, because a model call takes seconds and workspace creation must
+// not wait on the network: a local heuristic name is applied at creation, then
+// 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.
+
+import type { AssistantId, WorkspaceRecord } from '../state/types'
+
+import { heuristicTitle } from '../auto-rename/heuristic-title'
+import { generateTabTitle, 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
+ * to its own `wt-<project>` default.
+ */
+export function placeholderWorkspaceName(prompt: string): string | undefined {
+  return heuristicTitle(prompt) ?? undefined
+}
+
+export interface WorkspaceNamingTarget {
+  projectId: string
+  workspace: WorkspaceRecord
+  prompt: string
+  /** Provider used for the naming call — the assistant the user just picked. */
+  provider: AssistantId
+}
+
+export interface WorkspaceNamingDeps {
+  applyName: (projectId: string, workspaceId: string, patch: Partial<WorkspaceRecord>) => void
+  renameBranch?: (repoRoot: string, from: string, to: string) => Promise<boolean>
+  spawn?: TitleSpawnFn
+  signal?: AbortSignal
+}
+
+/**
+ * Replace a workspace's placeholder name and branch with ones generated from
+ * the prompt. Silent on every failure: a missing CLI, a timeout or a branch
+ * collision all leave the placeholder standing, which is a perfectly usable
+ * outcome and not worth a toast.
+ *
+ * ponytail: fixed timeout, no model override. Read `autoRename.models` here if
+ * anyone wants naming on a cheaper model than the tab's assistant.
+ */
+export async function renameWorkspaceFromPrompt(
+  target: WorkspaceNamingTarget,
+  deps: WorkspaceNamingDeps
+): Promise<void> {
+  const result = await generateTabTitle({
+    firstPrompt: target.prompt,
+    provider: target.provider,
+    signal: deps.signal ?? new AbortController().signal,
+    spawn: deps.spawn,
+    timeoutMs: NAMING_TIMEOUT_MS,
+  })
+  if (result.status !== 'ok') return
+
+  const { workspace } = target
+  if (result.title === workspace.name) return
+
+  const branch = branchNameFor(result.title)
+  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
+
+  deps.applyName(target.projectId, workspace.id, {
+    name: result.title,
+    ...(branchRenamed ? { branch } : null),
+  })
+}