@brimveyn/aimux 1.21.0 → 1.22.2

package/src/ui/status-bar-model.ts

@@ -3,7 +3,7 @@ import type { ModeId, ResolvedKeymapConfig } from '@brimveyn/aimux-config'
 import type { AppState } from '../state/types'
 
 import { describeBindings } from '../input/keymap/describe-bindings'
-import { getSessionProjectPath } from '../state/session-worktrees'
+import { getActiveWorkspacePath } from '../state/project-workspaces'
 import { buildHintText } from './keymap-context'
 import { abbreviatePath } from './path-format'
 
@@ -16,26 +16,32 @@ export interface IdentitySegment {
 export interface StatusBarModel {
   help: string
   right: string
-  sessionSegments: IdentitySegment[]
+  projectSegments: IdentitySegment[]
 }
 
 const HINT_LIMIT = 6
 const HELP_DESCRIPTION = 'Help'
 const SEP = '  ·  '
 
-function sessionSegments(
-  sessionName: string,
-  sessionPath: string | null | undefined
+function projectSegments(
+  projectName: string,
+  projectPath: string | null | undefined
 ): IdentitySegment[] {
-  const segs: IdentitySegment[] = [{ id: 'session', text: sessionName, tone: 'primary' }]
-  if (sessionPath != null && sessionPath !== '') {
-    segs.push({ id: 'sep-session-path', text: SEP, tone: 'muted' })
-    segs.push({ id: 'path', text: abbreviatePath(sessionPath), tone: 'muted' })
+  const segs: IdentitySegment[] = [{ id: 'project', text: projectName, tone: 'primary' }]
+  if (projectPath != null && projectPath !== '') {
+    segs.push({ id: 'sep-project-path', text: SEP, tone: 'muted' })
+    segs.push({ id: 'path', text: abbreviatePath(projectPath), tone: 'muted' })
   }
   return segs
 }
 
 const STAGING_DESCRIPTIONS = ['Stage', 'Unstage/delete', 'Commit', 'Push']
+/**
+ * Moving around a two-column screen is the one thing you can see from the screen,
+ * so the bar spends its six slots on what you cannot: searching, resetting, and
+ * how to change the thing under the cursor.
+ */
+const SETTINGS_OBVIOUS_DESCRIPTIONS = ['Sections', 'Settings of the section', 'Next', 'Prev']
 
 function hintForMode(config: ResolvedKeymapConfig, modeId: ModeId): string {
   return buildHintText(config, modeId, HINT_LIMIT, { excludeDescriptions: [HELP_DESCRIPTION] })
@@ -57,27 +63,27 @@ function helpHintForMode(config: ResolvedKeymapConfig, modeId: ModeId): string {
 }
 
 export function getStatusBarModel(state: AppState, config: ResolvedKeymapConfig): StatusBarModel {
-  const currentSession =
-    state.currentSessionId != null && state.currentSessionId !== ''
-      ? state.sessions.find((session) => session.id === state.currentSessionId)
+  const currentProject =
+    state.currentProjectId != null && state.currentProjectId !== ''
+      ? state.projects.find((project) => project.id === state.currentProjectId)
       : undefined
-  const sessionName = currentSession?.name ?? 'no workspace'
-  const sessionPath = getSessionProjectPath(currentSession)
-  const sessionSegs = sessionSegments(sessionName, sessionPath)
+  const projectName = currentProject?.name ?? 'no project'
+  const projectPath = getActiveWorkspacePath(currentProject)
+  const projectSegs = projectSegments(projectName, projectPath)
 
   switch (state.focusMode) {
     case 'terminal-input':
       return {
         help: '',
+        projectSegments: projectSegs,
         right: hintForMode(config, 'terminal-input'),
-        sessionSegments: sessionSegs,
       }
     case 'modal': {
       const modalMode = deriveModalModeId(state.modal.type)
       return {
         help: '',
+        projectSegments: projectSegs,
         right: modalMode ? hintForMode(config, modalMode) : '',
-        sessionSegments: sessionSegs,
       }
     }
     case 'git': {
@@ -93,24 +99,32 @@ export function getStatusBarModel(state: AppState, config: ResolvedKeymapConfig)
       }
       return {
         help: helpHintForMode(config, 'git-mode'),
+        projectSegments: [...projectSegs, ...extras],
         right: hintForGitMode(config, headOffset),
-        sessionSegments: [...sessionSegs, ...extras],
       }
     }
+    case 'settings':
+      return {
+        help: helpHintForMode(config, 'settings'),
+        projectSegments: projectSegs,
+        right: buildHintText(config, 'settings', HINT_LIMIT, {
+          excludeDescriptions: [HELP_DESCRIPTION, ...SETTINGS_OBVIOUS_DESCRIPTIONS],
+        }),
+      }
     case 'command-edit': {
       const commandEditMode = deriveCommandEditModeId(state.modal.type)
       return {
         help: '',
+        projectSegments: projectSegs,
         right: commandEditMode ? hintForMode(config, commandEditMode) : '',
-        sessionSegments: sessionSegs,
       }
     }
     case 'navigation':
     default:
       return {
         help: helpHintForMode(config, 'navigation'),
+        projectSegments: projectSegs,
         right: hintForMode(config, 'navigation'),
-        sessionSegments: sessionSegs,
       }
   }
 }
@@ -121,8 +135,8 @@ function deriveModalModeId(modalType: AppState['modal']['type']): ModeId | null
       return 'modal.help.filtering'
     case 'new-tab':
       return 'modal.new-tab.command-edit'
-    case 'session-picker':
-      return 'modal.session-picker.filtering'
+    case 'project-picker':
+      return 'modal.project-picker.filtering'
     case 'snippet-picker':
       return 'modal.snippet-picker.filtering'
     case 'split-picker':
@@ -131,10 +145,10 @@ function deriveModalModeId(modalType: AppState['modal']['type']): ModeId | null
       return 'modal.theme-picker.filtering'
     case 'update-available':
       return 'modal.update-available'
-    case 'worktree-move':
-      return 'modal.worktree-move'
-    case 'worktree-move-confirm':
-      return 'modal.worktree-move-confirm'
+    case 'workspace-move':
+      return 'modal.workspace-move'
+    case 'workspace-move-confirm':
+      return 'modal.workspace-move-confirm'
     default:
       return null
   }
@@ -142,20 +156,20 @@ function deriveModalModeId(modalType: AppState['modal']['type']): ModeId | null
 
 function deriveCommandEditModeId(modalType: AppState['modal']['type']): ModeId | null {
   switch (modalType) {
-    case 'create-session':
-      return 'modal.create-session'
+    case 'create-project':
+      return 'modal.create-project'
     case 'git-commit':
       return 'modal.git-commit'
     case 'new-tab':
       return 'modal.new-tab.command-edit'
     case 'rename-tab':
       return 'modal.rename-tab'
-    case 'rename-worktree':
-      return 'modal.rename-worktree'
-    case 'session-name':
-      return 'modal.session-name'
-    case 'session-picker':
-      return 'modal.session-picker.filtering'
+    case 'rename-workspace':
+      return 'modal.rename-workspace'
+    case 'project-name':
+      return 'modal.project-name'
+    case 'project-picker':
+      return 'modal.project-picker.filtering'
     case 'snippet-editor':
       return 'modal.snippet-editor'
     case 'snippet-picker':

package/src/ui/terminal-graphics/kitty.ts

@@ -16,7 +16,7 @@ let nextId = 0x100000
 
 export function nextImageId(): number {
   const id = nextId++
-  // Wrap at 24-bit; we don't expect to leak more than ~16M IDs per session but
+  // Wrap at 24-bit; we don't expect to leak more than ~16M IDs per project but
   // be safe in case of a long-running daemon.
   if (nextId > 0xffffff) nextId = 0x100000
   return id
@@ -46,10 +46,16 @@ function chunkString(s: string, size: number): string[] {
 
 // Build the upload escape(s) for a PNG (f=100) image. Chunked per Kitty spec
 // recommendation (≤ 4096 base64 bytes per escape).
+//
+// The upload is preceded by a delete of the same id. Images outlive the
+// process — they belong to the terminal window — and this process allocates
+// ids from a fixed base, so a previous run may have left this very id carrying
+// a *different* placement. An image with two virtual placements and nothing to
+// disambiguate them draws at whichever size the terminal happens to pick.
 export function uploadPngEscape(pngBytes: Uint8Array, id: number): string {
   const b64 = encodeBase64(pngBytes)
   const chunks = chunkString(b64, MAX_BASE64_CHUNK)
-  const parts: string[] = []
+  const parts: string[] = [`${ESC}_Ga=d,d=I,i=${id},q=2;${ST}`]
   for (let i = 0; i < chunks.length; i++) {
     const isLast = i === chunks.length - 1
     const m = isLast ? 0 : 1
@@ -60,6 +66,19 @@ export function uploadPngEscape(pngBytes: Uint8Array, id: number): string {
   return wrapForTmux(parts.join(''))
 }
 
+// A virtual placement (U=1) is not painted over the screen: the terminal
+// composites the image into whichever cells carry the Unicode placeholder,
+// which is what lets an image survive redraws the app makes on its own. `cols`
+// and `rows` size the placeholder box, and the image is scaled to fill it.
+//
+// Deliberately no source rectangle (`x`/`y`/`w`/`h`): terminals that speak the
+// rest of this protocol do not all honour it on a virtual placement, and one
+// that ignores it silently draws the whole image instead of the slice asked
+// for. Callers upload one image per frame.
+export function virtualPlacementEscape(id: number, cols: number, rows: number): string {
+  return wrapForTmux(`${ESC}_Ga=p,U=1,i=${id},c=${cols},r=${rows},q=2;${ST}`)
+}
+
 export function deleteImageEscape(id: number): string {
   return wrapForTmux(`${ESC}_Ga=d,d=I,i=${id},q=2;${ST}`)
 }
@@ -68,6 +87,13 @@ export function imageIdToRgb(id: number): [number, number, number] {
   return idToRgb(id)
 }
 
+// Same id, spelled the way a renderable's `fg` wants it. The colour is not a
+// colour here: it is what tells the terminal which image a placeholder cell
+// stands for, so it has to survive the round trip through the renderer intact.
+export function imageIdToHex(id: number): string {
+  return `#${(id & 0xffffff).toString(16).padStart(6, '0')}`
+}
+
 export function writeRaw(seq: string): void {
   // Synchronous write so we don't interleave with opentui frames.
   process.stdout.write(seq)

package/src/ui/terminal-graphics/sprites.ts

@@ -0,0 +1,246 @@
+// Activity sprites: a small animation per agent state, drawn where the sidebar
+// would otherwise put a spinner or a dot.
+//
+// Every frame is its own image, uploaded once and given a virtual placement, so
+// animating is nothing but changing the foreground colour of two cells — no
+// escape written per frame, and nothing an opentui redraw can wipe. One image
+// per frame rather than one sheet cropped per placement: the source rectangle
+// of a placement is not honoured by every terminal that speaks the protocol,
+// and a sheet placed without it draws all its frames at once.
+//
+// Naming carries everything, so there is no manifest to keep in step with the
+// files. Either form works:
+//   - a folder `<state>@<ms>/` of numbered PNGs, one per frame (`0.png`, `1.png`…)
+//   - a `<state>.gif`, which brings its own frames and delay, cut by ImageMagick
+
+import { readdir } from 'node:fs/promises'
+
+import { logDebug } from '../../debug/input-log'
+import { getProfileConfigDir } from '../../profile-paths'
+import {
+  imageIdToHex,
+  nextImageId,
+  uploadPngEscape,
+  virtualPlacementEscape,
+  writeRaw,
+} from './kitty'
+
+export const SPRITE_STATES = ['idle', 'working', 'waiting', 'done'] as const
+
+export type SpriteState = (typeof SPRITE_STATES)[number]
+
+export type SpriteSet = Partial<Record<SpriteState, Sprite>>
+
+export interface Sprite {
+  /**
+   * One entry per frame. Not a colour: it is the 24-bit id of the image the
+   * placeholder cells stand for, spelled the way a renderable's `fg` wants it.
+   */
+  colors: readonly string[]
+  frameMs: number
+}
+
+/**
+ * The one shape a sprite is ever placed into: the two lines of a workspace row,
+ * three cells across.
+ *
+ * Deliberately the only one. A frame gets a single image and a single placement,
+ * so a cell cannot resolve to a box other than the one it was drawn for. Earlier
+ * revisions placed each frame at several sizes for the different rows that
+ * wanted them, and sprites drew at the wrong size — three placements of visually
+ * identical images stacked in one column is a resolution the protocol gives no
+ * way to make unambiguous from a cell alone.
+ *
+ * Three cells across because the terminal fits an image to its box keeping the
+ * aspect ratio: for a roughly square frame in cells twice as tall as they are
+ * wide, the width is what caps the sprite, and two rows of height buy nothing
+ * under two cells of width.
+ */
+export const SPRITE_COLS = 3
+const SPRITE_ROWS = 2
+
+// Kitty encodes a placeholder cell's row and column as combining marks, the Nth
+// entry of the spec's table standing for N. Three of each is all this needs.
+const MARKS = ['̅', '̍', '̎'] as const
+const DEFAULT_FRAME_MS = 150
+const BUNDLED_DIR = `${import.meta.dir}/sprites`
+const FOLDER_NAME = /^(idle|working|waiting|done)@(\d+)$/
+const GIF_NAME = /^(idle|working|waiting|done)\.gif$/
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
+
+/** U+10EEEE, the Kitty placeholder. */
+const PLACEHOLDER = '\u{10EEEE}'
+
+/**
+ * The cells of a sprite, one string per line of its box, top line first.
+ *
+ * Every cell names the row and the column it stands for, always — never a bare
+ * placeholder left for the terminal to work out. Its rule for an unmarked cell
+ * looks up as well as left: a placeholder sitting directly below another of the
+ * same image reads as the next row down. A sidebar is a column of rows drawing
+ * the same idle sprite, so each one would inherit the position of the row above
+ * it and draw a slice of the image rather than the image.
+ *
+ * The marks are zero-width, so a line is exactly `SPRITE_COLS` columns wide.
+ */
+function placeholderLines(): string[] {
+  return Array.from({ length: SPRITE_ROWS }, (_, row) => {
+    const rowMark = MARKS[row] ?? MARKS[0]
+    let line = ''
+    for (let col = 0; col < SPRITE_COLS; col++) {
+      line += `${PLACEHOLDER}${rowMark}${MARKS[col] ?? MARKS[0]}`
+    }
+    return line
+  })
+}
+
+/** Resolved once: the same two strings every row of the sidebar draws. */
+export const SPRITE_PLACEHOLDERS: readonly string[] = placeholderLines()
+
+/** Where a user drops their own sprites. Anything here beats what aimux ships. */
+export function userSpriteDir(): string {
+  return `${getProfileConfigDir()}/sprites`
+}
+
+export interface SpriteName {
+  frameMs: number
+  /** True when the frames come from a GIF and only ImageMagick can read them. */
+  gif: boolean
+  state: SpriteState
+}
+
+/**
+ * What an entry in a sprite folder declares, or null when it declares nothing —
+ * the folder is the user's, and a stray screenshot in it is not a configuration
+ * error.
+ */
+export function parseSpriteName(entry: string): SpriteName | null {
+  const folder = FOLDER_NAME.exec(entry)
+  if (folder) {
+    const ms = Number.parseInt(folder[2] ?? '', 10)
+    return {
+      frameMs: Number.isFinite(ms) && ms > 0 ? ms : DEFAULT_FRAME_MS,
+      gif: false,
+      state: folder[1] as SpriteState,
+    }
+  }
+  const gif = GIF_NAME.exec(entry)
+  if (gif === null) return null
+  return { frameMs: DEFAULT_FRAME_MS, gif: true, state: gif[1] as SpriteState }
+}
+
+interface Frames {
+  frameMs: number
+  pngs: Uint8Array[]
+}
+
+async function runMagick(args: string[], timeoutMs: number): Promise<Uint8Array | null> {
+  for (const bin of ['magick', 'convert']) {
+    try {
+      const proc = Bun.spawn([bin, ...args], { stderr: 'ignore', stdin: 'ignore', stdout: 'pipe' })
+      const timer = setTimeout(() => proc.kill(), timeoutMs)
+      const [out, code] = await Promise.all([new Response(proc.stdout).bytes(), proc.exited])
+      clearTimeout(timer)
+      if (code === 0 && out.byteLength > 0) return out
+    } catch {
+      // Next binary, then give up: a missing ImageMagick is not an error, it
+      // only means GIF sprites are unavailable.
+    }
+  }
+  return null
+}
+
+/**
+ * ImageMagick writes one PNG per frame back to back on stdout. They are split on
+ * the signature rather than counted, so a frame count that disagrees with the
+ * stream cannot desynchronise the two.
+ */
+function splitPngs(bytes: Uint8Array): Uint8Array[] {
+  const starts: number[] = []
+  for (let i = 0; i + PNG_SIGNATURE.length <= bytes.length; i++) {
+    if (PNG_SIGNATURE.every((byte, k) => bytes[i + k] === byte)) starts.push(i)
+  }
+  return starts.map((start, i) => bytes.subarray(start, starts[i + 1] ?? bytes.length))
+}
+
+/** A GIF's own frame count and delay are authoritative, so it names neither. */
+async function gifFrames(path: string): Promise<Frames | null> {
+  const pngs = splitPngs((await runMagick([path, '-coalesce', 'png:-'], 5000)) ?? new Uint8Array())
+  if (pngs.length === 0) return null
+  const meta = await runMagick(['identify', '-format', '%T\\n', path], 2000)
+  const ticks = Number.parseInt(new TextDecoder().decode(meta ?? new Uint8Array()), 10)
+  // GIF delays are in hundredths of a second, and 0 is the "as fast as you can"
+  // some encoders write — which at this size would be a strobe.
+  const frameMs = Number.isFinite(ticks) && ticks > 0 ? ticks * 10 : DEFAULT_FRAME_MS
+  return { frameMs, pngs }
+}
+
+/** Frames in numeric order — `10.png` follows `9.png`, it does not precede it. */
+async function folderFrames(dir: string, frameMs: number): Promise<Frames | null> {
+  const files = (await readdir(dir))
+    .filter((file) => file.endsWith('.png'))
+    .sort((a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10))
+  if (files.length === 0) return null
+  return {
+    frameMs,
+    pngs: await Promise.all(files.map(async (file) => Bun.file(`${dir}/${file}`).bytes())),
+  }
+}
+
+/** Every sprite a directory declares, keyed by the state it stands for. */
+async function scanDir(dir: string): Promise<Map<SpriteState, Frames>> {
+  const found = new Map<SpriteState, Frames>()
+  let entries: string[]
+  try {
+    entries = await readdir(dir)
+  } catch {
+    return found
+  }
+
+  for (const entry of entries.sort()) {
+    const name = parseSpriteName(entry)
+    if (name === null) continue
+    const frames = name.gif
+      ? await gifFrames(`${dir}/${entry}`)
+      : await folderFrames(`${dir}/${entry}`, name.frameMs)
+    if (frames) found.set(name.state, frames)
+    else if (name.gif) {
+      logDebug('sprites.gif.failed', { entry, reason: 'ImageMagick unavailable or failed' })
+    }
+  }
+  return found
+}
+
+function upload(frames: Frames): Sprite {
+  const colors = frames.pngs.map((png) => {
+    const id = nextImageId()
+    writeRaw(uploadPngEscape(png, id) + virtualPlacementEscape(id, SPRITE_COLS, SPRITE_ROWS))
+    return imageIdToHex(id)
+  })
+  return { colors, frameMs: Math.max(16, frames.frameMs) }
+}
+
+async function loadAll(): Promise<SpriteSet> {
+  // The user's folder is scanned second so a state it declares replaces the one
+  // aimux ships, rather than being merged with it.
+  const found = new Map([...(await scanDir(BUNDLED_DIR)), ...(await scanDir(userSpriteDir()))])
+  const set: SpriteSet = {}
+  for (const [state, frames] of found) set[state] = upload(frames)
+  return set
+}
+
+let loaded: Promise<SpriteSet> | null = null
+
+/**
+ * Uploaded once per process — every row animates off the same images. Read from
+ * disk at first use, so a sprite dropped into the folder appears at the next
+ * launch, not mid-session.
+ */
+export async function loadSprites(): Promise<SpriteSet> {
+  loaded ??= loadAll()
+  try {
+    return await loaded
+  } catch {
+    return {}
+  }
+}

package/src/ui/truncate.ts

@@ -0,0 +1,7 @@
+/** Fit a label into `max` columns, marking the cut with an ellipsis. */
+export function truncate(label: string, max: number): string {
+  if (max <= 0) return ''
+  if (label.length <= max) return label
+  if (max === 1) return '…'
+  return `${label.slice(0, max - 1)}…`
+}

package/src/ui/widgets/registry.tsx

@@ -1,7 +1,8 @@
 import type { ReactNode } from 'react'
 
 import { GitPaneWidget } from '../components/git/pane/git-pane-widget'
-import { WorkspaceList } from '../components/layout/sidebar/workspace-list'
+import { ProjectList } from '../components/layout/sidebar/project-list'
+import { SetupWidget } from '../components/setup/setup-widget'
 
 /**
  * Everything a bar can host. Adding a widget = one entry here plus its id in
@@ -9,10 +10,12 @@ import { WorkspaceList } from '../components/layout/sidebar/workspace-list'
  */
 export const WIDGET_RENDERERS: Record<string, (contentWidth: number) => ReactNode> = {
   git: (contentWidth) => <GitPaneWidget contentWidth={contentWidth} pollingEnabled />,
-  workspaces: (contentWidth) => <WorkspaceList contentWidth={contentWidth} />,
+  projects: (contentWidth) => <ProjectList contentWidth={contentWidth} />,
+  setup: () => <SetupWidget />,
 }
 
 export const WIDGET_LABELS: Record<string, string> = {
   git: 'Git',
-  workspaces: 'Workspaces',
+  projects: 'Projects',
+  setup: 'Setup',
 }

package/src/ui/widgets/widget-context-menu.ts

@@ -5,9 +5,30 @@ import { visibleWidgets } from '../../state/bars'
 import { dispatchGlobal } from '../../state/dispatch-ref'
 import { WIDGET_LABELS } from './registry'
 
+/** `Show <label>` for every hidden widget in either bar. */
+function showHiddenItems(bars: BarsState): ContextMenuItem[] {
+  const items: ContextMenuItem[] = []
+  for (const side of ['left', 'right'] as const) {
+    for (const widget of bars[side].widgets) {
+      if (widget.visible) continue
+      items.push([
+        `Show ${WIDGET_LABELS[widget.id] ?? widget.id}`,
+        () => dispatchGlobal({ type: 'toggle-widget', widgetId: widget.id }),
+      ])
+    }
+  }
+  return items
+}
+
 /**
  * Right-click menu for a widget hosted in a bar: move it across, reorder it
- * within its bar, or hide it. Generic — a new widget gets this for free.
+ * within its bar, hide it, or bring back one that is hidden. Generic — a new
+ * widget gets this for free.
+ *
+ * The unhide entries live here and not only on the bar's own menu because the
+ * bar's menu is unreachable: widget slots cover the whole body and stop
+ * right-click propagation, and the edge and boundary handles swallow every
+ * button. Without this, hiding a widget is a one-way door for a mouse user.
  */
 export function buildWidgetContextMenu(
   bars: BarsState,
@@ -50,20 +71,15 @@ export function buildWidgetContextMenu(
   if (visibleWidgets(bars[side]).length > 1) {
     items.push(['Hide', () => dispatchGlobal({ type: 'toggle-widget', widgetId })])
   }
+
+  items.push(...showHiddenItems(bars))
   return items
 }
 
 /** Menu for the bar itself. Offers a way back for every hidden widget. */
 export function buildBarContextMenu(bars: BarsState, side: BarSide): ContextMenuItem[] {
-  const items: ContextMenuItem[] = [
+  return [
     [`Hide ${side} bar`, () => dispatchGlobal({ side, type: 'toggle-bar' })],
+    ...showHiddenItems(bars),
   ]
-  for (const widget of bars[side].widgets) {
-    if (widget.visible) continue
-    items.push([
-      `Show ${WIDGET_LABELS[widget.id] ?? widget.id}`,
-      () => dispatchGlobal({ type: 'toggle-widget', widgetId: widget.id }),
-    ])
-  }
-  return items
 }

package/src/update.ts

@@ -60,7 +60,7 @@ export async function runUpdate(): Promise<number> {
   }
 
   // The terminal-manager is intentionally NOT restarted here: doing so kills
-  // live AI sessions. The flip side: the running TM keeps executing the
+  // live AI projects. The flip side: the running TM keeps executing the
   // previous version's code path, so any TM-side fix (perf, lifecycle) only
   // takes effect after a manual restart. Surface that explicitly so users
   // aren't silently stuck on stale behaviour.
@@ -73,7 +73,7 @@ export async function runUpdate(): Promise<number> {
         'TM-side fixes in this update apply to new TMs only — the running one',
         'keeps its old behaviour until restarted.',
         'Run `aimux restart-terminal-manager` when you can afford to lose your',
-        'current PTY sessions to upgrade it.',
+        'current PTY projects to upgrade it.',
         '',
       ].join('\n')
     )