@brimveyn/aimux 1.18.3 → 1.18.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.18.3",
+  "version": "1.18.4",
   "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/send.ts

@@ -5,6 +5,16 @@ import { bracketedPaste, notationToBytes } from '../../chord'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
+/**
+ * Gap between the bracketed-paste write and the trailing carriage return when
+ * `--enter` submits a pasted block. Claude Code (and other paste-aware TUIs)
+ * buffer every byte between the paste-start/paste-end markers; a `\r` that
+ * arrives in the same burst as the paste-end marker is folded into the paste
+ * buffer as literal content instead of being read as a submit keystroke. A
+ * short settle lets the receiver exit paste mode before the Enter lands.
+ */
+const PASTE_SUBMIT_SETTLE_MS = 50
+
 /**
  * Lower a chord/paste buffer of bytes into the string the protocol expects.
  * Every byte we emit is < 0x80 (control chars or printable ASCII), so a
@@ -47,9 +57,18 @@ export const tabSend: CliCommand = {
     const appendEnter = ctx.args.flags.enter === true
 
     let data: string
+    // Whether `data` is a bracketed-paste block (multi-line text that
+    // `bracketedPaste` wrapped in start/end markers). A trailing `\r` must be
+    // sent as a *separate*, settled write for these — see PASTE_SUBMIT_SETTLE_MS.
+    let bracketed = false
     if (fromStdin) {
       const stdinText = await Bun.stdin.text()
-      data = asKeys ? bytesToString(notationToBytes(stdinText)) : bracketedPaste(stdinText)
+      if (asKeys) {
+        data = bytesToString(notationToBytes(stdinText))
+      } else {
+        data = bracketedPaste(stdinText)
+        bracketed = data !== stdinText
+      }
     } else {
       const text = ctx.args.positionals[1] ?? ''
       if (asKeys) {
@@ -57,13 +76,10 @@ export const tabSend: CliCommand = {
         data = bytesToString(notationToBytes(text))
       } else {
         data = bracketedPaste(text)
+        bracketed = data !== text
       }
     }
 
-    if (appendEnter) {
-      data = `${data}\r`
-    }
-
     const workspace = ctx.getWorkspace()
     const daemon = await ctx.getDaemon()
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
@@ -75,7 +91,20 @@ export const tabSend: CliCommand = {
     await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
     await daemon.expectOk('write', { data, tabId })
 
-    writeJson({ bytesWritten: Buffer.byteLength(data, 'utf8'), ok: true })
+    let bytesWritten = Buffer.byteLength(data, 'utf8')
+    if (appendEnter) {
+      // A bracketed paste swallows a same-burst `\r`, so settle first, then
+      // submit as an independent write. Plain text / key chords carry no paste
+      // markers, so the Enter can follow immediately — but still as its own
+      // write so the two paths stay uniform.
+      if (bracketed) {
+        await Bun.sleep(PASTE_SUBMIT_SETTLE_MS)
+      }
+      await daemon.expectOk('write', { data: '\r', tabId })
+      bytesWritten += 1
+    }
+
+    writeJson({ bytesWritten, ok: true })
     return EXIT_OK
   },
   summary: 'Write text or a key chord to a tab',

package/src/daemon/session-registry.ts

@@ -111,7 +111,21 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     const orderedSnapshotTabs = snapshot.tabs
       .map((persistedTab) => this.tabs.get(persistedTab.id))
       .filter((tab): tab is TabSession => tab !== undefined)
-    const normalizedTabs = normalizeGroupedTabOrder(orderedSnapshotTabs, layoutTrees, tabGroupMap)
+    // The registry — not the snapshot — is the source of truth for *which*
+    // tabs exist. A tab spawned by a sibling CLI after this workspace's
+    // snapshot was last persisted lives in `this.tabs` but is absent from
+    // `snapshot.tabs`; ordering by the snapshot alone would silently drop it
+    // from the attach result, so the UI would render an empty/stale workspace
+    // on switch. Append any live tab the snapshot doesn't mention (in
+    // registry order) so membership stays authoritative while the snapshot
+    // still supplies ordering + layout for the tabs it captured.
+    const snapshotIds = new Set(snapshot.tabs.map((persistedTab) => persistedTab.id))
+    const extraLiveTabs = tabs.filter((tab) => !snapshotIds.has(tab.id))
+    const normalizedTabs = normalizeGroupedTabOrder(
+      [...orderedSnapshotTabs, ...extraLiveTabs],
+      layoutTrees,
+      tabGroupMap
+    )
 
     return { activeTabId: this.activeTabId, tabs: normalizedTabs }
   }