@brimveyn/aimux 1.19.2 → 1.19.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.19.2",
+  "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
+}