@brimveyn/aimux 1.12.2 → 1.12.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.12.2",
+  "version": "1.12.6",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.5.13",
+    "@brimveyn/aimux-config": "0.5.17",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/pty-write.ts

@@ -45,3 +45,55 @@ export function writePasteToTab(
   const payload = buildPtyPastePayload(text, tab?.terminalModes.bracketedPasteMode ?? false)
   writeToTab(backend, tabId, tab, payload, dispatch, { autoBottom: true })
 }
+
+const DEL = '\x7f'
+const CURSOR_LEFT = '\x1b[D'
+const RAW_INLINE_MAX_LEN = 200
+
+/**
+ * Write a macro expansion to a PTY:
+ *  1. Erase `eraseCount` previously echoed characters via DEL (readline-compatible).
+ *  2. Inject `expandedText` (raw if short single-line; bracketed-paste payload otherwise).
+ *  3. Move cursor left to `cursorOffset` via ANSI left-arrow sequences (outside any
+ *     bracketed-paste wrapper so the application interprets them as keys, not text).
+ */
+export function writeMacroExpansionToTab(
+  backend: SessionBackend,
+  tabId: string,
+  tab: TabSession | undefined,
+  eraseCount: number,
+  expandedText: string,
+  cursorOffset: number,
+  dispatch?: (action: AppAction) => void
+): void {
+  if (tab && shouldScrollViewportToBottom(tab)) {
+    backend.scrollViewportToBottom(tabId)
+    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
+  }
+
+  const erase = eraseCount > 0 ? DEL.repeat(eraseCount) : ''
+  const isShortInline = expandedText.length <= RAW_INLINE_MAX_LEN && !expandedText.includes('\n')
+  const bracketed = tab?.terminalModes.bracketedPasteMode ?? false
+
+  const body = isShortInline ? expandedText : buildPtyPastePayload(expandedText, bracketed)
+  const leftArrowCount = Math.max(0, expandedText.length - cursorOffset)
+  const leftArrows = leftArrowCount > 0 ? CURSOR_LEFT.repeat(leftArrowCount) : ''
+
+  logInputDebug('ptyWrite.macroExpansion', {
+    bodyLength: body.length,
+    cursorOffset,
+    eraseCount,
+    expandedTextLength: expandedText.length,
+    leftArrowCount,
+    tabId,
+  })
+
+  if (isShortInline) {
+    backend.write(tabId, `${erase}${body}${leftArrows}`)
+    return
+  }
+
+  if (erase) backend.write(tabId, erase)
+  backend.write(tabId, body)
+  if (leftArrows) backend.write(tabId, leftArrows)
+}

package/src/app-runtime/side-effects.ts

@@ -6,7 +6,8 @@ import {
 } from '@brimveyn/aimux-config'
 import { type CliRenderer } from '@opentui/core'
 import { $ } from 'bun'
-import { resolve as resolvePath } from 'node:path'
+import { existsSync } from 'node:fs'
+import { join as joinPath, resolve as resolvePath } from 'node:path'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
@@ -15,6 +16,7 @@ import { loadConfig, saveConfig } from '../config'
 import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
 import { createPrefixedId } from '../platform/id'
+import { getProfileConfigDir } from '../profile-paths'
 import {
   getAllAssistantOptions,
   getAssistantOption,
@@ -33,6 +35,7 @@ import {
   splitNode,
 } from '../state/layout-tree'
 import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
+import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import {
   type AppAction,
@@ -388,6 +391,11 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       launchAssistant(ctx, option.id)
       return
     }
+    case 'edit-selected-assistant': {
+      const option = getSelectedAssistantOption(state)
+      dispatch({ assistantId: option.id, type: 'open-edit-custom-command' })
+      return
+    }
     case 'confirm-selected-session': {
       handleSessionSelection(ctx)
       return
@@ -617,22 +625,45 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       openFileInEditor(ctx, effect.path)
       return
     }
+    case 'open-selected-snippet-source-in-editor': {
+      openSelectedSnippetSourceInEditor(ctx)
+      return
+    }
     default:
       effect satisfies never
   }
 }
 
-function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
-  const config = getExternalEditorConfig()
-  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
-  if (!rawCommand || rawCommand.trim() === '') {
-    ctx.dispatch({
-      message: 'no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts',
-      type: 'git-mode-set-message',
-    })
-    return
+/**
+ * Open the file backing the currently selected snippet in the user's editor.
+ * Config-pinned snippets (id starts with `config:`) live in `aimux.config.ts`
+ * (or `.js`); user-edited snippets live in `aimux-snippets.json`.
+ *
+ * On error (no editor, editor not in PATH) the failure is silent: there is no
+ * snippet-picker status line. The user can check the debug log.
+ */
+function openSelectedSnippetSourceInEditor(ctx: SideEffectContext): void {
+  const snippet = getSelectedSnippet(ctx.state)
+  if (!snippet) return
+
+  const configDir = getProfileConfigDir()
+  let absolutePath: string
+
+  if (isConfigSnippetId(snippet.id)) {
+    const tsPath = joinPath(configDir, 'aimux.config.ts')
+    const jsPath = joinPath(configDir, 'aimux.config.js')
+    absolutePath = existsSync(jsPath) && !existsSync(tsPath) ? jsPath : tsPath
+  } else {
+    absolutePath = getSnippetsCatalogPath()
   }
 
+  launchEditorOnFile(ctx, absolutePath, configDir, (message) => {
+    logInputDebug('snippets.openInEditor.error', { message, path: absolutePath })
+    ctx.dispatch({ message, type: 'snippet-picker-set-message' })
+  })
+}
+
+function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
   const fileEntry = ctx.state.gitPanel.files.find((f) => f.path === relPath)
   const cwd = fileEntry?.repoPath ?? ctx.getCurrentSessionProjectPath()
   if (!cwd) {
@@ -640,11 +671,28 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
     return
   }
   const absolutePath = resolvePath(cwd, relPath)
+  launchEditorOnFile(ctx, absolutePath, cwd, (message) =>
+    ctx.dispatch({ message, type: 'git-mode-set-message' })
+  )
+}
+
+function launchEditorOnFile(
+  ctx: SideEffectContext,
+  absolutePath: string,
+  cwd: string,
+  onError: (message: string) => void
+): void {
+  const config = getExternalEditorConfig()
+  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
+  if (!rawCommand || rawCommand.trim() === '') {
+    onError('no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts')
+    return
+  }
 
   const cmdParts = shellSplit(rawCommand)
   const executable = cmdParts[0]
   if (!executable) {
-    ctx.dispatch({ message: 'invalid editor command', type: 'git-mode-set-message' })
+    onError('invalid editor command')
     return
   }
   const baseName = executable.split('/').pop() ?? executable
@@ -653,16 +701,12 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
   const kind: 'gui' | 'tui' = config.kind ?? (KNOWN_GUI_EDITORS.has(baseName) ? 'gui' : 'tui')
 
   const templateArgs = config.args ?? DEFAULT_EDITOR_ARGS[baseName] ?? ['{file}']
-  // git mode does not track a cursor line within the diff yet, so pass undefined
-  // and let the substitution strip `{line}` placeholders cleanly — preserves
-  // editor-side "restore last cursor position" behavior (e.g. vscode).
+  // No line target — let substitution strip `{line}` placeholders so we don't
+  // defeat the editor's "restore last cursor position" feature.
   const resolvedArgs = [...extraCmdArgs, ...substituteEditorArgs(templateArgs, absolutePath)]
 
   if (!isCommandAvailable(executable)) {
-    ctx.dispatch({
-      message: `editor not found in PATH: ${executable}`,
-      type: 'git-mode-set-message',
-    })
+    onError(`editor not found in PATH: ${executable}`)
     return
   }
 
@@ -671,9 +715,6 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
     return
   }
 
-  // TUI editor — if the user explicitly configured `terminal`, spawn a new
-  // terminal window with their template. Otherwise default to inline shellout:
-  // suspend the renderer, hand the TTY to the editor, resume on exit.
   if (config.terminal && config.terminal.length > 0) {
     const shellCmd = buildShellCmd(cwd, executable, resolvedArgs)
     const argv = config.terminal.map((a) =>

package/src/app-runtime/snippet-actions.ts

@@ -2,25 +2,31 @@ import type { SessionBackend } from '../session-backend/types'
 import type { AppAction, AppState, SnippetRecord, TabSession } from '../state/types'
 
 import { createPrefixedId } from '../platform/id'
-import { saveSnippetCatalog } from '../state/snippet-catalog'
+import { isConfigSnippetId, saveSnippetCatalog } from '../state/snippet-catalog'
 import { writePasteToTab } from './pty-write'
 
 function createSnippetId(): string {
   return createPrefixedId('snip')
 }
 
-export function getSnippetEditorValue(state: AppState): { name: string; content: string } | null {
+export interface SnippetEditorValue {
+  name: string
+  trigger: string
+  content: string
+}
+
+export function getSnippetEditorValue(state: AppState): SnippetEditorValue | null {
   if (state.modal.type !== 'snippet-editor') {
     return null
   }
 
   const { modal } = state
-  const name =
-    modal.activeField === 'name' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
-  const content =
-    modal.activeField === 'content' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
+  const editValue = (modal.editBuffer ?? '').trim()
+  const name = modal.activeField === 'name' ? editValue : modal.nameBuffer.trim()
+  const trigger = modal.activeField === 'trigger' ? editValue : modal.triggerBuffer.trim()
+  const content = modal.activeField === 'content' ? editValue : modal.contentBuffer.trim()
 
-  return { content, name }
+  return { content, name, trigger }
 }
 
 export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null {
@@ -35,21 +41,29 @@ export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null
   }
 
   const snippetId = state.modal.sessionTargetId
+  // Config-pinned snippets are sticky and read-only in the UI.
+  if (snippetId && isConfigSnippetId(snippetId)) {
+    return null
+  }
+
+  const trigger = editorValue.trigger.length > 0 ? editorValue.trigger : undefined
+
   if (snippetId) {
     return state.snippets.map((snippet) =>
       snippet.id === snippetId
-        ? { ...snippet, content: editorValue.content, name: editorValue.name }
+        ? { ...snippet, content: editorValue.content, name: editorValue.name, trigger }
         : snippet
     )
   }
 
   return [
     ...state.snippets,
-    { content: editorValue.content, id: createSnippetId(), name: editorValue.name },
+    { content: editorValue.content, id: createSnippetId(), name: editorValue.name, trigger },
   ]
 }
 
 export function deleteSnippetState(snippets: SnippetRecord[], snippetId: string): SnippetRecord[] {
+  if (isConfigSnippetId(snippetId)) return snippets
   return snippets.filter((snippet) => snippet.id !== snippetId)
 }
 

package/src/app-runtime/use-renderer-bindings.ts

@@ -3,13 +3,24 @@ import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { KeyChord } from '../input/keymap/key-chord'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, FocusMode, TabSession } from '../state/types'
+import type { AppAction, FocusMode, SnippetRecord, TabSession } from '../state/types'
 
 import { INPUT_DEBUG_LOG_PATH, logInputDebug } from '../debug/input-log'
 import { createRawInputHandler } from '../input/raw-input-handler'
-import { copyToSystemClipboard } from '../platform/clipboard'
+import { copyToSystemClipboard, readFromSystemClipboard } from '../platform/clipboard'
+import {
+  expandSnippet,
+  expandSnippetSync,
+  requiresAsyncExpansion,
+} from '../snippets/expand-variables'
+import { runShellVar } from '../snippets/run-shell-var'
+import {
+  createTriggerDetector,
+  type TriggerDetector,
+  type TriggerMatch,
+} from '../snippets/trigger-detector'
 import { shouldSuppressSelectionCopy } from './multi-click-clipboard-guard'
-import { writePasteToTab, writeToTab } from './pty-write'
+import { writeMacroExpansionToTab, writePasteToTab, writeToTab } from './pty-write'
 import { type OtuiSelection, resolveSelectionClipboardText } from './selection-clipboard'
 import { applyViewportObservation, type ViewportObservation } from './selection-scroll'
 
@@ -28,6 +39,9 @@ interface UseRendererBindingsOptions {
   focusModeRef: MutableRefObject<FocusMode>
   activeTabIdRef: MutableRefObject<string | null>
   activeTabRef: MutableRefObject<TabSession | undefined>
+  snippetsRef: MutableRefObject<readonly SnippetRecord[]>
+  branchRef: MutableRefObject<string | null>
+  triggerCharRef: MutableRefObject<string>
   handleTerminalShortcut: (chord: KeyChord) => boolean
 }
 
@@ -41,13 +55,27 @@ export function useRendererBindings({
   activeTabRef,
   activeTabViewportY,
   backend,
+  branchRef,
   dispatch,
   focusMode,
   focusModeRef,
   handleTerminalShortcut,
   renderer,
+  snippetsRef,
+  triggerCharRef,
 }: UseRendererBindingsOptions): void {
   const lastViewportRef = useRef<ViewportObservation | null>(null)
+  const triggerDetectorsRef = useRef<Map<string, TriggerDetector>>(new Map())
+  const pendingMacroUndoRef = useRef<Map<string, { fullLength: number; suffixLength: number }>>(
+    new Map()
+  )
+  /**
+   * Tabs currently waiting on an async expansion (shell vars or {{clipboard}}).
+   * While a tab is in this set, new trigger detections on that tab are
+   * suppressed — without this, a second trigger typed during the await would
+   * race with the in-flight expansion and corrupt PTY state + undo bookkeeping.
+   */
+  const inFlightAsyncExpansionRef = useRef<Set<string>>(new Set())
 
   useEffect(() => {
     renderer.useMouse = true
@@ -55,12 +83,115 @@ export function useRendererBindings({
     renderer.console.hide()
     renderer.console.show = () => {}
 
+    const getOrCreateDetector = (tabId: string): TriggerDetector => {
+      let detector = triggerDetectorsRef.current.get(tabId)
+      if (!detector) {
+        detector = createTriggerDetector({
+          getSnippets: () => snippetsRef.current,
+          getTriggerChar: () => triggerCharRef.current,
+        })
+        triggerDetectorsRef.current.set(tabId, detector)
+      }
+      return detector
+    }
+
+    const expandMacroForTab = (tabId: string, match: TriggerMatch): void => {
+      const tab = activeTabRef.current
+      const snippet = match.snippet
+      const branch = branchRef.current
+      const cwd = process.cwd()
+      const now = new Date()
+
+      const registerUndo = (text: string, cursorOffset: number) => {
+        // Undo window: only meaningful for short inline expansions where
+        // cursor positions stay predictable in raw mode.
+        if (!text.includes('\n')) {
+          pendingMacroUndoRef.current.set(tabId, {
+            fullLength: text.length,
+            suffixLength: text.length - cursorOffset,
+          })
+        }
+      }
+
+      if (!requiresAsyncExpansion(snippet)) {
+        const { cursorOffset, text } = expandSnippetSync(snippet.content, {
+          branch,
+          customVars: new Map(),
+          cwd,
+          now,
+        })
+        writeMacroExpansionToTab(
+          backend,
+          tabId,
+          tab,
+          match.triggerText.length,
+          text,
+          cursorOffset,
+          dispatch
+        )
+        registerUndo(text, cursorOffset)
+        return
+      }
+
+      // Eager erase: drop the typed trigger from the PTY immediately so the
+      // user doesn't stare at `:prfull ` while shell vars resolve.
+      backend.write(tabId, '\x7f'.repeat(match.triggerText.length))
+      inFlightAsyncExpansionRef.current.add(tabId)
+
+      void (async () => {
+        try {
+          const varEntries = Object.entries(snippet.vars ?? {})
+          const resolved = await Promise.all(
+            varEntries.map(async ([name, v]) => [name, await runShellVar(name, v)] as const)
+          )
+          const customVars = new Map(resolved)
+          const { cursorOffset, text } = await expandSnippet(snippet.content, {
+            branch,
+            clipboard: readFromSystemClipboard,
+            customVars,
+            cwd,
+            now,
+          })
+          // Trigger already erased above; eraseCount = 0 here.
+          writeMacroExpansionToTab(backend, tabId, tab, 0, text, cursorOffset, dispatch)
+          registerUndo(text, cursorOffset)
+        } finally {
+          inFlightAsyncExpansionRef.current.delete(tabId)
+        }
+      })()
+    }
+
+    const tryConsumeMacroUndo = (tabId: string, sequence: string): boolean => {
+      const entry = pendingMacroUndoRef.current.get(tabId)
+      if (!entry) return false
+      pendingMacroUndoRef.current.delete(tabId)
+      const isBackspace = sequence === '\x7f' || sequence === '\b'
+      if (!isBackspace) return false
+      const rightArrows = '\x1b[C'.repeat(entry.suffixLength)
+      const dels = '\x7f'.repeat(entry.fullLength)
+      backend.write(tabId, `${rightArrows}${dels}`)
+      return true
+    }
+
     const handler = createRawInputHandler({
+      expandMacro: expandMacroForTab,
+      feedTrigger: (tabId, char) => {
+        // Drop new detections while an async expansion is in flight for this
+        // tab — otherwise the second match races with the awaited write.
+        if (inFlightAsyncExpansionRef.current.has(tabId)) {
+          triggerDetectorsRef.current.get(tabId)?.reset()
+          return null
+        }
+        return getOrCreateDetector(tabId).feed(char)
+      },
       getActiveTabId: () => activeTabIdRef.current,
       getBracketedPasteModeEnabled: () =>
         activeTabRef.current?.terminalModes.bracketedPasteMode ?? false,
       getFocusMode: () => focusModeRef.current,
+      getIsAlternateBuffer: () => activeTabRef.current?.terminalModes.isAlternateBuffer ?? false,
       handleTerminalShortcut,
+      resetTrigger: (tabId) => triggerDetectorsRef.current.get(tabId)?.reset(),
+      tryConsumeMacroUndo,
       writeToPty: (tabId, data, options) =>
         writeToTab(backend, tabId, activeTabRef.current, data, dispatch, options),
     })
@@ -146,10 +277,13 @@ export function useRendererBindings({
     activeTabIdRef,
     activeTabRef,
     backend,
+    branchRef,
     dispatch,
     focusModeRef,
     handleTerminalShortcut,
     renderer,
+    snippetsRef,
+    triggerCharRef,
   ])
 
   useEffect(() => {

package/src/app.tsx

@@ -34,7 +34,7 @@ import { aiUsageStore } from './state/ai-usage-store'
 import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
 import { findMostRecentSession, loadSessionCatalog } from './state/session-catalog'
-import { loadSnippetCatalog } from './state/snippet-catalog'
+import { loadSnippetCatalog, mergeConfigSnippets } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
@@ -137,10 +137,11 @@ export function App({
     }
 
     const sessionCatalog = loadSessionCatalog()
+    const mergedSnippets = mergeConfigSnippets(loadSnippetCatalog(), resolvedConfig.snippets)
     const initial = createInitialState(
       json.customCommands,
       sessionCatalog,
-      loadSnippetCatalog(),
+      mergedSnippets,
       sessionCatalog.length === 0,
       {
         gitPane: gitPaneOverrides,
@@ -259,6 +260,13 @@ export function App({
   const stateRef = useRef(state)
   stateRef.current = state
 
+  const snippetsRef = useRef(state.snippets)
+  snippetsRef.current = state.snippets
+  const branchRef = useRef(state.gitPanel.branch)
+  branchRef.current = state.gitPanel.branch
+  const triggerCharRef = useRef(resolvedConfig.snippetTriggerChar)
+  triggerCharRef.current = resolvedConfig.snippetTriggerChar
+
   const contentOriginRef = useRef<TerminalContentOrigin>({ cols: 0, rows: 0, x: 0, y: 0 })
   const currentSessionWorkspaceSnapshot = currentSession?.workspaceSnapshot
 
@@ -370,11 +378,14 @@ export function App({
     activeTabRef,
     activeTabViewportY: activeTab?.viewport?.viewportY ?? null,
     backend,
+    branchRef,
     dispatch,
     focusMode: state.focusMode,
     focusModeRef,
     handleTerminalShortcut,
     renderer,
+    snippetsRef,
+    triggerCharRef,
   })
 
   const sideEffectCtx: SideEffectContext = {

package/src/input/modes/types.ts

@@ -26,6 +26,7 @@ export type ModeId =
 export type SideEffect =
   | { type: 'quit'; state: AppState }
   | { type: 'launch-selected-assistant' }
+  | { type: 'edit-selected-assistant' }
   | { type: 'confirm-selected-session' }
   | { type: 'delete-selected-session' }
   | { type: 'open-rename-selected-session' }
@@ -69,6 +70,7 @@ export type SideEffect =
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
   | { type: 'open-file-in-editor'; path: string }
+  | { type: 'open-selected-snippet-source-in-editor' }
 
 export interface KeyResult {
   actions: AppAction[]

package/src/input/raw-input-handler.ts

@@ -1,4 +1,5 @@
 import type { PtyWriteOptions } from '../app-runtime/pty-write'
+import type { TriggerMatch } from '../snippets/trigger-detector'
 import type { FocusMode } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
@@ -88,6 +89,20 @@ export function createRawInputHandler(deps: {
    * Returns true if the chord was consumed by the keymap, false otherwise.
    */
   handleTerminalShortcut: (chord: KeyChord) => boolean
+  /** True when the active tab is in alternate-screen mode (vim, less, htop, ...). */
+  getIsAlternateBuffer?: () => boolean
+  /** Feed a single char to the per-tab macro trigger detector. */
+  feedTrigger?: (tabId: string, char: string) => TriggerMatch | null
+  /** Expand a matched macro and inject it into the PTY (erase + paste + cursor). */
+  expandMacro?: (tabId: string, match: TriggerMatch) => void
+  /** Reset detector state when input boundaries change (paste start, mode toggle). */
+  resetTrigger?: (tabId: string) => void
+  /**
+   * Called for every keystroke immediately after a macro expansion: if the
+   * keystroke is a backspace, erase the entire expansion and return true.
+   * Any other keystroke clears the pending-undo state and returns false.
+   */
+  tryConsumeMacroUndo?: (tabId: string, sequence: string) => boolean
 }): (sequence: string) => boolean {
   let bracketedPasteBuffer: string | null = null
 
@@ -143,6 +158,7 @@ export function createRawInputHandler(deps: {
         sequencePreview: sequence.slice(0, 120),
         tabId,
       })
+      deps.resetTrigger?.(tabId)
       if (!handleSequence(tabId, sequence.slice(0, startIndex))) {
         return false
       }
@@ -158,6 +174,23 @@ export function createRawInputHandler(deps: {
       return handleSequence(tabId, afterStart.slice(endIndex + BRACKETED_PASTE_END.length))
     }
 
+    if (deps.tryConsumeMacroUndo?.(tabId, sequence) ?? false) {
+      return true
+    }
+
+    if (
+      sequence.length === 1 &&
+      deps.feedTrigger &&
+      deps.expandMacro &&
+      !(deps.getIsAlternateBuffer?.() ?? false)
+    ) {
+      const match = deps.feedTrigger(tabId, sequence)
+      if (match) {
+        deps.expandMacro(tabId, match)
+        return true
+      }
+    }
+
     if (handleTerminalShortcut(sequence)) {
       return true
     }

package/src/platform/clipboard.ts

@@ -11,3 +11,17 @@ export function copyToSystemClipboard(text: string): void {
     })
   }
 }
+
+export async function readFromSystemClipboard(): Promise<string> {
+  try {
+    const proc = Bun.spawn(['pbpaste'], { stdout: 'pipe' })
+    const text = await new Response(proc.stdout).text()
+    await proc.exited
+    return text
+  } catch (error) {
+    logDebug('platform.clipboard.readError', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return ''
+  }
+}

package/src/pty/command-registry.ts

@@ -29,6 +29,12 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
     id: 'opencode',
     label: 'OpenCode',
   },
+  {
+    command: 'agy',
+    description: 'Antigravity CLI',
+    id: 'antigravity',
+    label: 'Antigravity',
+  },
   {
     command: DEFAULT_SHELL,
     description: `Plain terminal (${SHELL_NAME})`,