@brimveyn/aimux 1.19.1 → 1.19.3

package/package.json

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

package/src/cli/commands/tab/create.ts

@@ -7,7 +7,11 @@ import {
   IPC_CAPABILITY_THIN_ATTACH,
 } from '../../../ipc/protocol'
 import { createPrefixedId } from '../../../platform/id'
-import { getAllAssistantOptions, parseCommand } from '../../../pty/command-registry'
+import {
+  buildAssistantModelArgs,
+  getAllAssistantOptions,
+  parseCommand,
+} from '../../../pty/command-registry'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
@@ -30,6 +34,16 @@ export const tabCreate: CliCommand = {
       kind: 'string',
       name: 'command',
     },
+    {
+      description: 'model for the worker (maps to the assistant’s model flag)',
+      kind: 'string',
+      name: 'model',
+    },
+    {
+      description: 'reasoning-effort level (maps to the assistant’s effort flag)',
+      kind: 'string',
+      name: 'effort',
+    },
     {
       description: 'worktree id the tab belongs to (defaults to the workspace’s active worktree)',
       kind: 'string',
@@ -49,8 +63,21 @@ export const tabCreate: CliCommand = {
         `unknown assistant: ${assistantId} (known: ${options.map((o) => o.id).join(', ')})`
       )
     }
-    const command =
-      typeof ctx.args.flags.command === 'string' ? ctx.args.flags.command : option.command
+    const commandOverride =
+      typeof ctx.args.flags.command === 'string' ? ctx.args.flags.command : undefined
+    const model = typeof ctx.args.flags.model === 'string' ? ctx.args.flags.model : undefined
+    const effort = typeof ctx.args.flags.effort === 'string' ? ctx.args.flags.effort : undefined
+
+    // A full `--command` override owns the whole invocation, so `--model` /
+    // `--effort` (which only make sense as additions to the assistant default)
+    // would be ambiguous alongside it — reject rather than silently drop them.
+    if (commandOverride !== undefined && (model !== undefined || effort !== undefined)) {
+      throw new Error(
+        '--model / --effort cannot be combined with --command (bake them into --command)'
+      )
+    }
+
+    const command = commandOverride ?? option.command
     const title = typeof ctx.args.flags.title === 'string' ? ctx.args.flags.title : option.label
     const cwdRaw = typeof ctx.args.flags.cwd === 'string' ? ctx.args.flags.cwd : undefined
     const cwd = cwdRaw === undefined ? undefined : resolvePath(cwdRaw)
@@ -81,7 +108,11 @@ export const tabCreate: CliCommand = {
     // Thin-attach so we don't clobber the UI's dimensions on the same session.
     await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
 
-    const { args, executable } = parseCommand(command)
+    const { args: baseArgs, executable } = parseCommand(command)
+    // Append the model/effort flags to the assistant default. Throws if the
+    // assistant has no control for a requested dimension.
+    const modelArgs = buildAssistantModelArgs(option, { effort, model })
+    const args = [...baseArgs, ...modelArgs]
     const tabId = createPrefixedId('tab')
 
     // cols/rows = 0 means "fall back to the session's last attached size" on
@@ -101,7 +132,16 @@ export const tabCreate: CliCommand = {
       worktreeId,
     })
 
-    writeJson({ assistant: assistantId, command, tabId, title, worktreeId })
+    const resolvedCommand = [executable, ...args].join(' ')
+    writeJson({
+      assistant: assistantId,
+      command: resolvedCommand,
+      effort: effort ?? null,
+      model: model ?? null,
+      tabId,
+      title,
+      worktreeId,
+    })
     return EXIT_OK
   },
   summary: 'Create a new tab in the active workspace',

package/src/cli/commands/worktree/list.ts

@@ -1,6 +1,7 @@
 import type { CliCommand } from '../../registry'
 
 import { listGitWorktrees } from '../../../git/worktree'
+import { IPC_CAPABILITY_LIST_TABS } from '../../../ipc/protocol'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
@@ -12,6 +13,28 @@ export const worktreeList: CliCommand = {
     const workspace = ctx.getWorkspace()
     const records = workspace.worktrees ?? []
 
+    // Count live tabs per worktree so an orchestrator can see co-location
+    // (several workers sharing one worktree) at a glance. Best-effort: `null`
+    // when the daemon is unreachable or predates the listTabs capability —
+    // `worktree list` otherwise reads purely from the catalog + git, so we don't
+    // want a down daemon to fail it.
+    const tabCounts = new Map<string, number>()
+    let tabCountsAvailable = false
+    try {
+      const daemon = await ctx.getDaemon()
+      if (daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
+        const { tabs } = await daemon.listTabs(workspace.id)
+        for (const tab of tabs) {
+          if (tab.worktreeId != null) {
+            tabCounts.set(tab.worktreeId, (tabCounts.get(tab.worktreeId) ?? 0) + 1)
+          }
+        }
+        tabCountsAvailable = true
+      }
+    } catch {
+      // daemon unreachable — leave tabCount null rather than failing the list.
+    }
+
     // Cross-check against git so we can flag catalog entries that git no
     // longer knows about (prunable / vanished) — otherwise the CLI would
     // happily report worktrees that don't exist on disk.
@@ -35,6 +58,7 @@ export const worktreeList: CliCommand = {
         path: w.path,
         repoRoot: w.repoRoot,
         source: w.source,
+        tabCount: tabCountsAvailable ? (tabCounts.get(w.id) ?? 0) : null,
       })),
     })
     return EXIT_OK

package/src/pty/command-registry.ts

@@ -1,10 +1,27 @@
 import type { AssistantId } from '../state/types'
 
+/**
+ * How an assistant renders a vendor-neutral model / reasoning-effort selection
+ * into its own CLI args. Vendor flag syntax lives here on the assistant
+ * definition — the source of truth — rather than in a separate resolver, so
+ * there's exactly one place that knows `claude` takes `--effort` while `codex`
+ * takes `-c model_reasoning_effort=…`. An absent builder means the CLI has no
+ * control for that dimension, and passing `--model` / `--effort` for it is an
+ * error (see `buildAssistantModelArgs`). Values themselves are passed through
+ * unvalidated: the worker CLI is the source of truth for its own vocabulary and
+ * rejects a bad value with its own clear startup error.
+ */
+export interface AssistantModelSpec {
+  buildModelArgs?: (model: string) => string[]
+  buildEffortArgs?: (effort: string) => string[]
+}
+
 export interface AssistantOption {
   id: AssistantId
   label: string
   command: string
   description: string
+  model?: AssistantModelSpec
 }
 
 const DEFAULT_SHELL =
@@ -17,18 +34,30 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
     description: 'Anthropic Claude CLI',
     id: 'claude',
     label: 'Claude',
+    model: {
+      buildEffortArgs: (effort) => ['--effort', effort],
+      buildModelArgs: (model) => ['--model', model],
+    },
   },
   {
     command: 'codex',
     description: 'OpenAI Codex CLI',
     id: 'codex',
     label: 'Codex',
+    model: {
+      buildEffortArgs: (effort) => ['-c', `model_reasoning_effort=${effort}`],
+      buildModelArgs: (model) => ['--model', model],
+    },
   },
   {
     command: 'opencode',
     description: 'OpenCode CLI',
     id: 'opencode',
     label: 'OpenCode',
+    // OpenCode takes a `provider/model` selector but has no reasoning-effort flag.
+    model: {
+      buildModelArgs: (model) => ['--model', model],
+    },
   },
   {
     command: 'agy',
@@ -74,3 +103,34 @@ export function parseCommand(commandString: string): { executable: string; args:
   const parts = commandString.trim().split(/\s+/).filter(Boolean)
   return { args: parts.slice(1), executable: parts[0] ?? '' }
 }
+
+/**
+ * Translate a vendor-neutral `{ model, effort }` selection into the extra CLI
+ * args to append to an assistant's default command. Throws if the assistant has
+ * no control for a requested dimension (e.g. `--effort` on OpenCode, anything on
+ * `terminal`) — that combination is unrepresentable, so we fail at the CLI
+ * boundary rather than spawn a worker that silently ignores the request.
+ */
+export function buildAssistantModelArgs(
+  option: AssistantOption,
+  selection: { model?: string; effort?: string }
+): string[] {
+  const args: string[] = []
+  const { effort, model } = selection
+
+  if (model !== undefined && model !== '') {
+    if (!option.model?.buildModelArgs) {
+      throw new Error(`assistant '${option.id}' does not support --model`)
+    }
+    args.push(...option.model.buildModelArgs(model))
+  }
+
+  if (effort !== undefined && effort !== '') {
+    if (!option.model?.buildEffortArgs) {
+      throw new Error(`assistant '${option.id}' does not support --effort`)
+    }
+    args.push(...option.model.buildEffortArgs(effort))
+  }
+
+  return args
+}

package/src/ui/components/modals/shared/modal-keybinds-overlay.tsx

@@ -1,32 +1,12 @@
 import type { ModeId } from '@brimveyn/aimux-config'
 
-import { type BoxRenderable, type OptimizedBuffer, RGBA } from '@opentui/core'
-
 import { describeBindings } from '../../../../input/keymap/describe-bindings'
 import { useKeymap } from '../../../keymap-context'
 import { useTheme, useTransparent } from '../../../theme'
+import { fillBoxInterior } from '../../../transparent-fill'
 
 const KEYS_COLUMN_WIDTH = 12
 
-const TRANSPARENT_RGBA = RGBA.fromValues(0, 0, 0, 0)
-
-// Same trick as modal-shell: when our bg is transparent, BoxRenderable skips
-// its fill so the chrome chars underneath leak through. setCell bypasses alpha
-// blending and char-preservation, so we can wipe every interior cell to
-// (' ', TRANSPARENT_RGBA, TRANSPARENT_RGBA). No border on this overlay, so
-// fill the full bounds (no 1-cell inset).
-function fillBoxInteriorWithSpaces(this: BoxRenderable, buffer: OptimizedBuffer): void {
-  const x0 = this.screenX
-  const y0 = this.screenY
-  const endX = x0 + this.width
-  const endY = y0 + this.height
-  for (let y = y0; y < endY; y++) {
-    for (let x = x0; x < endX; x++) {
-      buffer.setCell(x, y, ' ', TRANSPARENT_RGBA, TRANSPARENT_RGBA)
-    }
-  }
-}
-
 interface ModalKeybindsOverlayProps {
   modeId: ModeId
   limit?: number
@@ -52,7 +32,7 @@ export function ModalKeybindsOverlay({ limit, modeId }: ModalKeybindsOverlayProp
         paddingRight={2}
         paddingTop={1}
         paddingBottom={1}
-        renderAfter={transparent ? fillBoxInteriorWithSpaces : undefined}
+        renderAfter={transparent ? fillBoxInterior : undefined}
       >
         {entries.map((binding) => (
           <box key={binding.description ?? binding.keys} flexDirection="row">

package/src/ui/components/modals/shared/modal-shell.tsx

@@ -1,9 +1,8 @@
 import type { ModeId } from '@brimveyn/aimux-config'
 import type { ReactNode } from 'react'
 
-import { type BoxRenderable, type OptimizedBuffer, RGBA } from '@opentui/core'
-
 import { useTheme, useTransparent } from '../../../theme'
+import { fillBorderedBoxInterior } from '../../../transparent-fill'
 import { ModalKeybindsOverlay } from './modal-keybinds-overlay'
 
 interface ModalShellProps {
@@ -16,38 +15,6 @@ interface ModalShellProps {
   width: number | `${number}%`
 }
 
-const TRANSPARENT_RGBA = RGBA.fromValues(0, 0, 0, 0)
-
-// opentui's BoxRenderable only paints a fill when `backgroundColor.a > 0`, so
-// a fully transparent modal bg leaks the chrome characters underneath. The
-// `renderAfter` hook runs after the box paints itself but before its children
-// render, so we manually overwrite every interior cell with a blank space.
-//
-// Two gotchas we hit by reading the zig source (packages/core/src/zig/buffer.zig):
-//  1. `setCellWithAlphaBlending` early-returns via `isFullyTransparent` when
-//     both fg and bg alpha are 0 — nothing gets written.
-//  2. Its `blendCells` deliberately preserves the destination char when the
-//     overlay char is `DEFAULT_SPACE_CHAR` (codepoint 32) so that drawing a
-//     space on top of existing text does not erase it.
-//
-// `setCell` (→ `bufferSetCell` → zig `buffer.set`) bypasses both: it writes
-// the cell unconditionally, no alpha check, no blending, no char preservation.
-function fillModalInteriorWithSpaces(this: BoxRenderable, buffer: OptimizedBuffer): void {
-  const x0 = this.screenX
-  const y0 = this.screenY
-  const w = this.width
-  const h = this.height
-  const startX = x0 + 1
-  const startY = y0 + 1
-  const endX = x0 + w - 1
-  const endY = y0 + h - 1
-  for (let y = startY; y < endY; y++) {
-    for (let x = startX; x < endX; x++) {
-      buffer.setCell(x, y, ' ', TRANSPARENT_RGBA, TRANSPARENT_RGBA)
-    }
-  }
-}
-
 export function ModalShell({
   children,
   footer,
@@ -76,7 +43,7 @@ export function ModalShell({
         backgroundColor={bg}
         padding={1}
         width={width}
-        renderAfter={transparent ? fillModalInteriorWithSpaces : undefined}
+        renderAfter={transparent ? fillBorderedBoxInterior : undefined}
       >
         <box width="100%" flexDirection="column" gap={listGap}>
           <box flexDirection="column">

package/src/ui/components/overlays/context-menu/context-menu-overlay.tsx

@@ -9,7 +9,8 @@ import {
   type ContextMenuState,
   subscribeContextMenu,
 } from '../../../context-menu/controller'
-import { useTheme } from '../../../theme'
+import { useTheme, useTransparent } from '../../../theme'
+import { fillBorderedBoxInterior } from '../../../transparent-fill'
 
 const MenuItem = memo(function MenuItem({
   active,
@@ -59,6 +60,7 @@ export function ContextMenuOverlay() {
   const [menu, setMenu] = useState<ContextMenuState | null>(null)
   const [selected, setSelected] = useState(0)
   const t = useTheme()
+  const transparent = useTransparent()
   const terminalCols = useAppStore((s) => s.layout.terminalCols)
   const terminalRows = useAppStore((s) => s.layout.terminalRows)
 
@@ -131,7 +133,8 @@ export function ContextMenuOverlay() {
         flexDirection="column"
         border
         borderColor={t.border}
-        backgroundColor={t.backgroundPanel}
+        backgroundColor={transparent ? 'transparent' : t.backgroundPanel}
+        renderAfter={transparent ? fillBorderedBoxInterior : undefined}
         onMouseDown={handleMenuMouseDown}
       >
         {menu.items.map(([label, onSelect], index) => (

package/src/ui/transparent-fill.ts

@@ -0,0 +1,49 @@
+import { type BoxRenderable, type OptimizedBuffer, RGBA } from '@opentui/core'
+
+export const TRANSPARENT_RGBA = RGBA.fromValues(0, 0, 0, 0)
+
+// opentui's BoxRenderable only paints a fill when `backgroundColor.a > 0`, so
+// a fully transparent bg leaks the chrome characters underneath. These helpers
+// run from a box's `renderAfter` hook (after the box paints itself, before its
+// children render) and manually overwrite every interior cell with a blank
+// space so the region reads as "emptied" instead of leaking.
+//
+// Two gotchas we hit by reading the zig source (packages/core/src/zig/buffer.zig):
+//  1. `setCellWithAlphaBlending` early-returns via `isFullyTransparent` when
+//     both fg and bg alpha are 0 — nothing gets written.
+//  2. Its `blendCells` deliberately preserves the destination char when the
+//     overlay char is `DEFAULT_SPACE_CHAR` (codepoint 32) so that drawing a
+//     space on top of existing text does not erase it.
+//
+// `setCell` (→ `bufferSetCell` → zig `buffer.set`) bypasses both: it writes
+// the cell unconditionally, no alpha check, no blending, no char preservation.
+
+// Bordered boxes: inset by 1 cell so the painted border is preserved.
+export function fillBorderedBoxInterior(this: BoxRenderable, buffer: OptimizedBuffer): void {
+  const x0 = this.screenX
+  const y0 = this.screenY
+  const w = this.width
+  const h = this.height
+  const startX = x0 + 1
+  const startY = y0 + 1
+  const endX = x0 + w - 1
+  const endY = y0 + h - 1
+  for (let y = startY; y < endY; y++) {
+    for (let x = startX; x < endX; x++) {
+      buffer.setCell(x, y, ' ', TRANSPARENT_RGBA, TRANSPARENT_RGBA)
+    }
+  }
+}
+
+// Borderless boxes: fill the full bounds (no inset).
+export function fillBoxInterior(this: BoxRenderable, buffer: OptimizedBuffer): void {
+  const x0 = this.screenX
+  const y0 = this.screenY
+  const endX = x0 + this.width
+  const endY = y0 + this.height
+  for (let y = y0; y < endY; y++) {
+    for (let x = x0; x < endX; x++) {
+      buffer.setCell(x, y, ' ', TRANSPARENT_RGBA, TRANSPARENT_RGBA)
+    }
+  }
+}