@brimveyn/aimux 1.20.4 → 1.22.0

package/src/app-runtime/use-setup-runner.ts

@@ -0,0 +1,96 @@
+import { useEffect, useRef } from 'react'
+
+import type { AppState, ProjectRecord, TabSession, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { hasSetupScript } from '../state/project-data'
+import { findSetupTab, runSetup } from './setup-actions'
+
+export interface SetupCandidate {
+  projectId: string
+  workspace: WorkspaceRecord
+}
+
+/**
+ * Which workspaces should have their setup script run right now.
+ *
+ * The trigger is "a workspace id this session has not seen before", not "a
+ * workspace became active". Activation is the wrong signal: `j`/`k` cycles
+ * workspaces, so an activation-based rule would fire the script in every
+ * workspace the user scrolls past. Watching the id set also means one rule
+ * covers both creation paths — the TUI's `<C-p>` and `aimux workspace create`
+ * arriving over the daemon — instead of a hook per call site, which is how the
+ * CLI path ends up silently skipping setup.
+ *
+ * Mutates `seenByProject`: every id examined is marked seen, so a workspace is
+ * only ever a candidate once.
+ */
+export function collectSetupCandidates(
+  projects: ProjectRecord[],
+  tabs: TabSession[],
+  seenByProject: Map<string, Set<string>>,
+  hasScript: (projectId: string) => boolean
+): SetupCandidate[] {
+  const candidates: SetupCandidate[] = []
+
+  for (const project of projects) {
+    const seen = seenByProject.get(project.id)
+    const workspaces = project.workspaces ?? []
+
+    // First sight of a project: record what it already has and run nothing.
+    // Without this, switching to a project surfaces N pre-existing workspaces
+    // at once and would fire N setups.
+    if (!seen) {
+      seenByProject.set(project.id, new Set(workspaces.map((w) => w.id)))
+      continue
+    }
+
+    for (const workspace of workspaces) {
+      if (seen.has(workspace.id)) continue
+      seen.add(workspace.id)
+
+      // The primary workspace *is* the user's real repo checkout. Running a
+      // script that does `cp .env.example .env` over it would clobber their
+      // actual .env.
+      if (workspace.source === 'primary') continue
+      if (!hasScript(project.id)) continue
+      if (findSetupTab(tabs, workspace.id)) continue
+
+      candidates.push({ projectId: project.id, workspace })
+    }
+  }
+
+  return candidates
+}
+
+/**
+ * Runs a project's setup script once per newly created workspace.
+ *
+ * ponytail: a workspace created by the CLI while the app is closed is seeded as
+ * pre-existing on the next boot and never auto-runs. The widget's Run button
+ * covers it; compare createdAt against setupRanAt if that turns out to matter.
+ *
+ * The outcome is recorded by `recordSetupExitIfHidden`, called from the
+ * backend's exit event, which already carries the exit code.
+ */
+export function useSetupRunner(state: AppState, ctx: SideEffectContext): void {
+  const seenByProject = useRef(new Map<string, Set<string>>())
+  const ctxRef = useRef(ctx)
+  ctxRef.current = ctx
+
+  useEffect(() => {
+    // Tabs are read fresh rather than taken as a dependency: their array
+    // identity changes on every viewport frame, which would re-run this at the
+    // rate the PTYs print. The store is also the more correct source — the
+    // render snapshot can lag a setup tab that was just added.
+    const candidates = collectSetupCandidates(
+      state.projects,
+      ctxRef.current.getState().tabs,
+      seenByProject.current,
+      hasSetupScript
+    )
+    for (const { projectId, workspace } of candidates) {
+      runSetup(ctxRef.current, projectId, workspace)
+    }
+  }, [state.projects])
+}

package/src/app-runtime/use-terminal-resize.ts

@@ -10,10 +10,11 @@ import {
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState } from '../state/types'
 import type { MeasuredPaneRect } from './use-pane-size-report'
 
-import { getGitPaneWidthFromRatio } from '../state/git-pane-sizing'
+import { getBarWidth } from '../state/bars'
 import {
   createTerminalBounds,
   forEachSplitPaneRect,
@@ -151,7 +152,10 @@ export function useTerminalResize({
   const handledBySyncRef = useRef(false)
   const sidebarMountedRef = useRef(false)
 
-  const currentTabIds = state.tabs.map((t) => t.id)
+  // Hidden tabs are excluded from the open-loop cascade: their host (the setup
+  // widget) measures its own box, and the cascade would overwrite that with the
+  // main terminal area's size on every terminal or bar resize.
+  const currentTabIds = state.tabs.filter((t) => t.hidden !== true).map((t) => t.id)
   const tabIdsChanged =
     currentTabIds.length !== tabIdsRef.current.length ||
     currentTabIds.some((id, i) => id !== tabIdsRef.current[i])
@@ -179,15 +183,15 @@ export function useTerminalResize({
   // loop so an unchanged box never re-triggers a resize.
   const measuredRef = useRef(new Map<string, { cols: number; rows: number }>())
 
-  // Drop the dedupe cache when the workspace changes. attach() re-gates every
+  // Drop the dedupe cache when the project changes. attach() re-gates every
   // restored tab's paneReady to false; if a tabId carries the same dimensions
-  // across workspaces, handleMeasure's prev-match would short-circuit and
+  // across projects, handleMeasure's prev-match would short-circuit and
   // never call resizeTab({confirmedFromMeasurement:true}), leaving the gate
   // closed forever — the new pane then paints a stale buffered snapshot from
-  // the old workspace, which is the 2–3 row offset users see.
-  const lastSessionIdRef = useRef(state.currentSessionId)
-  if (lastSessionIdRef.current !== state.currentSessionId) {
-    lastSessionIdRef.current = state.currentSessionId
+  // the old project, which is the 2–3 row offset users see.
+  const lastProjectIdRef = useRef(state.currentProjectId)
+  if (lastProjectIdRef.current !== state.currentProjectId) {
+    lastProjectIdRef.current = state.currentProjectId
     measuredRef.current.clear()
   }
 
@@ -223,29 +227,30 @@ export function useTerminalResize({
     [backend, contentOriginRef]
   )
 
-  const gitPaneInPaneMode = state.gitPane.mode === 'pane' && state.gitPane.visible
+  // `getBarWidth` is the single authority on bar width — the Bar component
+  // renders from the same function. A mismatch silently corrupts PTY columns
+  // and mouse hit-testing.
+  const leftBarWidth = getBarWidth(state.bars.left)
+  const rightBarWidth = getBarWidth(state.bars.right)
   const terminalSize = useMemo(() => {
-    const sidebarWidth = state.sidebar.visible ? state.sidebar.width : 0
-    const sessionBarRows = state.sessionBar.visible ? 1 : 0
-    const sessionBarTopOffset = sessionBarRows
+    const projectBarRows = state.projectBar.visible ? 1 : 0
+    const projectBarTopOffset = projectBarRows
     const reservedRows =
       MAIN_AREA_VERTICAL_PADDING +
       STATUS_BAR_HEIGHT +
       TERMINAL_PANE_VERTICAL_CHROME +
-      sessionBarRows
-    const gitPaneWidth = gitPaneInPaneMode ? getGitPaneWidthFromRatio(state.gitPane.paneRatio) : 0
-    const gitOnLeft = gitPaneInPaneMode && state.gitPane.position === 'left'
+      projectBarRows
     const cols = Math.max(
       MIN_TERMINAL_COLS,
-      Math.floor(dimensions.width - sidebarWidth - gitPaneWidth - MAIN_AREA_HORIZONTAL_CHROME)
+      Math.floor(dimensions.width - leftBarWidth - rightBarWidth - MAIN_AREA_HORIZONTAL_CHROME)
     )
     const rows = Math.max(MIN_TERMINAL_ROWS, Math.floor(dimensions.height - reservedRows))
 
     contentOriginRef.current = {
       cols,
       rows,
-      x: sidebarWidth + (gitOnLeft ? gitPaneWidth : 0) + 1,
-      y: 1 + sessionBarTopOffset,
+      x: leftBarWidth + 1,
+      y: 1 + projectBarTopOffset,
     }
 
     return { cols, rows }
@@ -253,12 +258,9 @@ export function useTerminalResize({
     contentOriginRef,
     dimensions.height,
     dimensions.width,
-    state.sidebar.visible,
-    state.sidebar.width,
-    state.sessionBar.visible,
-    gitPaneInPaneMode,
-    state.gitPane.position,
-    state.gitPane.paneRatio,
+    leftBarWidth,
+    rightBarWidth,
+    state.projectBar.visible,
   ])
 
   useLayoutEffect(() => {
@@ -280,14 +282,7 @@ export function useTerminalResize({
     })
     handledBySyncRef.current = true
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    state.sidebar.visible,
-    state.sidebar.width,
-    state.sessionBar.visible,
-    gitPaneInPaneMode,
-    state.gitPane.position,
-    state.gitPane.paneRatio,
-  ])
+  }, [leftBarWidth, rightBarWidth, state.projectBar.visible])
 
   useEffect(() => {
     if (handledBySyncRef.current) {

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.`
+    )
+  }
+}