@brimveyn/aimux 1.7.3 → 1.8.0

package/README.md

@@ -1,7 +1,7 @@
 # aimux
 
 A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, and normal
-shell tabs side by side in one TUI with persistent sessions, split panes,
+shell tabs side by side in one TUI with persistent workspaces, split panes,
 snippets, themes, and fully configurable keymaps.
 
 ![Built with Bun](https://img.shields.io/badge/runtime-Bun-f9f1e1)
@@ -12,10 +12,10 @@ snippets, themes, and fully configurable keymaps.
 
 ## Features
 
-- multi-session workflow with a dedicated session picker
+- multi-workspace workflow with a dedicated workspace picker
 - tabs for `claude`, `codex`, `opencode`, and `terminal`
 - split panes with pane focus and resize shortcuts
-- persistent sessions with saved layout and tab state
+- persistent workspaces with saved layout and tab state
 - profile-isolated config, catalogs, daemon sockets, and runtime state
 - typed keymap customization through `@brimveyn/aimux-config`
 - snippets catalog and snippet picker
@@ -51,22 +51,27 @@ import { defineConfig, actions } from '@brimveyn/aimux-config'
 
 export default defineConfig({
   sessionBar: {
-    position: 'top',
-    visible: true,
+    initialPosition: 'top',
+    initialVisible: true,
   },
 
   keymaps: (k) =>
-    k.mode('navigation', (m) => m.map('<C-p>', actions.sessionPicker, 'Session picker')),
+    k.mode('navigation', (m) => m.map('<C-p>', actions.sessionPicker, 'Workspace picker')),
 })
 ```
 
+Typed config is startup intent, not app-managed persisted state. Fields like
+`sessionBar.initialVisible` and `sessionBar.initialPosition` are reapplied on
+every launch, so runtime UI changes for those fields do not stick while the
+config entry remains set.
+
 Then start the app:
 
 ```bash
 aimux
 ```
 
-On first launch, use the session picker flow to create your first session.
+On first launch, use the workspace picker flow to create your first workspace.
 
 For the full setup path, see [`docs/getting-started.md`](docs/getting-started.md).
 
@@ -95,19 +100,26 @@ profile. See [`docs/concepts/profiles.md`](docs/concepts/profiles.md).
 
 - `aimux.config.ts` or `aimux.config.js` - typed user config
 - `aimux.json` - app-managed preferences and runtime state
-- `aimux-sessions.json` - session catalog and workspace snapshots
+- `aimux-sessions.json` - workspace catalog and workspace snapshots
 - `aimux-snippets.json` - snippet catalog
 
+Rule of thumb:
+
+- `aimux.config.ts` declares startup intent
+- `aimux.json` stores app-managed runtime preferences
+- runtime actions never rewrite `aimux.config.ts`
+
 See [`docs/concepts/config-and-state.md`](docs/concepts/config-and-state.md).
 
-### Sessions
+### Workspaces
 
-Sessions are named workspaces. A session can have:
+Workspaces are the top-level user-facing concept in `aimux`. Internally, the
+runtime still uses `session` naming for compatibility. A workspace can have:
 
 - a name
 - an optional project directory
 - a persisted workspace snapshot
-- an order in the session bar and session picker
+- an order in the workspace bar and workspace picker
 
 See [`docs/guide/sessions.md`](docs/guide/sessions.md).
 
@@ -128,13 +140,13 @@ See [`docs/guide/keymaps.md`](docs/guide/keymaps.md).
 - `i` - focus terminal
 - `Ctrl+Z` - leave terminal-input mode
 - `Ctrl+N` - open new-tab modal
-- `Ctrl+G` - open session picker
+- `Ctrl+G` - open workspace picker
 - `Ctrl+S` - open snippet picker
 - `Ctrl+T` - open theme picker
 - `Ctrl+B` - toggle sidebar
 - `Ctrl+D` - enter git mode
-- `Ctrl+W b` - toggle session bar
-- `Ctrl+W 1` through `Ctrl+W 9` - switch sessions by index
+- `Ctrl+W b` - toggle workspace bar
+- `Ctrl+W 1` through `Ctrl+W 9` - switch workspaces by index
 
 The help modal reflects the resolved keymap, so it includes your overrides.
 
@@ -204,7 +216,7 @@ not collide with a globally installed `aimux` instance.
   and the source of the bundled theme catalog.
 - [herdr](https://github.com/ogulcancelik/herdr) by @ogulcancelik — the
   per-CLI assistant status heuristics (working / waiting-input / idle)
-  used in the session bar are adapted from herdr's `detect.rs` rule tables.
+  used in the workspace bar are adapted from herdr's `detect.rs` rule tables.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "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.4.5",
+    "@brimveyn/aimux-config": "0.5.0",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/auto-commit-driver.ts

@@ -0,0 +1,286 @@
+import { $ } from 'bun'
+
+import type {
+  AppAction,
+  AppState,
+  AssistantId,
+  AutoCommitState,
+  GitRefreshPayload,
+} from '../state/types'
+
+import { buildHeadlessInvocation, isSupportedProvider } from '../auto-commit/headless-commands'
+import { composePromptFromTemplate, loadBriefingTemplate } from '../auto-commit/prompt-loader'
+import { hasStagedFiles } from '../auto-commit/staging-mode'
+import { stripAnsi } from '../auto-commit/strip-ansi'
+import { runSuggestion } from '../auto-commit/suggestion-runner'
+import { workingTreeHash } from '../auto-commit/working-tree-hash'
+import { isCommandAvailable } from '../pty/command-registry'
+
+export interface TriggerInput {
+  enabled: boolean
+  assistant: AssistantId
+  hasProjectPath: boolean
+  git: GitRefreshPayload
+  sessionId: string
+  state: AutoCommitState
+  currentHash: string
+}
+
+export function shouldTriggerAutoCommit(input: TriggerInput): boolean {
+  if (!input.enabled) return false
+  if (!isSupportedProvider(input.assistant)) return false
+  if (!input.hasProjectPath) return false
+  if (input.git.files.length === 0) return false
+
+  const existing = input.state.bySession[input.sessionId]
+  if (!existing || existing.kind === 'idle') return true
+  if (existing.workingTreeHash === input.currentHash) return false
+  return true
+}
+
+export interface AutoCommitConfigSnapshot {
+  enabled: boolean
+  timeoutMs: number
+  models: Partial<Record<string, string>>
+}
+
+export interface DriverDeps {
+  getState: () => AppState
+  dispatch: (action: AppAction) => void
+  getConfig: () => AutoCommitConfigSnapshot
+  getProfileConfigRoot: () => string
+}
+
+let cachedTemplate: string | null = null
+
+async function getTemplate(deps: DriverDeps): Promise<string> {
+  if (cachedTemplate !== null) return cachedTemplate
+  cachedTemplate = await loadBriefingTemplate({ profileConfigRoot: deps.getProfileConfigRoot() })
+  return cachedTemplate
+}
+
+const UNTRACKED_FILE_BYTES_CAP = 8_000
+const SESSION_TAIL_BYTES_CAP = 8_000
+
+export function extractSessionTail(buffer: string | undefined): string {
+  if (!buffer) return '[no session tail available]'
+  const stripped = stripAnsi(buffer).trimEnd()
+  if (stripped.length === 0) return '[no session tail available]'
+  return stripped.length > SESSION_TAIL_BYTES_CAP
+    ? stripped.slice(stripped.length - SESSION_TAIL_BYTES_CAP)
+    : stripped
+}
+
+interface GatheredContext {
+  recentCommits: string
+  diff: string
+  branch: string
+}
+
+async function gatherContext(cwd: string, stagedOnly: boolean): Promise<GatheredContext | null> {
+  const logArgs = ['log', '-5', '--format=%h %s']
+  const diffArgs = stagedOnly ? ['diff', '--cached'] : ['diff', 'HEAD']
+  const branchArgs = ['rev-parse', '--abbrev-ref', 'HEAD']
+
+  // In staged-only mode we don't include untracked files: a file cannot be
+  // staged without first being tracked. Only git-diff-HEAD mode needs the
+  // untracked synthetic diffs.
+  if (stagedOnly) {
+    const [log, diff, branch] = await Promise.all([
+      $`git -C ${cwd} ${logArgs}`.quiet().nothrow(),
+      $`git -C ${cwd} ${diffArgs}`.quiet().nothrow(),
+      $`git -C ${cwd} ${branchArgs}`.quiet().nothrow(),
+    ])
+    if (log.exitCode !== 0 || diff.exitCode !== 0) return null
+    const branchName = branch.exitCode === 0 ? branch.stdout.toString().trim() : ''
+    return {
+      branch: branchName || '[unknown branch]',
+      diff: diff.stdout.toString(),
+      recentCommits: log.stdout.toString().trim(),
+    }
+  }
+
+  const untrackedArgs = ['ls-files', '--others', '--exclude-standard']
+  const [log, diff, untracked, branch] = await Promise.all([
+    $`git -C ${cwd} ${logArgs}`.quiet().nothrow(),
+    $`git -C ${cwd} ${diffArgs}`.quiet().nothrow(),
+    $`git -C ${cwd} ${untrackedArgs}`.quiet().nothrow(),
+    $`git -C ${cwd} ${branchArgs}`.quiet().nothrow(),
+  ])
+  if (log.exitCode !== 0 || diff.exitCode !== 0 || untracked.exitCode !== 0) return null
+
+  const untrackedPaths = untracked.stdout
+    .toString()
+    .split('\n')
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0)
+
+  const untrackedSections: string[] = []
+  for (const path of untrackedPaths) {
+    // git diff --no-index exits 1 when files differ (which they always do here);
+    // .nothrow() lets us read stdout regardless.
+    const diffNew = await $`git -C ${cwd} diff --no-index -- /dev/null ${path}`.quiet().nothrow()
+    const text = diffNew.stdout.toString()
+    const trimmed =
+      text.length > UNTRACKED_FILE_BYTES_CAP
+        ? `${text.slice(0, UNTRACKED_FILE_BYTES_CAP)}\n[truncated]`
+        : text
+    untrackedSections.push(trimmed || `[new file: ${path} — empty or unreadable]`)
+  }
+
+  const branchName = branch.exitCode === 0 ? branch.stdout.toString().trim() : ''
+  return {
+    branch: branchName || '[unknown branch]',
+    diff:
+      diff.stdout.toString() +
+      (untrackedSections.length > 0 ? `\n${untrackedSections.join('\n')}` : ''),
+    recentCommits: log.stdout.toString().trim(),
+  }
+}
+
+export interface ActivityTransitionArgs {
+  sessionId: string
+  tabId: string
+  assistant: AssistantId
+  projectPath: string | undefined
+  git: GitRefreshPayload | null
+}
+
+export async function onActivityTransition(
+  deps: DriverDeps,
+  args: ActivityTransitionArgs
+): Promise<void> {
+  const config = deps.getConfig()
+  if (!config.enabled) return
+  if (!args.git) return
+  const currentHash = workingTreeHash(args.git)
+
+  const state = deps.getState()
+  const should = shouldTriggerAutoCommit({
+    assistant: args.assistant,
+    currentHash,
+    enabled: config.enabled,
+    git: args.git,
+    hasProjectPath: !!args.projectPath,
+    sessionId: args.sessionId,
+    state: state.autoCommit,
+  })
+  if (!should) return
+
+  await runGeneration(deps, args, currentHash, config)
+}
+
+export async function onManualTrigger(
+  deps: DriverDeps,
+  args: ActivityTransitionArgs
+): Promise<void> {
+  const config = deps.getConfig()
+  const fail = (reason: string): void => {
+    deps.dispatch({ message: `auto-commit: ${reason}`, type: 'git-mode-set-message' })
+    deps.dispatch({ sessionId: args.sessionId, type: 'auto-commit-clear' })
+  }
+  if (!config.enabled) return fail('disabled in config')
+  if (!args.git || args.git.files.length === 0) return fail('no changes to summarise')
+  if (!args.projectPath) return fail('no project path for current session')
+
+  const currentHash = workingTreeHash(args.git)
+  const existing = deps.getState().autoCommit.bySession[args.sessionId]
+  // An in-flight generation will dispatch ready/clear; just wait for it.
+  if (existing && existing.kind === 'generating') return
+  // Manual trigger is always user-intent to regenerate, even if a ready
+  // suggestion exists at the same hash — the user explicitly asked for it.
+
+  const probe = buildHeadlessInvocation(args.assistant, '__probe__', config.models[args.assistant])
+  if (!probe) return fail(`no headless invocation for ${args.assistant}`)
+  if (!isCommandAvailable(probe.executable)) {
+    return fail(`'${probe.executable}' not found in PATH`)
+  }
+
+  await runGeneration(deps, args, currentHash, config)
+}
+
+async function runGeneration(
+  deps: DriverDeps,
+  args: ActivityTransitionArgs,
+  currentHash: string,
+  config: AutoCommitConfigSnapshot
+): Promise<void> {
+  const probe = buildHeadlessInvocation(args.assistant, '__probe__', config.models[args.assistant])
+  if (!probe) return
+  if (!isCommandAvailable(probe.executable)) return
+
+  // Supersede any in-flight generation for this session. Without this, a
+  // rapid sequence of activity transitions (each with a different working
+  // tree hash) would leak concurrent headless subprocesses until each hit
+  // its 60 s timeout — burning real API credits.
+  const existing = deps.getState().autoCommit.bySession[args.sessionId]
+  if (existing && existing.kind === 'generating') {
+    try {
+      existing.abortController.abort()
+    } catch {
+      // ignore
+    }
+  }
+
+  const controller = new AbortController()
+  deps.dispatch({
+    abortController: controller,
+    sessionId: args.sessionId,
+    startedAt: Date.now(),
+    tabId: args.tabId,
+    type: 'auto-commit-generation-started',
+    workingTreeHash: currentHash,
+  })
+
+  const template = await getTemplate(deps)
+  const stagedOnly = args.git ? hasStagedFiles(args.git) : false
+  const ctx = await gatherContext(args.projectPath as string, stagedOnly)
+  if (!ctx) {
+    deps.dispatch({ sessionId: args.sessionId, type: 'auto-commit-clear' })
+    return
+  }
+  const tab = deps.getState().tabs.find((t) => t.id === args.tabId)
+  const sessionTail = extractSessionTail(tab?.buffer)
+  const prompt = composePromptFromTemplate(template, { ...ctx, sessionTail })
+  const finalInvocation = buildHeadlessInvocation(
+    args.assistant,
+    prompt,
+    config.models[args.assistant]
+  )
+  if (!finalInvocation) {
+    deps.dispatch({ sessionId: args.sessionId, type: 'auto-commit-clear' })
+    return
+  }
+
+  const parsed = await runSuggestion({
+    invocation: finalInvocation,
+    signal: controller.signal,
+    timeoutMs: config.timeoutMs,
+  })
+  if (!parsed) {
+    deps.dispatch({ sessionId: args.sessionId, type: 'auto-commit-clear' })
+    return
+  }
+  deps.dispatch({
+    body: parsed.body,
+    generatedAt: Date.now(),
+    sessionId: args.sessionId,
+    title: parsed.title,
+    type: 'auto-commit-generation-ready',
+    workingTreeHash: currentHash,
+  })
+}
+
+export function onGitRefresh(
+  deps: DriverDeps,
+  sessionId: string,
+  payload: GitRefreshPayload
+): void {
+  const state = deps.getState()
+  const current = state.autoCommit.bySession[sessionId]
+  if (!current || current.kind === 'idle') return
+  const newHash = workingTreeHash(payload)
+  if (newHash !== current.workingTreeHash) {
+    deps.dispatch({ sessionId, type: 'auto-commit-clear' })
+  }
+}

package/src/app-runtime/auto-commit-ref.ts

@@ -0,0 +1,20 @@
+import type { ActivityTransitionArgs } from './auto-commit-driver'
+
+type TriggerFn = (args: ActivityTransitionArgs) => Promise<void>
+
+let activeTrigger: TriggerFn | null = null
+
+export function setActiveAutoCommitDriver(trigger: TriggerFn | null): void {
+  activeTrigger = trigger
+}
+
+// Identity-checked cleanup: only clears the slot if it still holds `trigger`.
+// Prevents a re-mounted hook from nulling out a live registration.
+export function clearActiveAutoCommitDriverIfMatches(trigger: TriggerFn): void {
+  if (activeTrigger === trigger) activeTrigger = null
+}
+
+export function triggerAutoCommitNow(args: ActivityTransitionArgs): Promise<void> {
+  if (!activeTrigger) return Promise.resolve()
+  return activeTrigger(args)
+}

package/src/app-runtime/backend-attach-runtime.ts

@@ -10,6 +10,7 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
+import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export function resizeSnapshotPanes(
   snapshot: WorkspaceSnapshotV1 | undefined,
@@ -21,13 +22,14 @@ export function resizeSnapshotPanes(
   }
 
   const trees = getSnapshotTrees(snapshot)
+  const intents = getSnapshotScrollIntents(snapshot)
   const bounds = createTerminalBounds(
     layoutRef.current.terminalCols,
     layoutRef.current.terminalRows
   )
   forEachSplitPaneRect(trees, bounds, (tabId, rect) => {
     const size = toTerminalContentSize(rect)
-    backend.resizeTab(tabId, size.cols, size.rows)
+    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId))
   })
 }
 

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

@@ -134,7 +134,8 @@ export function handleDeleteSessionEffect(
   state: AppState,
   backend: SessionBackend,
   dispatch: (action: AppAction) => void,
-  sessionId: string
+  sessionId: string,
+  options?: { openSessionPicker?: boolean }
 ): void {
   const remaining = deleteSessionRecords(state.sessions, sessionId)
   logInputDebug('app.session.delete', {
@@ -146,7 +147,11 @@ export function handleDeleteSessionEffect(
   if (sessionId === state.currentSessionId) {
     void backend.destroy(true)
   }
-  dispatch({ sessionId, type: 'delete-session-record' })
+  dispatch({
+    openSessionPicker: options?.openSessionPicker,
+    sessionId,
+    type: 'delete-session-record',
+  })
 }
 
 export function restartTabSession(

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

@@ -1,3 +1,4 @@
+import { isAutoCommitEnabled } from '@brimveyn/aimux-config'
 import { $ } from 'bun'
 
 import type { SideEffect } from '../input/modes/types'
@@ -38,6 +39,7 @@ import { filterThemeIds } from '../ui/filter-themes'
 import { scrollGitDiff } from '../ui/git-view-controls'
 import { applyTheme, getTransparent, setTransparent } from '../ui/theme'
 import { type ThemeId } from '../ui/themes'
+import { triggerAutoCommitNow } from './auto-commit-ref'
 import {
   handleCreateSessionEffect,
   handleDeleteSessionEffect,
@@ -100,7 +102,9 @@ function handleSelectedSessionDelete(ctx: SideEffectContext): void {
   })
 
   if (selectedSession) {
-    handleDeleteSessionEffect(state, backend, dispatch, selectedSession.id)
+    handleDeleteSessionEffect(state, backend, dispatch, selectedSession.id, {
+      openSessionPicker: true,
+    })
   }
 }
 
@@ -477,14 +481,17 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
     case 'persist-git-diff-mode-ratio': {
       const config = loadConfig()
       const persistedGitPane = config.gitPane
+      const paneRatio = persistedGitPane?.paneRatio ?? persistedGitPane?.ratio ?? 0.5
+      const embeddedRatio = persistedGitPane?.embeddedRatio ?? persistedGitPane?.ratio ?? 0.5
       saveConfig({
         ...config,
         gitPane: {
           diffModeRatio: effect.ratio,
+          embeddedRatio,
           fileListMode: persistedGitPane?.fileListMode,
           mode: persistedGitPane?.mode ?? 'embedded',
+          paneRatio,
           position: persistedGitPane?.position ?? 'bottom',
-          ratio: persistedGitPane?.ratio ?? 0.5,
           treeCompaction: persistedGitPane?.treeCompaction,
           visible: persistedGitPane?.visible ?? true,
         },
@@ -494,14 +501,17 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
     case 'persist-git-file-list-mode': {
       const config = loadConfig()
       const persistedGitPane = config.gitPane
+      const paneRatio = persistedGitPane?.paneRatio ?? persistedGitPane?.ratio ?? 0.5
+      const embeddedRatio = persistedGitPane?.embeddedRatio ?? persistedGitPane?.ratio ?? 0.5
       saveConfig({
         ...config,
         gitPane: {
           diffModeRatio: persistedGitPane?.diffModeRatio,
+          embeddedRatio,
           fileListMode: effect.mode,
           mode: persistedGitPane?.mode ?? 'embedded',
+          paneRatio,
           position: persistedGitPane?.position ?? 'bottom',
-          ratio: persistedGitPane?.ratio ?? 0.5,
           treeCompaction: persistedGitPane?.treeCompaction,
           visible: persistedGitPane?.visible ?? true,
         },
@@ -511,14 +521,17 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
     case 'persist-git-tree-compaction': {
       const config = loadConfig()
       const persistedGitPane = config.gitPane
+      const paneRatio = persistedGitPane?.paneRatio ?? persistedGitPane?.ratio ?? 0.5
+      const embeddedRatio = persistedGitPane?.embeddedRatio ?? persistedGitPane?.ratio ?? 0.5
       saveConfig({
         ...config,
         gitPane: {
           diffModeRatio: persistedGitPane?.diffModeRatio,
+          embeddedRatio,
           fileListMode: persistedGitPane?.fileListMode,
           mode: persistedGitPane?.mode ?? 'embedded',
+          paneRatio,
           position: persistedGitPane?.position ?? 'bottom',
-          ratio: persistedGitPane?.ratio ?? 0.5,
           treeCompaction: effect.enabled,
           visible: persistedGitPane?.visible ?? true,
         },
@@ -548,6 +561,17 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       void enqueueGitOp(() => runGitCommit(ctx, title, body))
       return
     }
+    case 'git-commit-auto': {
+      if (!isAutoCommitEnabled()) return
+      const { body, title } = effect
+      void enqueueGitOp(() => runGitCommitAuto(ctx, title, body))
+      return
+    }
+    case 'generate-auto-commit-now': {
+      if (!isAutoCommitEnabled()) return
+      void runGenerateAutoCommitNow(ctx, effect.sessionId)
+      return
+    }
     case 'git-push': {
       void enqueueGitOp(() => runGitPush(ctx))
       return
@@ -675,9 +699,92 @@ async function runGitCommit(ctx: SideEffectContext, title: string, body: string)
     })
     return
   }
+  clearAutoCommitForCurrentSession(ctx)
+  ctx.dispatch({ message: `committed: ${title}`, type: 'git-mode-set-message' })
+}
+
+async function runGitCommitAuto(
+  ctx: SideEffectContext,
+  title: string,
+  body: string
+): Promise<void> {
+  if (!title) {
+    ctx.dispatch({ message: 'empty commit title', type: 'git-mode-set-message' })
+    return
+  }
+  const cwd = ctx.getCurrentSessionProjectPath()
+  if (!cwd) return
+
+  // If the user has manually staged files, respect that intent and commit
+  // only the staged set — don't run `git add -A` which would sweep up
+  // unrelated unstaged/untracked changes. With nothing staged, `add -A`
+  // keeps the "commit everything" behaviour the user expects from auto-commit.
+  const hasStaged = ctx.state.gitPanel.files.some((f) => f.section === 'staged')
+  if (!hasStaged) {
+    const addArgs = ['add', '-A']
+    const addResult = await $`git -C ${cwd} ${addArgs}`.quiet().nothrow()
+    if (addResult.exitCode !== 0) {
+      ctx.dispatch({
+        message: addResult.stderr.toString().trim() || 'auto-commit: git add failed',
+        type: 'git-mode-set-message',
+      })
+      return
+    }
+  }
+
+  const commitResult = body
+    ? await $`git -C ${cwd} commit -m ${title} -m ${body}`.quiet().nothrow()
+    : await $`git -C ${cwd} commit -m ${title}`.quiet().nothrow()
+
+  if (commitResult.exitCode !== 0) {
+    ctx.dispatch({
+      message: commitResult.stderr.toString().trim() || 'auto-commit: commit failed',
+      type: 'git-mode-set-message',
+    })
+    return
+  }
+
+  clearAutoCommitForCurrentSession(ctx)
   ctx.dispatch({ message: `committed: ${title}`, type: 'git-mode-set-message' })
 }
 
+function clearAutoCommitForCurrentSession(ctx: SideEffectContext): void {
+  const sessionId = ctx.state.currentSessionId
+  if (!sessionId) return
+  ctx.dispatch({ sessionId, type: 'auto-commit-clear' })
+}
+
+async function runGenerateAutoCommitNow(ctx: SideEffectContext, sessionId: string): Promise<void> {
+  const session = ctx.state.sessions.find((s) => s.id === sessionId)
+  const panel = ctx.state.gitPanel
+  if (panel.error !== null) {
+    ctx.dispatch({ message: 'auto-commit: git panel unavailable', type: 'git-mode-set-message' })
+    ctx.dispatch({ sessionId, type: 'auto-commit-clear' })
+    return
+  }
+  const tab = ctx.activeTab
+  if (!tab) {
+    ctx.dispatch({
+      message: 'auto-commit: no active assistant tab — open a claude/codex session first',
+      type: 'git-mode-set-message',
+    })
+    ctx.dispatch({ sessionId, type: 'auto-commit-clear' })
+    return
+  }
+  await triggerAutoCommitNow({
+    assistant: tab.assistant,
+    git: {
+      ahead: panel.ahead,
+      behind: panel.behind,
+      branch: panel.branch,
+      files: panel.files,
+    },
+    projectPath: session?.projectPath,
+    sessionId,
+    tabId: tab.id,
+  })
+}
+
 async function runGitPush(ctx: SideEffectContext): Promise<void> {
   const cwd = ctx.getCurrentSessionProjectPath()
   if (!cwd) return