feat(git): add model selection for commit message generation

Allow users to choose which model generates commit messages via a
dropdown in the git diff panel. The selection persists in app settings
and falls back to the workspace default when the chosen model is no
longer available.

Author: joshhbk

.gitignore

@@ -27,6 +27,10 @@ dist-ssr
 CodexMonitor.zip
 .codex-worktrees/
 .codexmonitor/
+.agent/
+.agents/
+.claude/
+.cursor/
 public/assets/material-icons/
 
 # Nix

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -1118,22 +1118,31 @@ impl DaemonState {
         codex_aux_core::codex_doctor_core(&self.app_settings, codex_bin, codex_args).await
     }
 
-    async fn generate_commit_message(&self, workspace_id: String) -> Result<String, String> {
+    async fn generate_commit_message(
+        &self,
+        workspace_id: String,
+        commit_message_model_id: Option<String>,
+    ) -> Result<String, String> {
         let repo_root = git_ui_core::resolve_repo_root_for_workspace_core(
             &self.workspaces,
             workspace_id.clone(),
         )
         .await?;
         let diff = git_ui_core::collect_workspace_diff_core(&repo_root)?;
-        let commit_message_prompt = {
+        let (commit_message_prompt, default_commit_message_model_id) = {
             let settings = self.app_settings.lock().await;
-            settings.commit_message_prompt.clone()
+            (
+                settings.commit_message_prompt.clone(),
+                settings.commit_message_model_id.clone(),
+            )
         };
+        let commit_message_model_id = commit_message_model_id.or(default_commit_message_model_id);
         codex_aux_core::generate_commit_message_core(
             &self.sessions,
             workspace_id,
             &diff,
             &commit_message_prompt,
+            commit_message_model_id.as_deref(),
             |workspace_id, thread_id| {
                 emit_background_thread_hide(&self.event_sink, workspace_id, thread_id);
             },

src-tauri/src/bin/codex_monitor_daemon/rpc/git.rs

@@ -366,7 +366,11 @@ pub(super) async fn try_handle(
                 Ok(value) => value,
                 Err(err) => return Some(Err(err)),
             };
-            let message = match state.generate_commit_message(workspace_id).await {
+            let commit_message_model_id = parse_optional_string(params, "commitMessageModelId");
+            let message = match state
+                .generate_commit_message(workspace_id, commit_message_model_id)
+                .await
+            {
                 Ok(value) => value,
                 Err(err) => return Some(Err(err)),
             };

src-tauri/src/codex/mod.rs

@@ -736,31 +736,46 @@ pub(crate) async fn get_config_model(
 #[tauri::command]
 pub(crate) async fn generate_commit_message(
     workspace_id: String,
+    commit_message_model_id: Option<String>,
     state: State<'_, AppState>,
     app: AppHandle,
 ) -> Result<String, String> {
     if remote_backend::is_remote_mode(&*state).await {
+        let commit_message_model_id = if commit_message_model_id.is_some() {
+            commit_message_model_id
+        } else {
+            let settings = state.app_settings.lock().await;
+            settings.commit_message_model_id.clone()
+        };
         let value = remote_backend::call_remote(
             &*state,
             app,
             "generate_commit_message",
-            json!({ "workspaceId": workspace_id }),
+            json!({
+                "workspaceId": workspace_id,
+                "commitMessageModelId": commit_message_model_id,
+            }),
         )
         .await?;
         return serde_json::from_value(value).map_err(|err| err.to_string());
     }
 
     let diff = crate::git::get_workspace_diff(&workspace_id, &state).await?;
 
-    let commit_message_prompt = {
+    let (commit_message_prompt, default_commit_message_model_id) = {
         let settings = state.app_settings.lock().await;
-        settings.commit_message_prompt.clone()
+        (
+            settings.commit_message_prompt.clone(),
+            settings.commit_message_model_id.clone(),
+        )
     };
+    let commit_message_model_id = commit_message_model_id.or(default_commit_message_model_id);
     crate::shared::codex_aux_core::generate_commit_message_core(
         &state.sessions,
         workspace_id,
         &diff,
         &commit_message_prompt,
+        commit_message_model_id.as_deref(),
         |workspace_id, thread_id| {
             let _ = app.emit(
                 "app-server-event",

src-tauri/src/shared/codex_aux_core.rs

@@ -258,6 +258,7 @@ pub(crate) async fn run_background_prompt_core<F>(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,
     prompt: String,
+    model: Option<&str>,
     on_hide_thread: F,
     timeout_error: &str,
     turn_error_fallback: &str,
@@ -315,13 +316,16 @@ where
         callbacks.insert(thread_id.clone(), tx);
     }
 
-    let turn_params = json!({
+    let mut turn_params = json!({
         "threadId": thread_id,
         "input": [{ "type": "text", "text": prompt }],
         "cwd": session.entry.path,
         "approvalPolicy": "never",
         "sandboxPolicy": { "type": "readOnly" },
     });
+    if let Some(model_id) = model {
+        turn_params["model"] = json!(model_id);
+    }
     let turn_result = session.send_request("turn/start", turn_params).await;
     let turn_result = match turn_result {
         Ok(result) => result,
@@ -408,6 +412,7 @@ pub(crate) async fn generate_commit_message_core<F>(
     workspace_id: String,
     diff: &str,
     template: &str,
+    model: Option<&str>,
     on_hide_thread: F,
 ) -> Result<String, String>
 where
@@ -418,6 +423,7 @@ where
         sessions,
         workspace_id,
         prompt,
+        model,
         on_hide_thread,
         "Timeout waiting for commit message generation",
         "Unknown error during commit message generation",
@@ -444,6 +450,7 @@ where
         sessions,
         workspace_id,
         metadata_prompt,
+        None,
         on_hide_thread,
         "Timeout waiting for metadata generation",
         "Unknown error during metadata generation",

src-tauri/src/types.rs

@@ -533,6 +533,8 @@ pub(crate) struct AppSettings {
         rename = "commitMessagePrompt"
     )]
     pub(crate) commit_message_prompt: String,
+    #[serde(default, rename = "commitMessageModelId")]
+    pub(crate) commit_message_model_id: Option<String>,
     #[serde(
         default = "default_system_notifications_enabled",
         rename = "systemNotificationsEnabled"
@@ -1149,6 +1151,7 @@ impl Default for AppSettings {
             preload_git_diffs: default_preload_git_diffs(),
             git_diff_ignore_whitespace_changes: default_git_diff_ignore_whitespace_changes(),
             commit_message_prompt: default_commit_message_prompt(),
+            commit_message_model_id: None,
             experimental_collab_enabled: false,
             collaboration_modes_enabled: true,
             steer_enabled: true,

src/App.tsx

@@ -105,6 +105,7 @@ import { useWorkspaceLaunchScript } from "@app/hooks/useWorkspaceLaunchScript";
 import { useWorkspaceLaunchScripts } from "@app/hooks/useWorkspaceLaunchScripts";
 import { useWorktreeSetupScript } from "@app/hooks/useWorktreeSetupScript";
 import { useGitCommitController } from "@app/hooks/useGitCommitController";
+import { useCommitMessageModelSelection } from "@app/hooks/useCommitMessageModelSelection";
 import { WorkspaceHome } from "@/features/workspaces/components/WorkspaceHome";
 import { MobileServerSetupWizard } from "@/features/mobile/components/MobileServerSetupWizard";
 import { useMobileServerSetup } from "@/features/mobile/hooks/useMobileServerSetup";
@@ -425,6 +426,15 @@ function MainApp() {
     setAccessMode,
     persistThreadCodexParams,
   });
+  const {
+    resolvedCommitMessageModelId,
+    onCommitMessageModelChange,
+  } = useCommitMessageModelSelection({
+    models,
+    commitMessageModelId: appSettings.commitMessageModelId,
+    setAppSettings,
+    queueSaveSettings,
+  });
 
   const composerShortcuts = {
     modelShortcut: appSettings.composerModelShortcut,
@@ -1428,6 +1438,7 @@ function MainApp() {
     activeWorkspace,
     activeWorkspaceId,
     activeWorkspaceIdRef,
+    commitMessageModelId: resolvedCommitMessageModelId,
     gitStatus,
     refreshGitStatus,
     refreshGitLog,
@@ -2160,6 +2171,8 @@ function MainApp() {
     commitMessageError,
     onCommitMessageChange: handleCommitMessageChange,
     onGenerateCommitMessage: handleGenerateCommitMessage,
+    commitMessageModelId: resolvedCommitMessageModelId,
+    onCommitMessageModelChange,
     onCommit: handleCommit,
     onCommitAndPush: handleCommitAndPush,
     onCommitAndSync: handleCommitAndSync,

src/features/app/hooks/useCommitMessageModelSelection.ts

@@ -0,0 +1,54 @@
+import { useCallback, useEffect, useMemo } from "react";
+import type { Dispatch, SetStateAction } from "react";
+import type { AppSettings, ModelOption } from "@/types";
+import { resolveCommitMessageModelSelection } from "@/features/git/utils/commitMessageModelSelection";
+
+type UseCommitMessageModelSelectionOptions = {
+  models: ModelOption[];
+  commitMessageModelId: string | null;
+  setAppSettings: Dispatch<SetStateAction<AppSettings>>;
+  queueSaveSettings: (next: AppSettings) => Promise<AppSettings | void>;
+};
+
+type UseCommitMessageModelSelectionResult = {
+  resolvedCommitMessageModelId: string | null;
+  onCommitMessageModelChange: (id: string | null) => void;
+};
+
+export function useCommitMessageModelSelection({
+  models,
+  commitMessageModelId,
+  setAppSettings,
+  queueSaveSettings,
+}: UseCommitMessageModelSelectionOptions): UseCommitMessageModelSelectionResult {
+  const selection = useMemo(
+    () => resolveCommitMessageModelSelection(models, commitMessageModelId),
+    [models, commitMessageModelId],
+  );
+
+  const persistCommitMessageModelId = useCallback(
+    (id: string | null) => {
+      setAppSettings((current) => {
+        if (current.commitMessageModelId === id) {
+          return current;
+        }
+        const next = { ...current, commitMessageModelId: id };
+        void queueSaveSettings(next);
+        return next;
+      });
+    },
+    [queueSaveSettings, setAppSettings],
+  );
+
+  useEffect(() => {
+    if (!selection.shouldNormalize) {
+      return;
+    }
+    persistCommitMessageModelId(selection.normalizedModelId);
+  }, [persistCommitMessageModelId, selection.normalizedModelId, selection.shouldNormalize]);
+
+  return {
+    resolvedCommitMessageModelId: selection.resolvedModelId,
+    onCommitMessageModelChange: persistCommitMessageModelId,
+  };
+}

src/features/app/hooks/useGitCommitController.ts

@@ -18,6 +18,7 @@ type GitCommitControllerOptions = {
   activeWorkspace: WorkspaceInfo | null;
   activeWorkspaceId: string | null;
   activeWorkspaceIdRef: RefObject<string | null>;
+  commitMessageModelId: string | null;
   gitStatus: GitStatusState;
   refreshGitStatus: () => void;
   refreshGitLog?: () => void;
@@ -53,6 +54,7 @@ export function useGitCommitController({
   activeWorkspace,
   activeWorkspaceId,
   activeWorkspaceIdRef,
+  commitMessageModelId,
   gitStatus,
   refreshGitStatus,
   refreshGitLog,
@@ -100,7 +102,7 @@ export function useGitCommitController({
     setCommitMessageLoading(true);
     setCommitMessageError(null);
     try {
-      const message = await generateCommitMessage(workspaceId);
+      const message = await generateCommitMessage(workspaceId, commitMessageModelId);
       if (!shouldApplyCommitMessage(activeWorkspaceIdRef.current, workspaceId)) {
         return;
       }
@@ -117,7 +119,7 @@ export function useGitCommitController({
         setCommitMessageLoading(false);
       }
     }
-  }, [activeWorkspace, commitMessageLoading, activeWorkspaceIdRef]);
+  }, [activeWorkspace, commitMessageLoading, activeWorkspaceIdRef, commitMessageModelId]);
 
   useEffect(() => {
     setCommitMessage("");

src/features/git/components/GitDiffPanel.tsx

@@ -1,4 +1,4 @@
-import type { GitHubIssue, GitHubPullRequest, GitLogEntry } from "../../../types";
+import type { GitHubIssue, GitHubPullRequest, GitLogEntry, ModelOption } from "../../../types";
 import type { MouseEvent as ReactMouseEvent } from "react";
 import { Menu, MenuItem } from "@tauri-apps/api/menu";
 import { LogicalPosition } from "@tauri-apps/api/dpi";
@@ -127,6 +127,9 @@ type GitDiffPanelProps = {
   commitMessageError?: string | null;
   onCommitMessageChange?: (value: string) => void;
   onGenerateCommitMessage?: () => void | Promise<void>;
+  models?: ModelOption[];
+  commitMessageModelId?: string | null;
+  onCommitMessageModelChange?: (id: string | null) => void;
   // Git operations
   onCommit?: () => void | Promise<void>;
   onCommitAndPush?: () => void | Promise<void>;
@@ -216,6 +219,9 @@ export function GitDiffPanel({
   commitMessageError = null,
   onCommitMessageChange,
   onGenerateCommitMessage,
+  models = [],
+  commitMessageModelId = null,
+  onCommitMessageModelChange,
   onCommit,
   onCommitAndPush: _onCommitAndPush,
   onCommitAndSync: _onCommitAndSync,
@@ -730,6 +736,9 @@ export function GitDiffPanel({
           commitMessageLoading={commitMessageLoading}
           canGenerateCommitMessage={canGenerateCommitMessage}
           onGenerateCommitMessage={onGenerateCommitMessage}
+          models={models}
+          commitMessageModelId={commitMessageModelId}
+          onCommitMessageModelChange={onCommitMessageModelChange}
           stagedFiles={stagedFiles}
           unstagedFiles={unstagedFiles}
           commitLoading={commitLoading}