@brimveyn/aimux 1.20.2 → 1.20.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.20.2",
+  "version": "1.20.3",
   "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/auto-rename/coordinator.ts

@@ -1,13 +1,18 @@
 import type { AssistantId } from '../state/types'
 
 import { isSupportedProvider } from '../auto-commit/headless-commands'
+import { heuristicTitle } from './heuristic-title'
 import { PromptCapture } from './prompt-capture'
+import { classifyPrompt } from './prompt-gate'
 import { generateTabTitle, type TitleSpawnFn } from './title-runner'
 
 export interface AutoRenameConfigSnapshot {
   enabled: boolean
   timeoutMs: number
   models: Partial<Record<string, string>>
+  settleMs?: number
+  maxAttempts?: number
+  minPromptWords?: number
 }
 
 export interface AutoRenameTab {
@@ -27,6 +32,35 @@ export interface AutoRenameCoordinatorOptions {
   spawn?: TitleSpawnFn
 }
 
+const DEFAULT_SETTLE_MS = 2_500
+const DEFAULT_MAX_ATTEMPTS = 3
+const DEFAULT_MIN_PROMPT_WORDS = 3
+/** Opening prompts folded into one title request. */
+const MAX_PENDING_PROMPTS = 3
+/** Headless CLIs running at once, so opening a burst of tabs does not fork one per tab. */
+const MAX_CONCURRENT_GENERATIONS = 2
+
+interface TabRenameState {
+  capture: PromptCapture
+  /** Title-worthy prompts collected for the next generation, oldest first. */
+  prompts: string[]
+  /** First title-worthy prompt seen, kept as the source for the local fallback. */
+  firstPrompt: string | null
+  attempts: number
+  settleTimer: ReturnType<typeof setTimeout> | null
+  controller: AbortController | null
+  /**
+   * True once a provider hook delivered a real prompt. Hook payloads are ground
+   * truth — dialog keystrokes never reach them — so keystroke reconstruction is
+   * ignored from then on.
+   */
+  hookDriven: boolean
+}
+
+function normalize(text: string): string {
+  return text.replaceAll(/\s+/gu, ' ').trim().toLowerCase()
+}
+
 export function initialAutoRenameStatus(
   config: AutoRenameConfigSnapshot,
   assistant: AssistantId,
@@ -35,63 +69,203 @@ export function initialAutoRenameStatus(
   return config.enabled && candidate && isSupportedProvider(assistant) ? 'eligible' : undefined
 }
 
+/**
+ * Owns the "name this tab after what it is doing" behaviour.
+ *
+ * Two properties drive the design:
+ *
+ * - A tab only leaves `eligible` on success, on an exhausted attempt budget, or
+ *   on a manual rename. Anything transient — an unreadable keystroke stream, a
+ *   failed CLI, a timeout — leaves the tab armed for the next prompt, so a tab
+ *   never gets stuck on its assistant label because of one bad submission.
+ * - Nothing is titled from a prompt that carries no intent, and a prompt that
+ *   does starts a settle window rather than an immediate request, so a rapid
+ *   multi-message opening produces one title from the whole opening.
+ */
 export class AutoRenameCoordinator {
-  private readonly captures = new Map<string, PromptCapture>()
-  private readonly controllers = new Map<string, AbortController>()
+  private readonly states = new Map<string, TabRenameState>()
+  private running = 0
+  private readonly waiting: (() => void)[] = []
 
   constructor(private readonly options: AutoRenameCoordinatorOptions) {}
 
   register(tab: AutoRenameTab): void {
-    if (tab.autoRenameStatus === 'eligible' && !this.captures.has(tab.id)) {
-      this.captures.set(tab.id, new PromptCapture())
+    if (tab.autoRenameStatus === 'eligible' && !this.states.has(tab.id)) {
+      this.states.set(tab.id, createState())
     }
   }
 
   unregister(tabId: string): void {
-    this.controllers.get(tabId)?.abort()
-    this.controllers.delete(tabId)
-    this.captures.delete(tabId)
+    const state = this.states.get(tabId)
+    if (!state) return
+    state.controller?.abort()
+    if (state.settleTimer) clearTimeout(state.settleTimer)
+    this.states.delete(tabId)
   }
 
   manualRename(tabId: string): void {
     this.unregister(tabId)
   }
 
+  /** Keystroke fallback: reconstruct submissions from the bytes written to the PTY. */
   observeWrite(tabId: string, input: string): void {
-    const tab = this.options.getTab(tabId)
-    if (!tab || tab.autoRenameStatus !== 'eligible') return
-    let capture = this.captures.get(tabId)
-    if (!capture) {
-      capture = new PromptCapture()
-      this.captures.set(tabId, capture)
-    }
-    const result = capture.feed(input)
+    const tab = this.eligibleTab(tabId)
+    if (!tab) return
+    const state = this.ensureState(tabId)
+    if (state.hookDriven) return
+
+    const result = state.capture.feed(input)
     if (result.type === 'pending') return
+    // A submission we could not reconstruct faithfully is dropped, not counted:
+    // history recall, Tab completion and unknown escapes must not cost the tab
+    // its only chance at a name.
+    if (result.prompt === null) return
+    this.acceptPrompt(tabId, state, result.prompt)
+  }
+
+  /**
+   * Ground truth from a provider hook (Claude's `UserPromptSubmit`): the exact
+   * prompt text, delivered only for real submissions.
+   */
+  observePrompt(tabId: string, prompt: string): void {
+    const tab = this.eligibleTab(tabId)
+    if (!tab) return
+    const state = this.ensureState(tabId)
+    if (!state.hookDriven) {
+      state.hookDriven = true
+      state.capture.reset()
+    }
+    this.acceptPrompt(tabId, state, prompt)
+  }
+
+  private eligibleTab(tabId: string): AutoRenameTab | undefined {
+    const tab = this.options.getTab(tabId)
+    return tab?.autoRenameStatus === 'eligible' ? tab : undefined
+  }
+
+  private ensureState(tabId: string): TabRenameState {
+    const existing = this.states.get(tabId)
+    if (existing) return existing
+    const created = createState()
+    this.states.set(tabId, created)
+    return created
+  }
+
+  private acceptPrompt(tabId: string, state: TabRenameState, prompt: string): void {
+    const minWords = this.options.config.minPromptWords ?? DEFAULT_MIN_PROMPT_WORDS
+    if (classifyPrompt(prompt, minWords) === 'skip') return
+
+    state.firstPrompt ??= prompt
+    appendPrompt(state, prompt)
+    // A generation already in flight covers this prompt's window; a settled
+    // title is never rewritten.
+    if (state.controller) return
+    this.scheduleGeneration(tabId, state)
+  }
+
+  private scheduleGeneration(tabId: string, state: TabRenameState): void {
+    if (state.settleTimer) clearTimeout(state.settleTimer)
+    const settleMs = this.options.config.settleMs ?? DEFAULT_SETTLE_MS
+    const timer = setTimeout(() => {
+      state.settleTimer = null
+      void this.generate(tabId, state)
+    }, settleMs)
+    // Never hold the process open for a pending title.
+    timer.unref?.()
+    state.settleTimer = timer
+  }
+
+  private async generate(tabId: string, state: TabRenameState): Promise<void> {
+    const tab = this.eligibleTab(tabId)
+    if (!tab || this.states.get(tabId) !== state || state.prompts.length === 0) return
 
-    this.captures.delete(tabId)
-    this.options.updateTab(tabId, { autoRenameStatus: 'attempted' })
-    const prompt = result.prompt
-    if (prompt === null) return
     const controller = new AbortController()
-    this.controllers.set(tabId, controller)
-    const originalTitle = tab.title
+    state.controller = controller
+    state.attempts++
 
-    void (async () => {
-      const title = await generateTabTitle({
-        firstPrompt: prompt,
+    const release = await this.acquireSlot()
+    let result: Awaited<ReturnType<typeof generateTabTitle>>
+    try {
+      // The tab may have been closed or renamed while queued behind another
+      // generation; drop out before spending a process on it.
+      if (this.states.get(tabId) !== state || controller.signal.aborted) return
+      result = await generateTabTitle({
+        firstPrompt: state.prompts.join('\n\n'),
         model: this.options.config.models[tab.assistant],
         provider: tab.assistant,
         signal: controller.signal,
         spawn: this.options.spawn,
         timeoutMs: this.options.config.timeoutMs,
       })
-      if (this.controllers.get(tabId) !== controller) return
-      this.controllers.delete(tabId)
-      if (title == null || title === '') return
-      const current = this.options.getTab(tabId)
-      if (!current || current.autoRenameStatus !== 'attempted' || current.title !== originalTitle)
-        return
-      this.options.updateTab(tabId, { autoRenameStatus: 'attempted', title })
-    })()
+    } finally {
+      release()
+    }
+
+    if (this.states.get(tabId) !== state) return
+    state.controller = null
+
+    if (result.status === 'ok') {
+      this.finish(tabId, result.title)
+      return
+    }
+
+    const maxAttempts = this.options.config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS
+    // `unavailable` means no retry can ever succeed; otherwise keep the tab
+    // armed so the next prompt tries again with more context.
+    if (result.status === 'failed' && state.attempts < maxAttempts) return
+
+    this.finish(tabId, heuristicTitle(state.firstPrompt ?? state.prompts[0] ?? ''))
+  }
+
+  /** Apply the final outcome and stop watching the tab. */
+  private finish(tabId: string, title: string | null): void {
+    this.unregister(tabId)
+    this.options.updateTab(tabId, {
+      autoRenameStatus: 'attempted',
+      ...(title != null && title !== '' ? { title } : {}),
+    })
+  }
+
+  private async acquireSlot(): Promise<() => void> {
+    if (this.running >= MAX_CONCURRENT_GENERATIONS) {
+      await new Promise<void>((resolve) => this.waiting.push(resolve))
+    }
+    this.running++
+    let released = false
+    return () => {
+      if (released) return
+      released = true
+      this.running--
+      this.waiting.shift()?.()
+    }
   }
 }
+
+function createState(): TabRenameState {
+  return {
+    attempts: 0,
+    capture: new PromptCapture(),
+    controller: null,
+    firstPrompt: null,
+    hookDriven: false,
+    prompts: [],
+    settleTimer: null,
+  }
+}
+
+/**
+ * Add a prompt, keeping the pending set free of restatements of the same text.
+ * The keystroke and hook paths can both report one submission, and a user often
+ * rephrases; either way the title request should see the content once.
+ */
+function appendPrompt(state: TabRenameState, prompt: string): void {
+  const incoming = normalize(prompt)
+  if (incoming === '') return
+  // Already covered by a pending prompt (the same submission seen through both
+  // the keystroke and hook paths, or a restatement of it).
+  if (state.prompts.some((existing) => normalize(existing).includes(incoming))) return
+  // Supersede the shorter pending prompts this one subsumes.
+  state.prompts = state.prompts.filter((existing) => !incoming.includes(normalize(existing)))
+  if (state.prompts.length >= MAX_PENDING_PROMPTS) return
+  state.prompts.push(prompt)
+}

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

@@ -0,0 +1,57 @@
+// Last-resort title, derived locally from the prompt when every model
+// generation attempt failed (binary missing, non-zero exit, timeout,
+// unusable output). A rough title beats a tab that stays "Claude" forever.
+
+import { clampTitle } from './title-format'
+
+/** Openers that carry no intent; dropped so the title starts at the verb. */
+const LEADING_FILLERS = [
+  /^(?:hey|hi|hello|yo|salut|bonjour|coucou)\b[\s,]*/iu,
+  /^(?:please|pls|plz|stp|svp)\b[\s,]*/iu,
+  /^(?:s'il te (?:plait|plaît)|s'il vous (?:plait|plaît))\b[\s,]*/iu,
+  /^(?:can|could|would|will)\s+you\s+(?:please\s+)?/iu,
+  /^(?:i(?:'d| would)\s+like\s+you\s+to|i\s+want\s+you\s+to|i\s+need\s+you\s+to)\s+/iu,
+  /^(?:j'aimerais\s+que\s+tu|je\s+voudrais\s+que\s+tu|peux[- ]tu|pourrais[- ]tu|tu\s+peux)\s+/iu,
+  /^(?:let'?s|on\s+va)\s+/iu,
+  /^(?:ok|okay|alors|bon|donc|so|now)\b[\s,]*/iu,
+]
+
+/** Markdown noise that would otherwise land inside the title. */
+const LEADING_MARKUP = /^(?:[-*+>#]+|\d+[.)])\s*/u
+
+export function heuristicTitle(prompt: string): string | null {
+  // First prose line: fenced code is pasted context, never the request itself.
+  let inFence = false
+  let firstLine: string | undefined
+  for (const raw of prompt.split(/\r?\n/u)) {
+    const line = raw.trim()
+    if (line.startsWith('```')) {
+      inFence = !inFence
+      continue
+    }
+    if (inFence || line === '') continue
+    firstLine = line
+    break
+  }
+  if (firstLine == null) return null
+
+  let text = firstLine.replaceAll('`', '').replace(LEADING_MARKUP, '').trim()
+  // Fillers stack ("hey, could you please …"), so keep peeling until stable.
+  let stripped = true
+  while (stripped) {
+    stripped = false
+    for (const filler of LEADING_FILLERS) {
+      const next = text.replace(filler, '')
+      if (next !== text) {
+        text = next.trim()
+        stripped = true
+      }
+    }
+  }
+
+  // Only the opening clause describes the task; the rest is detail.
+  const clause = text.split(/(?<=[.!?;:])\s|\s+(?:and|then|puis|et)\s+/iu)[0] ?? text
+  const title = clampTitle(clause)
+  if (title == null) return null
+  return title.charAt(0).toLocaleUpperCase() + title.slice(1)
+}

package/src/auto-rename/prompt-capture.ts

@@ -121,6 +121,14 @@ export class PromptCapture {
     this.escapeBuffer += char
     const sequence = this.escapeBuffer
 
+    // Alt/Shift+Enter — a newline inside the prompt, not a submission and not a
+    // reason to distrust what we captured.
+    if (sequence.length === 2 && (char === '\r' || char === '\n')) {
+      this.escapeBuffer = ''
+      this.insert('\n')
+      return
+    }
+
     if (
       sequence.length === 2 &&
       sequence !== '\x1b[' &&
@@ -169,6 +177,17 @@ export class PromptCapture {
 
     const final = sequence.at(-1) ?? ''
     const parameters = sequence.slice(2, -1)
+    // Modified Enter under the kitty keyboard protocol (`CSI 13;2 u`) or
+    // xterm's modifyOtherKeys (`CSI 27;2;13 ~`): another way to type a newline
+    // inside the prompt.
+    const fields = parameters.split(';')
+    if (
+      (final === 'u' && fields[0] === '13') ||
+      (final === '~' && fields[0] === '27' && fields[2] === '13')
+    ) {
+      this.insert('\n')
+      return
+    }
     if ((final === 'C' || final === 'D') && parameters.includes(';')) {
       this.invalidateCurrentSubmission()
       return

package/src/auto-rename/prompt-gate.ts

@@ -0,0 +1,82 @@
+// Decides whether a submitted prompt says anything about what the tab is for.
+//
+// The first Enter in an assistant tab is very often not a task: a trust-folder
+// dialog, a theme picker, a slash-command menu, a permission answer, or a bare
+// "y". Titling from those is the "renamed too early / wrong intent" failure, so
+// they are skipped — and skipping is free: it never consumes a rename attempt.
+
+import { usesUnspacedScript } from './title-format'
+
+/** Answers that only advance a dialog; never a description of the work. */
+const CONFIRMATIONS: ReadonlySet<string> = new Set([
+  'a',
+  'accept',
+  'again',
+  'allow',
+  'annuler',
+  'cancel',
+  'continue',
+  'continue please',
+  'd',
+  'do it',
+  'encore',
+  'exit',
+  'go',
+  'go ahead',
+  'go on',
+  'k',
+  'merci',
+  'n',
+  'next',
+  'no',
+  'non',
+  'nope',
+  'ok',
+  'okay',
+  'oui',
+  'proceed',
+  'quit',
+  'retry',
+  'skip',
+  'stop',
+  'sure',
+  'thanks',
+  'thank you',
+  'undo',
+  'vas-y',
+  'y',
+  'yep',
+  'yes',
+  'yes please',
+])
+
+/** `/model`, `/init`, `/clear`… — a command, not a request. `/home/x/y.ts` is not one. */
+const SLASH_COMMAND = /^\/[a-z][\w:-]*(?:\s|$)/iu
+/** `!ls -la` runs a shell command in Claude Code. */
+const SHELL_ESCAPE = /^!/u
+/** `#` memorizes a note in Claude Code. */
+const MEMORY_NOTE = /^#/u
+
+export type PromptVerdict = 'title-worthy' | 'skip'
+
+export function classifyPrompt(prompt: string, minWords: number): PromptVerdict {
+  const trimmed = prompt.trim()
+  if (trimmed === '') return 'skip'
+  if (SLASH_COMMAND.test(trimmed) || SHELL_ESCAPE.test(trimmed) || MEMORY_NOTE.test(trimmed)) {
+    return 'skip'
+  }
+
+  const normalized = trimmed
+    .replaceAll(/\s+/gu, ' ')
+    .replace(/[.!?,;:…]+$/u, '')
+    .toLowerCase()
+  if (CONFIRMATIONS.has(normalized)) return 'skip'
+  // Menu selections: a lone digit, or "1" / "2." style picks.
+  if (/^\d{1,2}$/u.test(normalized)) return 'skip'
+
+  // Languages without spaces between words defeat the word count; fall back to
+  // a character floor so Japanese or Chinese prompts are not all skipped.
+  if (usesUnspacedScript(trimmed)) return trimmed.length >= 4 ? 'title-worthy' : 'skip'
+
+  return trimmed.split(/\s+/u).filter(Boolean).length >= minWords ? 'title-worthy' : 'skip'
+}

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

@@ -0,0 +1,38 @@
+// Shared shaping rules for tab titles, whether they come from a model
+// (`title-runner`) or from the local fallback (`heuristic-title`). Both must
+// produce the same silhouette: 2 to 6 words, at most 48 characters, no
+// trailing punctuation.
+
+export const MAX_TITLE_WORDS = 6
+export const MAX_TITLE_LENGTH = 48
+
+/** Scripts that do not separate words with spaces, where a one-"word" title is legitimate. */
+export function usesUnspacedScript(text: string): boolean {
+  return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Thai}]/u.test(
+    text
+  )
+}
+
+/**
+ * Collapse whitespace, drop trailing punctuation, and clamp to the title
+ * budget. Returns null when nothing usable is left.
+ */
+export function clampTitle(raw: string): string | null {
+  const clean = raw
+    .replaceAll(/\s+/gu, ' ')
+    .replace(/[.!?,;:…]+$/u, '')
+    .trim()
+  const words = clean.split(' ').filter(Boolean)
+  const unspaced = usesUnspacedScript(clean)
+  if (words.length < 2 && !unspaced) return null
+
+  let title = words.slice(0, MAX_TITLE_WORDS).join(' ')
+  if (title.length > MAX_TITLE_LENGTH) {
+    title = title
+      .slice(0, MAX_TITLE_LENGTH)
+      .replace(/\s+\S*$/u, '')
+      .trim()
+  }
+  if (title === '') return null
+  return title.split(' ').filter(Boolean).length < 2 && !unspaced ? null : title
+}

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

@@ -1,10 +1,21 @@
 import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+import { clampTitle } from './title-format'
 
 export type TitleSpawnFn = (
   invocation: HeadlessInvocation,
   signal: AbortSignal
 ) => Promise<{ stdout: string; exitCode: number } | null>
 
+/**
+ * `failed` is retryable — a later prompt may well produce a usable title.
+ * `unavailable` is not: the provider has no headless mode or its binary is not
+ * installed, so the coordinator should stop burning attempts and fall back.
+ */
+export type TitleResult =
+  | { status: 'ok'; title: string }
+  | { status: 'failed' }
+  | { status: 'unavailable' }
+
 export function buildTitlePrompt(firstPrompt: string): string {
   return [
     'Create a concise tab title for the user request below.',
@@ -23,24 +34,16 @@ export function sanitizeGeneratedTitle(raw: string): string | null {
   if (first == null || first === '') return null
 
   const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
-  const clean = unlabelled
-    .replaceAll(/\s+/gu, ' ')
-    .replace(/[.!?,;:…]+$/u, '')
-    .trim()
-  const words = clean.split(' ').filter(Boolean)
-  const usesUnspacedScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(clean)
-  if (words.length < 2 && !usesUnspacedScript) return null
+  return clampTitle(unlabelled)
+}
 
-  let title = words.slice(0, 6).join(' ')
-  if (title.length > 48) {
-    title = title
-      .slice(0, 48)
-      .replace(/\s+\S*$/u, '')
-      .trim()
+function executableOnPath(executable: string): boolean {
+  try {
+    return typeof Bun !== 'undefined' && Bun.which(executable) != null
+  } catch {
+    // Never let a lookup failure mask a provider that would have worked.
+    return true
   }
-  return title === '' || (title.split(' ').filter(Boolean).length < 2 && !usesUnspacedScript)
-    ? null
-    : title
 }
 
 export async function generateTabTitle(options: {
@@ -50,21 +53,29 @@ export async function generateTabTitle(options: {
   timeoutMs: number
   signal: AbortSignal
   spawn?: TitleSpawnFn
-}): Promise<string | null> {
+  isExecutableAvailable?: (executable: string) => boolean
+}): Promise<TitleResult> {
   const invocation = buildHeadlessInvocation(
     options.provider,
     buildTitlePrompt(options.firstPrompt),
     options.model
   )
-  if (!invocation) return null
+  if (!invocation) return { status: 'unavailable' }
+
+  // A caller-supplied spawn does not go through PATH, so only probe it for the
+  // real one. Probing lets a missing CLI fail instantly instead of after the
+  // full timeout, once per tab instead of once per attempt.
+  const available = options.isExecutableAvailable ?? (options.spawn ? null : executableOnPath)
+  if (available && !available(invocation.executable)) return { status: 'unavailable' }
 
   const signal = AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs)])
   try {
     const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
-    if (!result || result.exitCode !== 0 || signal.aborted) return null
-    return sanitizeGeneratedTitle(result.stdout)
+    if (!result || result.exitCode !== 0 || signal.aborted) return { status: 'failed' }
+    const title = sanitizeGeneratedTitle(result.stdout)
+    return title == null ? { status: 'failed' } : { status: 'ok', title }
   } catch {
-    return null
+    return { status: 'failed' }
   }
 }
 

package/src/daemon/daemon.ts

@@ -514,6 +514,17 @@ export async function runDaemon(): Promise<void> {
           payload: event.payload,
           receivedAt: event.receivedAt,
         })
+        // `UserPromptSubmit` carries the exact prompt at the exact moment it is
+        // submitted, so auto-rename prefers it over reconstructing keystrokes:
+        // trust dialogs, menus and completions never produce one.
+        if (event.hookEventName === 'UserPromptSubmit') {
+          const prompt = event.payload.prompt
+          const parentToolUseId = event.payload.parent_tool_use_id
+          const fromSubagent = typeof parentToolUseId === 'string' && parentToolUseId.length > 0
+          if (typeof prompt === 'string' && !fromSubagent) {
+            autoRename.observePrompt(event.paneId, prompt)
+          }
+        }
       },
     })
     try {