@brimveyn/aimux 1.22.4 → 1.22.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.22.4",
+  "version": "1.22.6",
   "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/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'
@@ -120,7 +121,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 +152,7 @@ export async function createAimuxTempWorkspace(
     repoPath: repoRoot,
     targetPath,
   })
+  await copyWorktreeFiles(repoRoot, targetPath, worktreeCopyPatterns())
   const now = new Date().toISOString()
 
   const workspace: WorkspaceRecord = {
@@ -209,12 +215,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-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(
     () => {

package/src/auto-rename/title-runner.ts

@@ -1,4 +1,5 @@
 import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+import { foldDiacritics } from '../platform/worktree-paths'
 import { clampTitle } from './title-format'
 
 export type TitleSpawnFn = (
@@ -16,6 +17,33 @@ export type TitleResult =
   | { status: 'failed' }
   | { status: 'unavailable' }
 
+/**
+ * A workspace needs two different names from one request: a tab title in the
+ * user's own language, and a branch name — which is read by git, by reviewers
+ * and by CI, so it follows the repo's conventions instead: English, a
+ * conventional-commit type, kebab-case. `branch` is null when the model gave
+ * nothing that qualifies; the caller keeps the branch it already has.
+ */
+export type NamingResult =
+  | { status: 'ok'; title: string; branch: string | null }
+  | { status: 'failed' }
+  | { status: 'unavailable' }
+
+/** Conventional-commit types a generated branch may use; anything else is refused. */
+const BRANCH_TYPES = new Set([
+  'build',
+  'chore',
+  'ci',
+  'docs',
+  'feat',
+  'fix',
+  'perf',
+  'refactor',
+  'style',
+  'test',
+])
+const BRANCH_SUBJECT_WORDS = 5
+
 export function buildTitlePrompt(firstPrompt: string): string {
   return [
     'Create a concise tab title for the user request below.',
@@ -26,15 +54,56 @@ export function buildTitlePrompt(firstPrompt: string): string {
   ].join('\n')
 }
 
-export function sanitizeGeneratedTitle(raw: string): string | null {
-  const first = raw
+export function buildWorkspaceNamingPrompt(firstPrompt: string): string {
+  return [
+    'Name a workspace for the user request below.',
+    'Return exactly two lines and nothing else.',
+    'Line 1 — a tab title: 2 to 6 words, at most 48 characters, in the same language as the request.',
+    'Line 2 — a git branch named <type>/<subject>, always in English whatever the language of the request.',
+    '<type> is one of: feat, fix, refactor, perf, docs, test, chore, ci, style, build.',
+    '<subject> is 2 to 5 lowercase words joined by hyphens, naming what changes rather than restating the request.',
+    'Example line 2: fix/scroll-drift-on-resize',
+    'No quotes, no labels, no numbering, no markdown, no ending punctuation.',
+    '',
+    firstPrompt.slice(0, 8_000),
+  ].join('\n')
+}
+
+function nonEmptyLines(raw: string): string[] {
+  return raw
     .split(/\r?\n/u)
     .map((line) => line.trim())
-    .find(Boolean)
-  if (first == null || first === '') return null
+    .filter(Boolean)
+}
+
+/** Strip the wrappers a model reaches for even when told not to: labels, list markers, quotes. */
+function unwrapLine(line: string, label: RegExp): string {
+  return line
+    .replace(label, '')
+    .replace(/^(?:\d+[.)]|[-*])\s*/u, '')
+    .replaceAll(/^["'`“”‘’]+|["'`“”‘’]+$/gu, '')
+}
 
-  const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
-  return clampTitle(unlabelled)
+export function sanitizeGeneratedTitle(raw: string): string | null {
+  const first = nonEmptyLines(raw)[0]
+  if (first == null) return null
+  return clampTitle(unwrapLine(first, /^TITLE\s*:\s*/iu))
+}
+
+export function sanitizeGeneratedBranch(raw: string): string | null {
+  const line = unwrapLine(raw.trim(), /^BRANCH\s*:\s*/iu)
+  const slash = line.indexOf('/')
+  if (slash < 0) return null
+  const type = line.slice(0, slash).trim().toLowerCase()
+  if (!BRANCH_TYPES.has(type)) return null
+  // Whole words only: a mid-word cut ("...-bran") names nothing.
+  const subject = foldDiacritics(line.slice(slash + 1))
+    .toLowerCase()
+    .split(/[^a-z0-9]+/u)
+    .filter(Boolean)
+    .slice(0, BRANCH_SUBJECT_WORDS)
+    .join('-')
+  return subject === '' ? null : `${type}/${subject}`
 }
 
 function executableOnPath(executable: string): boolean {
@@ -46,7 +115,7 @@ function executableOnPath(executable: string): boolean {
   }
 }
 
-export async function generateTabTitle(options: {
+export interface NamingOptions {
   provider: string
   model?: string
   firstPrompt: string
@@ -54,12 +123,13 @@ export async function generateTabTitle(options: {
   signal: AbortSignal
   spawn?: TitleSpawnFn
   isExecutableAvailable?: (executable: string) => boolean
-}): Promise<TitleResult> {
-  const invocation = buildHeadlessInvocation(
-    options.provider,
-    buildTitlePrompt(options.firstPrompt),
-    options.model
-  )
+}
+
+async function runNamingModel(
+  options: NamingOptions,
+  prompt: string
+): Promise<{ status: 'ok'; stdout: string } | { status: 'failed' } | { status: 'unavailable' }> {
+  const invocation = buildHeadlessInvocation(options.provider, prompt, options.model)
   if (!invocation) return { status: 'unavailable' }
 
   // A caller-supplied spawn does not go through PATH, so only probe it for the
@@ -72,13 +142,33 @@ export async function generateTabTitle(options: {
   try {
     const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
     if (!result || result.exitCode !== 0 || signal.aborted) return { status: 'failed' }
-    const title = sanitizeGeneratedTitle(result.stdout)
-    return title == null ? { status: 'failed' } : { status: 'ok', title }
+    return { status: 'ok', stdout: result.stdout }
   } catch {
     return { status: 'failed' }
   }
 }
 
+export async function generateTabTitle(options: NamingOptions): Promise<TitleResult> {
+  const run = await runNamingModel(options, buildTitlePrompt(options.firstPrompt))
+  if (run.status !== 'ok') return run
+  const title = sanitizeGeneratedTitle(run.stdout)
+  return title == null ? { status: 'failed' } : { status: 'ok', title }
+}
+
+/** One model call for both names — a workspace must not wait on two. */
+export async function generateWorkspaceNaming(options: NamingOptions): Promise<NamingResult> {
+  const run = await runNamingModel(options, buildWorkspaceNamingPrompt(options.firstPrompt))
+  if (run.status !== 'ok') return run
+  const [titleLine, branchLine] = nonEmptyLines(run.stdout)
+  const title = titleLine == null ? null : sanitizeGeneratedTitle(titleLine)
+  if (title == null) return { status: 'failed' }
+  return {
+    branch: branchLine == null ? null : sanitizeGeneratedBranch(branchLine),
+    status: 'ok',
+    title,
+  }
+}
+
 async function defaultSpawn(
   invocation: HeadlessInvocation,
   signal: AbortSignal

package/src/cli/commands/workspace/create-core.ts

@@ -2,6 +2,7 @@ import type { ProjectRecord, WorkspaceRecord } from '../../../state/types'
 import type { DaemonClient } from '../../client/daemon-client'
 
 import { createGitWorktree, removeGitWorktree, resolveGitRef } from '../../../git/worktree'
+import { copyWorktreeFiles } from '../../../git/worktree-files'
 import { IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS } from '../../../ipc/protocol'
 import { createPrefixedId } from '../../../platform/id'
 import {
@@ -10,7 +11,7 @@ import {
   makeWorktreePath,
   pruneEmptyWorktreeParent,
 } from '../../../platform/worktree-paths'
-import { shouldRefreshBase } from '../../../settings/flags'
+import { shouldRefreshBase, worktreeCopyPatterns } from '../../../settings/flags'
 
 export interface CreateWorkspaceParams {
   /** Base ref for the branch (callers default to 'HEAD'). */
@@ -84,6 +85,7 @@ export async function createProjectWorkspace(
     await pruneEmptyWorktreeParent(targetPath)
     throw error
   }
+  await copyWorktreeFiles(primary.repoRoot, targetPath, worktreeCopyPatterns())
 
   const now = new Date().toISOString()
   const record: WorkspaceRecord = {

package/src/git/pr-status-poller.ts

@@ -15,14 +15,16 @@ interface Options {
 
 /** One-shot refetch, for when an action we took just invalidated the state. */
 export async function refreshPrStatus(projectPath: string): Promise<void> {
-  prStatusStore.getState().setResult(await collectPrStatus(projectPath))
+  prStatusStore.getState().setResult(projectPath, await collectPrStatus(projectPath))
 }
 
 export function usePrStatusPolling({ enabled, projectPath }: Options): void {
   useEffect(() => {
     if (!enabled || !(projectPath != null && projectPath !== '')) return
 
-    prStatusStore.getState().reset()
+    // Show what we last knew about this path while the fetch runs in the
+    // background, rather than blanking the row on every workspace switch.
+    prStatusStore.getState().selectPath(projectPath)
 
     let cancelled = false
     let timer: ReturnType<typeof setTimeout> | null = null
@@ -36,7 +38,7 @@ export function usePrStatusPolling({ enabled, projectPath }: Options): void {
     const tick = async () => {
       const result = await collectPrStatus(projectPath)
       if (cancelled) return
-      prStatusStore.getState().setResult(result)
+      prStatusStore.getState().setResult(projectPath, result)
       if (result.kind === 'error') {
         delay = Math.min(delay * 2, MAX_INTERVAL_MS)
       } else if (result.kind === 'ok' && result.checks.some((c) => c.state === 'pending')) {

package/src/git/worktree-files.ts

@@ -0,0 +1,51 @@
+import { Glob } from 'bun'
+import { existsSync } from 'node:fs'
+import { cp, mkdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+import { logDebug } from '../debug/input-log'
+
+/**
+ * Seed a fresh worktree with the untracked local files it needs to run.
+ *
+ * A worktree checkout holds tracked files and nothing else, so every ignored
+ * local file — `.env` above all — is missing the moment the workspace opens.
+ * The setup script can recreate some of them from a template; it cannot invent
+ * the secrets, which is why they are copied from the main checkout instead.
+ *
+ * ponytail: the patterns are matched against the whole checkout, gitignore and
+ * all — a recursive pattern walks `node_modules` too. Feeding the scan the ignore
+ * rules is the upgrade path if that ever costs anything noticeable.
+ *
+ * Best-effort by design: a pattern that matches nothing, or a file that cannot
+ * be read, must not take the workspace down with it. Nothing is ever
+ * overwritten — a match that already exists in the new worktree is tracked
+ * content, and clobbering it would dirty the workspace before its first commit.
+ */
+export async function copyWorktreeFiles(
+  repoPath: string,
+  targetPath: string,
+  patterns: readonly string[]
+): Promise<void> {
+  for (const pattern of patterns) {
+    try {
+      const matches = new Glob(pattern).scan({ cwd: repoPath, dot: true, onlyFiles: true })
+      for await (const relative of matches) {
+        const to = join(targetPath, relative)
+        if (existsSync(to)) continue
+        await mkdir(dirname(to), { recursive: true })
+        await cp(join(repoPath, relative), to)
+      }
+    } catch (error) {
+      // A workspace without its .env still opens; a workspace that failed to be
+      // created does not. Logged rather than swallowed outright: a file that
+      // silently never arrives is otherwise indistinguishable from one the
+      // pattern never matched.
+      logDebug('worktree.seed.error', {
+        error: error instanceof Error ? error.message : String(error),
+        pattern,
+        repoPath,
+      })
+    }
+  }
+}

package/src/git/worktree.ts

@@ -206,7 +206,7 @@ export async function removeGitWorktree({
   force: boolean
 }): Promise<void> {
   if (!isInsideAimuxWorktreeRoot(targetPath)) {
-    throw new Error(`refusing to delete worktree outside Aimux temp root: ${targetPath}`)
+    throw new Error(`refusing to delete worktree outside Aimux worktree root: ${targetPath}`)
   }
   const result = force
     ? await $`git -C ${repoPath} worktree remove --force ${targetPath}`.quiet().nothrow()

package/src/platform/play-sound.ts

@@ -141,6 +141,7 @@ function findPlayer(platform: string): string | null {
 }
 
 let lastPlayedAt = 0
+let playing: { kill: () => void } | null = null
 
 /**
  * Whether enough time has passed since the last sound. Separate from the play
@@ -151,16 +152,17 @@ export function shouldPlayNow(now: number, previous: number): boolean {
 }
 
 /**
- * Play a sound file. Returns whether a player was actually spawned, which is
- * what the settings screen's "Test sound" row reports.
+ * Play a sound file. Returns false only when nothing could play at all — a
+ * missing player or a failed spawn — which is what the settings screen's "Test
+ * sound" row reports. A throttled call is not a failure.
+ *
+ * The throttle covers every caller, the test row included: held down, its key
+ * repeats tens of times a second, and one live player per press is enough to
+ * take CoreAudio down with it.
  */
-export function playSoundFile(
-  path: string,
-  options?: { ignoreThrottle?: boolean; volume?: number }
-): boolean {
+export function playSoundFile(path: string, options?: { volume?: number }): boolean {
   const now = Date.now()
-  const throttled = options?.ignoreThrottle !== true
-  if (throttled && !shouldPlayNow(now, lastPlayedAt)) return false
+  if (!shouldPlayNow(now, lastPlayedAt)) return true
   const platform = process.platform
   const bin = findPlayer(platform)
   if (bin == null) {
@@ -169,10 +171,11 @@ export function playSoundFile(
   }
   const argv = soundPlayerArgv(platform, bin, path, options?.volume ?? DEFAULT_VOLUME)
   try {
-    Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
-    // A test press does not start the window: it would swallow a real
-    // notification arriving in the next few hundred milliseconds.
-    if (throttled) lastPlayedAt = now
+    // Cut the previous one rather than layer on top of it. Players come and go
+    // on their own, so killing an already-exited one has to be harmless.
+    playing?.kill()
+    playing = Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
+    lastPlayedAt = now
     return true
   } catch (error) {
     logDebug('platform.playSound.error', {

package/src/platform/worktree-paths.ts

@@ -2,16 +2,32 @@ import { createHash } from 'node:crypto'
 import { lstat, mkdir, realpath, rmdir } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
 
-const DEFAULT_WORKTREE_ROOT = '/tmp/aimux-wt'
+// Worktrees hold uncommitted work, so they live in the XDG data dir, not /tmp:
+// a reboot clears /tmp on macOS and on most Linux distros, and took the work
+// with it. The old root stays recognized (never generated) so worktrees created
+// before this change are still classified and deleted as aimux-managed.
+const LEGACY_WORKTREE_ROOT = '/tmp/aimux-wt'
 const MAX_SLUG_LENGTH = 24
 
+function defaultWorktreeRoot(): string {
+  const xdgData = process.env.XDG_DATA_HOME
+  const base =
+    xdgData != null && xdgData !== '' ? xdgData : join(process.env.HOME ?? '.', '.local', 'share')
+  return join(base, 'aimux', 'worktrees')
+}
+
 export function getAimuxWorktreeRoot(): string {
   const root = process.env.AIMUX_WORKTREE_ROOT
-  return root != null && root !== '' ? root : DEFAULT_WORKTREE_ROOT
+  return root != null && root !== '' ? root : defaultWorktreeRoot()
+}
+
+/** `améliorer` → `ameliorer`, so accents slug as letters instead of separators. */
+export function foldDiacritics(input: string): string {
+  return input.normalize('NFD').replaceAll(/\p{Diacritic}/gu, '')
 }
 
 export function sanitizePathSegment(input: string, maxLength = MAX_SLUG_LENGTH): string {
-  const sanitized = input
+  const sanitized = foldDiacritics(input)
     .trim()
     .replaceAll(/[^A-Za-z0-9._-]+/g, '-')
     .replaceAll(/\.\.+/g, '-')
@@ -42,9 +58,10 @@ export function makeWorktreePath({
 
 export function isInsideAimuxWorktreeRoot(path: string): boolean {
   const normalizeTmp = (value: string) => value.replace(/^\/private\/tmp(?=\/|$)/, '/tmp')
-  const root = `${normalizeTmp(resolve(getAimuxWorktreeRoot()))}/`
   const target = `${normalizeTmp(resolve(path))}/`
-  return target.startsWith(root)
+  return [getAimuxWorktreeRoot(), LEGACY_WORKTREE_ROOT].some((root) =>
+    target.startsWith(`${normalizeTmp(resolve(root))}/`)
+  )
 }
 
 export async function ensureAimuxWorktreeRoot(): Promise<string> {
@@ -80,13 +97,13 @@ export async function pruneEmptyWorktreeParent(worktreePath: string): Promise<vo
 export async function assertSafeAimuxWorktreePath(path: string): Promise<void> {
   const root = await ensureAimuxWorktreeRoot()
   if (!isInsideAimuxWorktreeRoot(path)) {
-    throw new Error(`refusing worktree path outside Aimux temp root: ${path}`)
+    throw new Error(`refusing worktree path outside Aimux worktree root: ${path}`)
   }
   // Create the repo-scoped parent (<root>/r-<hash>) before resolving it: git
   // worktree add does not create intermediate dirs, and realpath() would throw
   // ENOENT on the first worktree for a repo. mkdir(recursive) leaves an
   // existing symlink in place, so the realpath check below still catches an
-  // escape out of the temp root.
+  // escape out of the worktree root.
   const parent = resolve(path, '..')
   await mkdir(parent, { recursive: true })
   const realRoot = await realpath(root)

package/src/settings/flags.ts

@@ -1,5 +1,5 @@
 import { loadConfig } from '../config'
-import { FETCH_BASE } from './sections/git'
+import { COPY_FILES, COPY_FILES_DEFAULT, FETCH_BASE } from './sections/git'
 
 /**
  * Settings read outside the screen, off the file rather than the store.
@@ -13,3 +13,13 @@ import { FETCH_BASE } from './sections/git'
 export function shouldRefreshBase(): boolean {
   return loadConfig().settings?.[FETCH_BASE] !== false
 }
+
+/** Untracked files a new workspace is seeded with, as globs relative to the repo. */
+export function worktreeCopyPatterns(): string[] {
+  const value = loadConfig().settings?.[COPY_FILES]
+  // Only an explicit empty string disables it; an untouched setting gets `.env`.
+  return String(value ?? COPY_FILES_DEFAULT)
+    .split(',')
+    .map((pattern) => pattern.trim())
+    .filter((pattern) => pattern !== '')
+}

package/src/settings/sections/git.ts

@@ -6,6 +6,8 @@ import type { SettingSection, SettingValue } from '../types'
 import { dispatchGlobal, runSideEffectGlobal } from '../../state/dispatch-ref'
 
 export const FETCH_BASE = 'git.fetchBase'
+export const COPY_FILES = 'git.worktreeCopyFiles'
+export const COPY_FILES_DEFAULT = '.env'
 
 function isFileListMode(value: SettingValue): value is GitFileListMode {
   return value === 'tree' || value === 'flat'
@@ -93,6 +95,18 @@ export const GIT_SECTION: SettingSection = {
       label: 'Refresh the base branch',
       storage: 'settings',
     },
+    {
+      // No `apply`, same reason as the row above: `worktreeCopyPatterns` reads
+      // this off the file so `aimux workspace create` honours it too.
+      description:
+        'Untracked files copied into each new workspace. Globs from the repo root: **/.env for nested ones.',
+      fallback: COPY_FILES_DEFAULT,
+      id: COPY_FILES,
+      kind: 'text',
+      label: 'Seed new workspaces with',
+      placeholder: 'nothing',
+      storage: 'settings',
+    },
     {
       apply: (value) => setMultiRepoConfig({ ...getMultiRepoConfig(), enabled: value === true }),
       description: 'Aggregate the status of git repos nested under the project.',

package/src/settings/sections/notifications.ts

@@ -45,10 +45,10 @@ function selectedVolume(): number {
  * user has set the row to `off`, which is what makes it safe to call on every
  * status edge.
  */
-export function playNotificationSound(options?: { ignoreThrottle?: boolean }): boolean {
+export function playNotificationSound(): boolean {
   const path = resolveSoundPath(selectedSoundId())
   if (path == null) return false
-  return playSoundFile(path, { ...options, volume: selectedVolume() })
+  return playSoundFile(path, { volume: selectedVolume() })
 }
 
 export const NOTIFICATIONS_SECTION: SettingSection = {
@@ -89,7 +89,7 @@ export const NOTIFICATIONS_SECTION: SettingSection = {
           toast.info('Notification sound is off')
           return
         }
-        if (!playNotificationSound({ ignoreThrottle: true })) {
+        if (!playNotificationSound()) {
           toast.error('Could not play that sound — no audio player found')
         }
       },

package/src/state/pr-status-store.ts

@@ -5,34 +5,38 @@ import type { PrStatusResult } from '../git/pr-status'
 
 export interface PrStatusState {
   result: PrStatusResult | null
+  /** Last result seen per project path, so a workspace switch shows its own
+   * previous state instead of blanking while the background fetch runs. */
+  byPath: Record<string, PrStatusResult>
   /** True once a fetch failed but we are still showing the previous good result. */
   stale: boolean
-  setResult: (result: PrStatusResult) => void
-  reset: () => void
+  setResult: (path: string, result: PrStatusResult) => void
+  /** Point the row at a project path, showing whatever we last knew about it. */
+  selectPath: (path: string) => void
 }
 
 export const prStatusStore = createStore<PrStatusState>((set) => ({
-  reset: () => set({ result: null, stale: false }),
+  byPath: {},
   result: null,
-  setResult: (result: PrStatusResult) =>
+  selectPath: (path: string) =>
+    set((state) => ({ result: state.byPath[path] ?? null, stale: false })),
+  setResult: (path: string, result: PrStatusResult) =>
     set((state) => {
       // A transient `gh` failure shouldn't blank a PR we already resolved — keep
       // the last good snapshot and mark it stale instead (same contract as
       // ai-usage-store's setSnapshot).
       if (result.kind === 'error' && state.result?.kind === 'ok') return { stale: true }
-      return { result, stale: false }
+      return { byPath: { ...state.byPath, [path]: result }, result, stale: false }
     }),
   stale: false,
 }))
 
 /**
- * The PR state row occupies its band both while the first fetch is in flight
- * and once it resolved to a PR — anything else (no PR, no gh, error) gives the
- * row back. Shared so the header and the row itself can never disagree and
- * shift the layout under the user.
+ * The PR state row only occupies its band once we know there is a PR — an
+ * unknown or resolved-to-nothing state gives the row back. Shared so the header
+ * and the row itself can never disagree and shift the layout under the user.
  */
-export const selectPrRowVisible = (state: PrStatusState): boolean =>
-  state.result === null || state.result.kind === 'ok'
+export const selectPrRowVisible = (state: PrStatusState): boolean => state.result?.kind === 'ok'
 
 export function usePrStatusStore<T>(selector: (state: PrStatusState) => T): T {
   return useStore(prStatusStore, selector)

package/src/ui/components/git/pane/pr-state-row.tsx

@@ -44,18 +44,9 @@ export const PrStateRow = memo(function PrStateRow({ projectPath }: { projectPat
     })()
   }, [projectPath])
 
-  // First fetch still in flight: hold the band empty so the tabs below don't
-  // jump a row once the PR lands.
-  if (result === null) {
-    return (
-      <box backgroundColor={bg} paddingLeft={1} paddingRight={1}>
-        <text selectable={false} bg={bg} wrapMode="none">
-          {' '}
-        </text>
-      </box>
-    )
-  }
-  if (result.kind !== 'ok' || pr === null) return null
+  // Nothing known yet (or nothing to show): stay out of the layout entirely and
+  // appear only once a fetch reports a PR.
+  if (result?.kind !== 'ok' || pr === null) return null
   const status = prActionState(pr, result.checks)
   let label = status.label
   if (confirming) label = 'Merge this PR?'

package/src/ui/components/layout/terminal-pane.tsx

@@ -44,32 +44,6 @@ interface TerminalPaneProps {
   junctionEdges?: JunctionEdges
 }
 
-function getTitle(
-  tab: TabSession | undefined,
-  isActive: boolean,
-  focusMode: TerminalPaneProps['focusMode'],
-  emptyContext: { projectName: string; workspaceName: string }
-): string {
-  if (!tab) {
-    const { projectName, workspaceName } = emptyContext
-    if (projectName === '' && workspaceName === '') return 'No active project'
-    if (workspaceName === '' || workspaceName === projectName) {
-      return `${projectName} · no tabs`
-    }
-    return `${projectName} / ${workspaceName} · no tabs`
-  }
-
-  if (isActive && focusMode === 'terminal-input') {
-    return `● ${tab.title} · ${tab.status}`
-  }
-
-  if (isActive) {
-    return `▸ ${tab.title} · ${tab.status}`
-  }
-
-  return `${tab.title} · ${tab.status}`
-}
-
 function getBorderColor(isActive: boolean, focusMode: TerminalPaneProps['focusMode']): string {
   const t = getCurrentTheme()
   if (!isActive) return t.border
@@ -526,10 +500,6 @@ export function TerminalPane({
       <ContextMenuBox
         border
         borderColor={getBorderColor(paneIsActive, focusMode)}
-        title={getTitle(tab, paneIsActive, focusMode, {
-          projectName: emptyProjectName,
-          workspaceName: emptyWorkspaceName,
-        })}
         padding={0}
         flexDirection="column"
         flexGrow={1}