chore(deps): update lockfile metadata

Introduce a split-planning path for staged changes that asks supported AI
providers to group files into ordered Conventional Commit messages. The
plan is validated before execution so every staged file is assigned once
and unsafe states are rejected.

A new dialog lets users review and adjust the proposed groups before
creating the commits in sequence, with safeguards to preserve remaining
changes if something fails.

CHANGELOG.md

@@ -0,0 +1,90 @@
+# Changelog
+
+All notable user-facing changes to Gitty are documented in this file.
+
+The project uses calendar versions. Displayed release names use `YYYY.MM.DD`;
+package metadata uses the equivalent numeric form without leading zeroes where
+required by the package manager.
+
+## [2026.07.22] - 2026-07-22
+
+### Added
+
+- AI-assisted commit splitting for staged changes:
+  - analyze the staged diff and propose an ordered set of logical commits;
+  - generate an editable Conventional Commit message for every group;
+  - move files between proposed commits before applying the plan;
+  - create all accepted commits sequentially with **Commit all**.
+- Support for commit-splitting suggestions through OpenAI, Anthropic, and
+  custom OpenAI-compatible endpoints.
+
+### Changed
+
+- The commit-splitting dialog now explains why a plan cannot be applied and
+  clearly marks AI-generated commit messages as editable.
+- Safety checks prevent applying a stale plan after the staged files change
+  and reject files that contain both staged and unstaged changes.
+
+### Fixed
+
+- **Commit all** now passes a plain state snapshot to the commit workflow
+  instead of failing silently when cloning a reactive UI proxy.
+- Closing the active repository tab no longer allows an in-flight status or
+  fetch response to reopen and reactivate the closed repository.
+
+## [2026.07.21] - 2026-07-21
+
+### Added
+
+- Full Git worktree management:
+  - create a worktree from an existing branch;
+  - create a new branch and worktree together;
+  - create a detached worktree at a commit;
+  - open a worktree as a repository tab;
+  - move, lock, unlock, repair, remove, and prune worktrees.
+- A dedicated **Worktrees** entry below **Tags** in the branch panel.
+- An **Open in new worktree** action in the local branch context menu.
+- Line-level patch selection with Shift-click range selection.
+- Stage, unstage, and discard actions for selected lines while retaining the
+  existing whole-file and whole-hunk workflows.
+- Arch Linux package automation that builds from `PKGBUILD`, publishes the
+  `.pkg.tar.zst` artifact, and updates the Pacman repository database on the
+  CDN.
+- Detailed German and English help for worktrees, line-level staging, Pacman
+  installation, and release changes.
+
+### Changed
+
+- Branch deletion now uses a clearer confirmation dialog with more explicit
+  branch and upstream information.
+- Dialog backdrops blur the application instead of covering it with a nearly
+  black background.
+- Remote operations and authentication errors provide more actionable
+  feedback.
+- Build diagnostics and resource handling for the Arch package pipeline are
+  more robust.
+
+### Infrastructure
+
+- Added centralized error notifications.
+- Added structured, privacy-conscious telemetry.
+- Stabilized the Arch Linux container build and `makepkg` workflow.
+
+## [2026.7.20] - 2026-07-13
+
+### Added
+
+- AI-assisted review of staged changes before committing.
+- Optional automatic repository refresh.
+- Comprehensive German Git documentation in the built-in help.
+- Initial `PKGBUILD` and automated package version synchronization.
+
+### Changed
+
+- Redesigned the repository action toolbar and workspace status presentation.
+- Improved repository tabs, diff styling, spacing, and panel structure.
+- Improved file-history state handling.
+
+[2026.07.22]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.22
+[2026.07.21]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.21
+[2026.7.20]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.20

PKGBUILD

@@ -5,7 +5,7 @@
 # binary + desktop entry. Run `makepkg -si` from the repo root.
 
 pkgname=gitty
-pkgver=2026.7.20
+pkgver=2026.7.22
 pkgrel=1
 pkgdesc="A lightweight, modern Git client built with Tauri"
 arch=('x86_64')

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "gitty",
-  "version": "2026.7.20",
+  "version": "2026.7.22",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "gitty",
-      "version": "2026.7.20",
+      "version": "2026.7.22",
       "dependencies": {
         "@lucide/svelte": "^1.21.0",
         "@tailwindcss/vite": "^4.3.1",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitty",
-  "version": "2026.7.20",
+  "version": "2026.7.22",
   "private": true,
   "type": "module",
   "scripts": {

src-tauri/crates/commit_ai/src/cloud.rs

@@ -215,6 +215,89 @@ pub async fn review_custom(
     openai_compatible_review_request(url, api_key, model, diff).await
 }
 
+async fn openai_compatible_split_request(
+    url: String,
+    bearer: Option<&str>,
+    model: &str,
+    diff: &str,
+) -> Result<String, String> {
+    let system = "You split staged Git changes into small, logical commits. Return only JSON in this exact shape: {\"summary\":\"...\",\"groups\":[{\"message\":\"type(scope): subject\",\"reason\":\"...\",\"files\":[\"path\"]}]}. Every staged file must appear exactly once. Use only paths from the supplied staged file list. Keep messages in English and use Conventional Commits. Do not use markdown.";
+    let user =
+        format!("Analyze these staged changes and propose an ordered commit plan:\n\n{diff}");
+    let body = OpenAiRequest {
+        model: model.to_string(),
+        messages: vec![
+            OpenAiMessage {
+                role: "system",
+                content: system.to_string(),
+            },
+            OpenAiMessage {
+                role: "user",
+                content: user,
+            },
+        ],
+        temperature: 0.1,
+    };
+    let client = http_client()?;
+    let mut request = client.post(url).json(&body);
+    if let Some(key) = bearer.filter(|key| !key.trim().is_empty()) {
+        request = request.bearer_auth(key);
+    }
+    let response = request
+        .send()
+        .await
+        .map_err(|err| format!("Request to the AI model failed: {err}"))?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|err| format!("Could not read response: {err}"))?;
+    if !status.is_success() {
+        return Err(format!("API error ({status}): {text}"));
+    }
+    let parsed: OpenAiResponse =
+        serde_json::from_str(&text).map_err(|err| format!("Could not process response: {err}"))?;
+    parsed
+        .choices
+        .into_iter()
+        .next()
+        .and_then(|choice| choice.message.content)
+        .map(|content| sanitize_message(&content))
+        .filter(|content| !content.is_empty())
+        .ok_or_else(|| "The model did not return a commit plan.".to_string())
+}
+
+pub async fn split_openai(api_key: &str, model: &str, diff: &str) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("OpenAI API key is missing.".to_string());
+    }
+    openai_compatible_split_request(
+        "https://api.openai.com/v1/chat/completions".to_string(),
+        Some(api_key),
+        model,
+        diff,
+    )
+    .await
+}
+
+pub async fn split_custom(
+    base_url: &str,
+    api_key: Option<&str>,
+    model: &str,
+    diff: &str,
+) -> Result<String, String> {
+    if base_url.trim().is_empty() {
+        return Err("Endpoint URL is missing.".to_string());
+    }
+    openai_compatible_split_request(
+        format!("{}/chat/completions", base_url.trim_end_matches('/')),
+        api_key,
+        model,
+        diff,
+    )
+    .await
+}
+
 #[derive(Serialize)]
 struct AnthropicMessage {
     role: &'static str,
@@ -338,3 +421,47 @@ pub async fn review_anthropic(api_key: &str, model: &str, diff: &str) -> Result<
         .filter(|text| !text.is_empty())
         .ok_or_else(|| "The model did not return a review.".to_string())
 }
+
+pub async fn split_anthropic(api_key: &str, model: &str, diff: &str) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("Anthropic API key is missing.".to_string());
+    }
+    let system = "You split staged Git changes into small, logical commits. Return only JSON in this exact shape: {\"summary\":\"...\",\"groups\":[{\"message\":\"type(scope): subject\",\"reason\":\"...\",\"files\":[\"path\"]}]}. Every staged file must appear exactly once. Use only paths from the supplied staged file list. Keep messages in English and use Conventional Commits. Do not use markdown.".to_string();
+    let body = AnthropicRequest {
+        model: model.to_string(),
+        max_tokens: 2400,
+        system,
+        messages: vec![AnthropicMessage {
+            role: "user",
+            content: format!(
+                "Analyze these staged changes and propose an ordered commit plan:\n\n{diff}"
+            ),
+        }],
+    };
+    let client = http_client()?;
+    let response = client
+        .post("https://api.anthropic.com/v1/messages")
+        .header("x-api-key", api_key)
+        .header("anthropic-version", "2023-06-01")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|err| format!("Request to Anthropic failed: {err}"))?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|err| format!("Could not read response: {err}"))?;
+    if !status.is_success() {
+        return Err(format!("API error ({status}): {text}"));
+    }
+    let parsed: AnthropicResponse =
+        serde_json::from_str(&text).map_err(|err| format!("Could not process response: {err}"))?;
+    parsed
+        .content
+        .into_iter()
+        .find_map(|block| block.text)
+        .map(|text| sanitize_message(&text))
+        .filter(|text| !text.is_empty())
+        .ok_or_else(|| "The model did not return a commit plan.".to_string())
+}

src-tauri/crates/commit_ai/src/lib.rs

@@ -2,7 +2,7 @@ mod cloud;
 
 pub use cloud::{
     generate_anthropic, generate_custom, generate_openai, review_anthropic, review_custom,
-    review_openai,
+    review_openai, split_anthropic, split_custom, split_openai,
 };
 
 use std::{

src-tauri/src/git.rs

@@ -1643,6 +1643,127 @@ pub struct AiReviewResult {
     pub findings: Vec<AiReviewFinding>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiCommitGroup {
+    pub message: String,
+    pub reason: String,
+    pub files: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiCommitPlan {
+    pub summary: String,
+    pub groups: Vec<AiCommitGroup>,
+}
+
+fn parse_ai_commit_plan(raw: &str, staged_files: &[String]) -> Result<AiCommitPlan, String> {
+    use std::collections::HashSet;
+    let trimmed = raw.trim().trim_matches('`').trim();
+    let json = match (trimmed.find('{'), trimmed.rfind('}')) {
+        (Some(start), Some(end)) if start <= end => &trimmed[start..=end],
+        _ => return Err("The AI response did not contain a valid commit plan.".to_string()),
+    };
+    let mut plan: AiCommitPlan = serde_json::from_str(json)
+        .map_err(|error| format!("Could not process the commit plan: {error}"))?;
+    plan.groups
+        .retain(|group| !group.message.trim().is_empty() && !group.files.is_empty());
+    if plan.groups.len() < 2 {
+        return Err("The staged changes do not appear to benefit from splitting.".to_string());
+    }
+    if plan.groups.len() > 12 {
+        return Err("The AI proposed too many commit groups.".to_string());
+    }
+    let expected = staged_files.iter().cloned().collect::<HashSet<_>>();
+    let mut seen = HashSet::new();
+    for group in &mut plan.groups {
+        group.message = group.message.trim().to_string();
+        group.reason = group.reason.trim().to_string();
+        group
+            .files
+            .retain(|file| expected.contains(file) && seen.insert(file.clone()));
+        if group.files.is_empty() {
+            return Err("The AI returned an empty or duplicate commit group.".to_string());
+        }
+    }
+    if seen != expected {
+        return Err("The AI plan did not assign every staged file exactly once.".to_string());
+    }
+    plan.summary = plan.summary.trim().to_string();
+    Ok(plan)
+}
+
+#[tauri::command]
+pub async fn commit_ai_split(
+    path: String,
+    provider: String,
+    model: Option<String>,
+    api_key: Option<String>,
+    base_url: Option<String>,
+) -> Result<AiCommitPlan, String> {
+    let repo = resolve_repo(&path)?;
+    let status = status_for_repo(&repo)?;
+    let staged_files = status
+        .files
+        .iter()
+        .filter(|file| file.staged.is_some())
+        .map(|file| file.path.clone())
+        .collect::<Vec<_>>();
+    if staged_files.len() < 2 {
+        return Err("Stage at least two files before creating a split plan.".to_string());
+    }
+    if status
+        .files
+        .iter()
+        .any(|file| file.staged.is_some() && file.unstaged.is_some())
+    {
+        return Err("Files with both staged and unstaged changes cannot be split safely. Stage or discard the remaining changes first.".to_string());
+    }
+    let diff = staged_diff(&repo)?;
+    let model = model.filter(|value| !value.trim().is_empty());
+    let api_key = api_key.filter(|value| !value.trim().is_empty());
+    let base_url = base_url.filter(|value| !value.trim().is_empty());
+    let raw = match provider.as_str() {
+        "openai" => {
+            commit_ai::split_openai(
+                api_key
+                    .as_deref()
+                    .ok_or_else(|| "OpenAI API key is missing.".to_string())?,
+                model.as_deref().unwrap_or("gpt-4o-mini"),
+                &diff,
+            )
+            .await?
+        }
+        "anthropic" => {
+            commit_ai::split_anthropic(
+                api_key
+                    .as_deref()
+                    .ok_or_else(|| "Anthropic API key is missing.".to_string())?,
+                model.as_deref().unwrap_or("claude-3-5-haiku-latest"),
+                &diff,
+            )
+            .await?
+        }
+        "custom" => {
+            commit_ai::split_custom(
+                base_url
+                    .as_deref()
+                    .ok_or_else(|| "Endpoint URL is missing.".to_string())?,
+                api_key.as_deref(),
+                model
+                    .as_deref()
+                    .ok_or_else(|| "Model name is missing.".to_string())?,
+                &diff,
+            )
+            .await?
+        }
+        "local" => return Err("Commit splitting currently requires an API provider.".to_string()),
+        other => return Err(format!("Unknown AI provider: {other}")),
+    };
+    parse_ai_commit_plan(&raw, &staged_files)
+}
+
 #[derive(Deserialize)]
 struct AiReviewWireFinding {
     severity: String,
@@ -7105,4 +7226,15 @@ mod tests {
         assert_eq!(review.findings[0].file.as_deref(), Some("src/main.rs"));
         assert_eq!(review.findings[0].line, Some(42));
     }
+
+    #[test]
+    fn parse_ai_commit_plan_requires_each_staged_file_exactly_once() {
+        let files = vec!["src/app.ts".to_string(), "tests/app.test.ts".to_string()];
+        let raw = r#"{"summary":"Separate behavior and coverage","groups":[{"message":"feat(app): add behavior","reason":"Production code","files":["src/app.ts"]},{"message":"test(app): cover behavior","reason":"Tests","files":["tests/app.test.ts"]}]}"#;
+        let plan = parse_ai_commit_plan(raw, &files).expect("complete plan should parse");
+        assert_eq!(plan.groups.len(), 2);
+
+        let duplicate = r#"{"summary":"Bad plan","groups":[{"message":"feat: one","reason":"","files":["src/app.ts"]},{"message":"test: two","reason":"","files":["src/app.ts"]}]}"#;
+        assert!(parse_ai_commit_plan(duplicate, &files).is_err());
+    }
 }

src-tauri/src/main.rs

@@ -9,9 +9,9 @@ use git::{
     SearchCancellationState, add_remote, add_worktree, amend_commit, apply_file_patch,
     cancel_code_search, cancel_file_history, checkout_branch, cherry_pick_abort,
     cherry_pick_commit, cherry_pick_continue, clone_repository, commit, commit_ai_generate,
-    commit_ai_load, commit_ai_local_models, commit_ai_review, commit_ai_status, compare_commits,
-    compare_file_to_head, compare_file_to_parent, create_branch, create_tag, cred_delete,
-    cred_load, cred_save, delete_branch, delete_remote_branch, delete_tag,
+    commit_ai_load, commit_ai_local_models, commit_ai_review, commit_ai_split, commit_ai_status,
+    compare_commits, compare_file_to_head, compare_file_to_parent, create_branch, create_tag,
+    cred_delete, cred_load, cred_save, delete_branch, delete_remote_branch, delete_tag,
     diff_file_against_working_tree, fetch, get_file_blame, get_file_patch, get_remote_url,
     get_status, init_repository, last_commit_message, list_branches, list_commits,
     list_file_history, list_interactive_rebase_commits, list_reflog, list_remotes,
@@ -169,6 +169,7 @@ async fn main() {
             commit_ai_local_models,
             commit_ai_generate,
             commit_ai_review,
+            commit_ai_split,
             pull,
             push,
             fetch,

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Gitty",
-  "version": "2026.7.20",
+  "version": "2026.7.22",
   "identifier": "com.gitty",
   "build": {
     "beforeDevCommand": "npm run dev",

src/App.svelte

@@ -10,6 +10,7 @@
   import RepoTabs from "./lib/RepoTabs.svelte";
   import AiSettingsDialog from "./lib/components/AiSettingsDialog.svelte";
   import AiReviewDialog from "./lib/components/AiReviewDialog.svelte";
+  import AiCommitSplitDialog from "./lib/components/AiCommitSplitDialog.svelte";
   import AnalyticsNoticeDialog from "./lib/components/AnalyticsNoticeDialog.svelte";
   import AppSettingsDialog from "./lib/components/AppSettingsDialog.svelte";
   import BranchDeleteConfirmDialog from "./lib/components/BranchDeleteConfirmDialog.svelte";
@@ -51,6 +52,7 @@
     commit,
     commitAiGenerate,
     commitAiReview,
+    commitAiSplit,
     commitAiLoad,
     commitAiLocalModels,
     commitAiStatus,
@@ -129,6 +131,7 @@
 
   import type {
     AiReviewResult,
+    AiCommitPlan,
     AiSettings,
     AppLanguage,
     AppTheme,
@@ -285,6 +288,7 @@
   let fileHistoryLoading = false;
   let fileHistoryRequestId = 0;
   let activeFileHistoryRequestId = "";
+  let repoOpenRequestId = 0;
   let lastFileHistoryHeadHash = "";
   let commitMessage = "";
   let amendMode = false;
@@ -293,6 +297,9 @@
   let commitAiPhase: CommitAiPhase = "idle";
   let commitAiGenerating = false;
   let commitAiReviewing = false;
+  let commitAiSplitting = false;
+  let aiCommitPlan: AiCommitPlan | null = null;
+  let aiCommitSplitOpen = false;
   let aiReviewResult: AiReviewResult | null = null;
   let aiReviewOpen = false;
   let commitAiPollTimer: ReturnType<typeof setInterval> | undefined;
@@ -1034,6 +1041,75 @@
     }
   }
 
+  async function splitStagedWithAi() {
+    if (!activeRepoPath || commitAiSplitting || stagedCount < 2) return;
+    if (aiSettings.provider === "local") {
+      errorMessage = "Commit splitting currently requires OpenAI, Anthropic, or a custom endpoint.";
+      return;
+    }
+    commitAiSplitting = true;
+    errorMessage = "";
+    try {
+      if (aiSettings.provider === "openai") {
+        const cred = await credLoad("ai:openai");
+        aiCommitPlan = await commitAiSplit(activeRepoPath, { provider: "openai", model: aiSettings.openaiModel, apiKey: cred?.password });
+      } else if (aiSettings.provider === "anthropic") {
+        const cred = await credLoad("ai:anthropic");
+        aiCommitPlan = await commitAiSplit(activeRepoPath, { provider: "anthropic", model: aiSettings.anthropicModel, apiKey: cred?.password });
+      } else {
+        const cred = await credLoad("ai:custom");
+        aiCommitPlan = await commitAiSplit(activeRepoPath, {
+          provider: "custom", model: aiSettings.customModel, baseUrl: aiSettings.customBaseUrl, apiKey: cred?.password,
+        });
+      }
+      aiCommitSplitOpen = true;
+      trackEvent("ai_commit_split_planned", { provider: aiSettings.provider, groups: aiCommitPlan.groups.length });
+    } catch (error) {
+      errorMessage = errorToMessage(error);
+    } finally {
+      commitAiSplitting = false;
+    }
+  }
+
+  async function applyAiCommitPlan(plan: AiCommitPlan) {
+    if (!activeRepoPath || isBusy || commitAiSplitting) return;
+    const allFiles = plan.groups.flatMap((group) => group.files);
+    if (plan.groups.length < 2 || plan.groups.some((group) => !group.message.trim() || group.files.length === 0)) return;
+    const currentStaged = changedFiles.filter((file) => file.staged !== null).map((file) => file.path).sort();
+    if (currentStaged.join("\n") !== [...allFiles].sort().join("\n")) {
+      errorMessage = "The staged files changed after the plan was created. Generate a new split plan.";
+      return;
+    }
+    if (changedFiles.some((file) => file.staged !== null && file.unstaged !== null)) {
+      errorMessage = "A file now has both staged and unstaged changes. Stage or discard the remaining changes first.";
+      return;
+    }
+
+    commitAiSplitting = true;
+    await runOperation("Creating split commits", async () => {
+      applyStatus(await unstageFiles(activeRepoPath, currentStaged));
+      let completed = 0;
+      try {
+        for (const group of plan.groups) {
+          applyStatus(await stageFiles(activeRepoPath, group.files));
+          applyStatus(await commit(activeRepoPath, group.message.trim()));
+          completed += 1;
+        }
+      } catch (error) {
+        throw new Error(`${completed} of ${plan.groups.length} commits were created. Remaining changes are preserved and can be staged again. ${errorToMessage(error)}`);
+      }
+      aiCommitSplitOpen = false;
+      aiCommitPlan = null;
+      commitMessage = "";
+      await refreshBranchList(activeRepoPath);
+      await refreshCommitHistory(activeRepoPath);
+      await refreshExplorerFiles(activeRepoPath);
+      await refreshFileHistory(activeRepoPath);
+      trackEvent("ai_commit_split_applied", { groups: plan.groups.length, files: allFiles.length });
+    });
+    commitAiSplitting = false;
+  }
+
   // ── Updates ────────────────────────────────────────────────────────────────
 
   async function checkForUpdates() {
@@ -1956,6 +2032,7 @@
   async function openRepo(pathOverride?: string) {
     const path = (pathOverride ?? repoPath).trim();
     if (!path) { errorMessage = "Enter a repository path."; return; }
+    const requestId = ++repoOpenRequestId;
     repoPath = path;
 
     await runOperation("Opening repository", async () => {
@@ -1967,6 +2044,7 @@
       // Single backend round-trip: resolves the repo and reads status, branches,
       // commits and files in one pass instead of four sequential git calls.
       const bundle = await openRepositoryBundle(path, 100);
+      if (requestId !== repoOpenRequestId) return;
       resetRepositoryState(false);
       applyStatus(bundle.status);
       if (globalSearchBusy) void cancelGlobalSearch();
@@ -2160,8 +2238,18 @@
 
     if (!wasActive) return;
     if (next) {
+      // Switch identity immediately. Otherwise a status/fetch request for the
+      // just-closed repository can still finish while it remains active and
+      // reinsert its tab through applyStatus().
+      repoOpenRequestId += 1;
+      activeRepoPath = next.path;
+      repoPath = next.path;
+      status = null;
+      lastStatusFingerprint = "";
+      resetRepositoryState(false);
       await openRepo(next.path);
     } else {
+      repoOpenRequestId += 1;
       resetRepositoryState(true);
       activeView = "management";
     }
@@ -4440,12 +4528,14 @@
             {commitAiPhase}
             {commitAiGenerating}
             {commitAiReviewing}
+            {commitAiSplitting}
             {canAmend}
             {amendMode}
             onCommit={commitChanges}
             onCommitMessageChange={updateCommitMessage}
             onGenerateCommitMessage={generateCommitMessageWithAi}
             onReviewStaged={reviewStagedWithAi}
+            onSplitStaged={splitStagedWithAi}
             onOpenAiSettings={() => { aiSettingsOpen = true; }}
             onToggleAmend={toggleAmendMode}
             onUndoLastCommit={undoLastCommitChange}
@@ -4588,6 +4678,15 @@
   />
 {/if}
 
+{#if aiCommitSplitOpen && aiCommitPlan}
+  <AiCommitSplitDialog
+    plan={aiCommitPlan}
+    isApplying={commitAiSplitting}
+    onApply={applyAiCommitPlan}
+    onClose={() => { if (!commitAiSplitting) aiCommitSplitOpen = false; }}
+  />
+{/if}
+
 {#if linePatchOpen && linePatchFile}
   <LinePatchDialog
     file={linePatchFile}

src/lib/components/AiCommitSplitDialog.svelte

@@ -0,0 +1,103 @@
+<script lang="ts">
+  import { GitCommitHorizontal, LoaderCircle, Sparkles, X } from "@lucide/svelte";
+  import type { AiCommitPlan } from "../types";
+
+  interface Props {
+    plan: AiCommitPlan;
+    isApplying: boolean;
+    onApply: (plan: AiCommitPlan) => void;
+    onClose: () => void;
+  }
+
+  let { plan, isApplying = false, onApply, onClose }: Props = $props();
+  let draft = $state<AiCommitPlan>({ summary: "", groups: [] });
+  $effect.pre(() => {
+    if (draft.groups.length === 0) draft = structuredClone(plan);
+  });
+  let valid = $derived(draft.groups.length > 1 && draft.groups.every((group) => group.message.trim() && group.files.length));
+  let validationIssue = $derived(
+    draft.groups.findIndex((group) => group.files.length === 0) >= 0
+      ? "Every commit needs at least one file."
+      : draft.groups.findIndex((group) => !group.message.trim()) >= 0
+        ? "Every commit needs a message."
+        : "",
+  );
+
+  function setMessage(index: number, message: string) {
+    draft.groups[index].message = message;
+  }
+
+  function moveFile(file: string, from: number, to: number) {
+    if (from === to) return;
+    draft.groups[from].files = draft.groups[from].files.filter((path) => path !== file);
+    draft.groups[to].files = [...draft.groups[to].files, file];
+  }
+
+  function applyDraft() {
+    // `draft` is a deeply reactive Svelte proxy. `structuredClone(draft)`
+    // throws a DataCloneError before the callback runs, which made the button
+    // appear to do nothing. A state snapshot is a plain, cloneable object.
+    onApply($state.snapshot(draft));
+  }
+</script>
+
+<svelte:window onkeydown={(event) => { if (event.key === "Escape" && !isApplying) onClose(); }} />
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog split-dialog" role="dialog" aria-modal="true" aria-label="AI commit split">
+    <header class="dialog-header">
+      <div><span class="eyebrow">Staged changes</span><h2>Split into logical commits</h2></div>
+      <button class="dialog-close" type="button" onclick={onClose} disabled={isApplying} aria-label="Close"><X size={18} /></button>
+    </header>
+    <div class="split-intro"><Sparkles size={18} /><p>{draft.summary}</p></div>
+    <div class="split-groups">
+      {#each draft.groups as group, groupIndex}
+        <article class:empty={group.files.length === 0}>
+          <header><GitCommitHorizontal size={17} /><strong>Commit {groupIndex + 1}</strong><span>{group.files.length} files</span></header>
+          <label>
+            <span>Commit message <em>AI-generated · editable</em></span>
+            <input value={group.message} oninput={(event) => setMessage(groupIndex, event.currentTarget.value)} disabled={isApplying} />
+          </label>
+          {#if group.reason}<p>{group.reason}</p>{/if}
+          <div class="split-files">
+            {#each group.files as file}
+              <div><code>{file}</code>
+                <select value={groupIndex} onchange={(event) => moveFile(file, groupIndex, Number(event.currentTarget.value))} disabled={isApplying}>
+                  {#each draft.groups as _, target}<option value={target}>Commit {target + 1}</option>{/each}
+                </select>
+              </div>
+            {/each}
+          </div>
+        </article>
+      {/each}
+    </div>
+    <footer class="dialog-footer">
+      <p class:invalid={!!validationIssue}>{validationIssue || "Messages are generated automatically. All commits are created in this order."}</p>
+      <div><button class="btn-secondary" type="button" onclick={onClose} disabled={isApplying}>Cancel</button>
+        <button class="btn-primary" type="button" onclick={applyDraft} disabled={!valid || isApplying}>
+          {#if isApplying}<LoaderCircle class="spin" size={14} />{/if}Commit all ({draft.groups.length})
+        </button></div>
+    </footer>
+  </div>
+</div>
+
+<style>
+  .split-dialog{width:min(820px,calc(100vw - 32px));max-height:min(820px,calc(100vh - 32px));display:flex;flex-direction:column}
+  .split-intro{display:flex;gap:10px;align-items:flex-start;padding:14px 18px;border-bottom:1px solid var(--color-border-subtle);color:var(--color-ink-muted)}
+  .split-intro p{margin:0;line-height:1.5}
+  .split-groups{display:grid;gap:10px;padding:14px 18px;overflow:auto}
+  article{display:grid;gap:10px;padding:13px;border:1px solid var(--color-border-subtle);border-radius:9px;background:var(--color-surface-raised)}
+  article.empty{border-color:#d88a45}
+  article>header{display:flex;align-items:center;gap:8px;color:var(--color-ink)}
+  article>header span{margin-left:auto;color:var(--color-ink-faint);font-size:11px}
+  label{display:grid;gap:5px;color:var(--color-ink-faint);font-size:10px;font-weight:800;text-transform:uppercase}
+  label span{display:flex;align-items:center;justify-content:space-between;gap:8px}
+  label em{color:var(--color-accent);font-size:9px;font-style:normal;font-weight:700;text-transform:none}
+  input{height:34px;padding:0 10px;border:1px solid var(--color-border);border-radius:6px;background:var(--color-surface);color:var(--color-ink);font-family:var(--font-mono)}
+  article>p{margin:0;color:var(--color-ink-muted);font-size:12px;line-height:1.45}
+  .split-files{display:grid;gap:5px}
+  .split-files>div{display:flex;align-items:center;gap:10px;padding:6px 8px;border-radius:6px;background:var(--color-surface)}
+  code{min-width:0;flex:1;overflow:hidden;text-overflow:ellipsis;color:var(--color-ink-muted);font-size:11px;white-space:nowrap}
+  select{height:28px;border:1px solid var(--color-border-subtle);border-radius:5px;background:var(--color-surface-raised);color:var(--color-ink);font-size:11px}
+  .dialog-footer p.invalid{color:#e0a040}
+</style>

src/lib/components/CommitPanel.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { Check, LoaderCircle, RotateCcw, Settings, ShieldCheck, Sparkles } from "@lucide/svelte";
+  import { Check, GitCommitHorizontal, LoaderCircle, RotateCcw, Settings, ShieldCheck, Sparkles } from "@lucide/svelte";
   import type { CommitAiPhase, CommitAiProvider } from "../types";
 
   interface Props {
@@ -14,12 +14,14 @@
     commitAiPhase: CommitAiPhase;
     commitAiGenerating: boolean;
     commitAiReviewing: boolean;
+    commitAiSplitting: boolean;
     canAmend: boolean;
     amendMode: boolean;
     onCommit: () => void;
     onCommitMessageChange: (msg: string) => void;
     onGenerateCommitMessage: () => void;
     onReviewStaged: () => void;
+    onSplitStaged: () => void;
     onOpenAiSettings: () => void;
     onToggleAmend: (checked: boolean) => void;
     onUndoLastCommit: () => void;
@@ -37,12 +39,14 @@
     commitAiPhase = "idle",
     commitAiGenerating = false,
     commitAiReviewing = false,
+    commitAiSplitting = false,
     canAmend = false,
     amendMode = false,
     onCommit = () => {},
     onCommitMessageChange = () => {},
     onGenerateCommitMessage = () => {},
     onReviewStaged = () => {},
+    onSplitStaged = () => {},
     onOpenAiSettings = () => {},
     onToggleAmend = () => {},
     onUndoLastCommit = () => {},
@@ -70,6 +74,7 @@
     (commitAiProvider !== "local" || commitAiPhase === "ready"),
   );
   let canReview = $derived(canGenerate && commitAiProvider !== "local");
+  let canSplit = $derived(canReview && stagedCount > 1 && !commitAiSplitting);
 </script>
 
 <section class="panel commit-panel" aria-label="Commit">
@@ -80,6 +85,16 @@
     </div>
     <div class="commit-head-actions">
       <span class="pill pill-count">{stagedCount} staged</span>
+      <button
+        class="commit-review-button"
+        type="button"
+        onclick={onSplitStaged}
+        disabled={!canSplit}
+        title={commitAiProvider === "local" ? "Commit splitting currently requires an API provider" : "Suggest logical commits for the staged files"}
+      >
+        {#if commitAiSplitting}<LoaderCircle class="spin" size={14} aria-hidden="true" />{:else}<GitCommitHorizontal size={14} aria-hidden="true" />{/if}
+        Split
+      </button>
       <button
         class="commit-review-button"
         type="button"

src/lib/components/HelpOverlay.svelte

@@ -17,6 +17,7 @@
     Lightbulb,
     ListChecks,
     Search,
+    Sparkles,
     Wrench,
     X,
   } from "@lucide/svelte";
@@ -617,6 +618,87 @@
     },
   );
 
+  deCategories.find((category) => category.id === "app")?.sections.push(
+    {
+      id: "app-line-staging",
+      title: "Änderungen zeilenweise stagen",
+      summary: "Im Patch-Dialog kannst du nicht nur vollständige Dateien oder Hunks, sondern einzelne hinzugefügte und entfernte Zeilen für den nächsten Commit auswählen.",
+      steps: [
+        "Öffne im Bereich Unstaged den Patch einer geänderten Textdatei.",
+        "Klicke auf die Auswahlfläche vor einer grünen oder roten Zeile. Mit Shift-Klick markierst du einen zusammenhängenden Bereich.",
+        "Die Auswahlleiste zeigt die Anzahl der gewählten Zeilen. Stage selected übernimmt nur diese Auswahl in den Staging-Bereich.",
+        "Öffne denselben Dialog unter Staged und nutze Unstage selected, wenn einzelne Zeilen wieder zurück ins Arbeitsverzeichnis sollen.",
+        "Prüfe danach den Staged-Diff. Er ist die verbindliche Vorschau des nächsten Commits.",
+      ],
+      note: "Bei einer geänderten Zeile stellt Git intern meist eine entfernte und eine hinzugefügte Zeile dar. Wähle beide Seiten, wenn die vollständige Ersetzung in denselben Commit gehört.",
+    },
+    {
+      id: "app-line-discard",
+      title: "Hunks und einzelne Zeilen verwerfen",
+      summary: "Discard selected verwirft nur die markierten Zeilen; Discard Hunk verwirft den vollständigen Abschnitt. Gitty zeigt vor dem Löschen eine Sicherheitsabfrage.",
+      steps: [
+        "Kontrolliere, ob der Dialog Staged changes oder Unstaged changes anzeigt.",
+        "Markiere exakt die Zeilen, die nicht behalten werden sollen.",
+        "Lies in der Sicherheitsabfrage Pfad und Umfang und bestätige erst danach.",
+        "Aktualisiere den Patch, falls Dateien während des geöffneten Dialogs extern verändert wurden.",
+      ],
+      note: "Vorsicht: Verwerfen kann nicht zuverlässig rückgängig gemacht werden. Erstelle bei wichtigen Zwischenständen zuerst einen Commit oder Stash.",
+    },
+    {
+      id: "app-package-updates",
+      title: "Gitty unter Arch Linux installieren und aktualisieren",
+      summary: "Ein Pacman-Repository auf der CDN-Seite ermöglicht signierte, versionierte Updates. Alternativ lässt sich eine heruntergeladene .pkg.tar.zst-Datei direkt installieren.",
+      commands: [
+        { command: "sudo pacman --config /pfad/gitty-pacman.conf -Syu gitty", description: "Repository-Konfiguration für genau diesen Aufruf verwenden und Gitty aktualisieren" },
+        { command: "sudo pacman -U /pfad/gitty-<version>-x86_64.pkg.tar.zst", description: "Ein einzelnes lokales oder heruntergeladenes Paket installieren" },
+        { command: "pacman -Qi gitty", description: "Installierte Version und Paketinformationen anzeigen" },
+        { command: "pacman -Si gitty", description: "Im konfigurierten Repository verfügbare Version anzeigen" },
+      ],
+      steps: [
+        "Für normale Systemupdates trägst du das Gitty-Repository einmal dauerhaft in /etc/pacman.conf ein.",
+        "Wenn du die Systemdatei nicht ändern möchtest, gib --config bei jedem Pacman-Aufruf erneut an oder verwende ein eigenes Wrapper-Skript.",
+        "Die Build-Pipeline erzeugt das Paket aus dem PKGBUILD, aktualisiert die Repository-Datenbank und veröffentlicht beides auf dem CDN.",
+        "Pacman installiert nur dann eine neue Version, wenn Paketversion und Repository-Datenbank entsprechend aktualisiert wurden.",
+      ],
+      note: "--config gilt nur für den aktuellen Pacman-Prozess. Ein späteres sudo pacman -Syu erinnert sich nicht automatisch an den zuvor angegebenen Pfad.",
+    },
+  );
+
+  deCategories.find((category) => category.id === "branches")?.sections.push(
+    {
+      id: "branches-worktrees-concept",
+      title: "Was ein Worktree ist",
+      summary: "Ein Repository besitzt eine gemeinsame Git-Datenbank, kann aber mehrere Arbeitsordner haben. Jeder Worktree hat eigene ausgecheckte Dateien und normalerweise einen eigenen Branch; Commits und Referenzen sind sofort in allen Worktrees sichtbar.",
+      steps: [
+        "Das Haupt-Worktree ist der Ordner, den du ursprünglich als Repository geöffnet hast.",
+        "Ein zusätzlicher Worktree ist kein vollständiger Clone: Git-Objekte und Historie werden gemeinsam genutzt, nur Arbeitsordner und Index sind getrennt.",
+        "Änderungen in Dateien bleiben im jeweiligen Worktree. Ein dort erstellter Commit ist dagegen sofort Teil desselben Repositorys.",
+        "Worktrees eignen sich besonders für parallele Features, dringende Hotfixes, Reviews oder längere Builds auf einem zweiten Branch.",
+        "Für vollständig unabhängige Remotes, Konfigurationen oder Experimente ist ein eigener Clone weiterhin die passendere Wahl.",
+      ],
+      note: "Ein Branch kann normalerweise nicht gleichzeitig in zwei Worktrees ausgecheckt werden. Das verhindert, dass zwei Ordner denselben Branch widersprüchlich verändern.",
+    },
+    {
+      id: "branches-worktrees",
+      title: "Mehrere Branches mit Worktrees parallel öffnen",
+      summary: "Ein Worktree checkt einen weiteren Branch in einen eigenen Ordner aus. So kannst du an mehreren Aufgaben arbeiten, ohne Branches im Hauptordner umzuschalten oder lokale Änderungen zu stashen.",
+      steps: [
+        "Öffne im Branch-Panel unter Tags den Reiter Worktrees.",
+        "Wähle Existing branch für einen vorhandenen lokalen Branch, New branch für einen neuen Branch oder Detached für einen festen Commit ohne Branch.",
+        "Lege einen leeren Zielordner fest und erstelle den Worktree. Open tab öffnet ihn anschließend als eigenen Repository-Tab.",
+        "Move verschiebt einen nicht aktiven Worktree. Lock schützt ihn vor versehentlichem Prune oder Entfernen, etwa auf einem externen Laufwerk.",
+        "Remove löscht den Worktree-Ordner und seine Registrierung, behält aber den Branch. Prune entfernt nur veraltete Registrierungen nicht mehr vorhandener Ordner.",
+      ],
+      commands: [
+        { command: "git worktree list", description: "Alle registrierten Worktrees anzeigen" },
+        { command: "git worktree add ../projekt-fix fix/login", description: "Vorhandenen Branch in neuem Ordner auschecken" },
+        { command: "git worktree add -b feature/name ../projekt-feature main", description: "Neuen Branch und Worktree von main erstellen" },
+        { command: "git worktree prune --dry-run", description: "Veraltete Registrierungen vor dem Aufräumen prüfen" },
+      ],
+      note: "Ein Branch kann normalerweise nur in einem Worktree gleichzeitig ausgecheckt sein. Ein Worktree mit lokalen Änderungen sollte vor Remove committed, gestasht oder bewusst erzwungen entfernt werden.",
+    },
+  );
+
   deCategories.find((category) => category.id === "branches")?.sections.push(
     {
       id: "branches-strategy",
@@ -979,6 +1061,87 @@
     },
   );
 
+  enCategories.find((category) => category.id === "app")?.sections.push(
+    {
+      id: "app-line-staging",
+      title: "Stage changes line by line",
+      summary: "The patch dialog lets you prepare individual added and deleted lines instead of staging an entire file or hunk.",
+      steps: [
+        "Open the patch of a changed text file in Unstaged.",
+        "Click the selector in front of a green or red line. Shift-click selects a continuous range.",
+        "The selection bar shows the number of selected lines. Stage selected moves only that selection into Staged.",
+        "Open the same dialog under Staged and use Unstage selected to return individual lines to the working tree.",
+        "Review the Staged diff afterward. It is the authoritative preview of the next commit.",
+      ],
+      note: "Git usually represents one edited line as one deletion plus one addition. Select both sides when the complete replacement belongs in the same commit.",
+    },
+    {
+      id: "app-line-discard",
+      title: "Discard hunks or individual lines",
+      summary: "Discard selected removes only selected lines; Discard Hunk removes the complete section. Gitty shows a confirmation before deleting changes.",
+      steps: [
+        "Check whether the dialog currently shows Staged changes or Unstaged changes.",
+        "Select exactly the lines that should not be kept.",
+        "Review the file path and scope in the confirmation, then confirm.",
+        "Refresh the patch if another application changed the file while the dialog was open.",
+      ],
+      note: "Caution: discarded work cannot always be recovered. Commit or stash important intermediate work first.",
+    },
+    {
+      id: "app-package-updates",
+      title: "Install and update Gitty on Arch Linux",
+      summary: "A Pacman repository hosted on the CDN provides versioned updates. Alternatively, install a downloaded .pkg.tar.zst package directly.",
+      commands: [
+        { command: "sudo pacman --config /path/gitty-pacman.conf -Syu gitty", description: "Use the custom repository configuration for this invocation and update Gitty" },
+        { command: "sudo pacman -U /path/gitty-<version>-x86_64.pkg.tar.zst", description: "Install one local or downloaded package file" },
+        { command: "pacman -Qi gitty", description: "Show the installed version and package information" },
+        { command: "pacman -Si gitty", description: "Show the version available from configured repositories" },
+      ],
+      steps: [
+        "For regular system upgrades, add the Gitty repository to /etc/pacman.conf once.",
+        "If you do not want to change the system file, pass --config on every Pacman invocation or create a dedicated wrapper script.",
+        "The build pipeline creates the package from PKGBUILD, updates the repository database, and publishes both to the CDN.",
+        "Pacman offers an update only after both the package version and repository database have been updated.",
+      ],
+      note: "--config applies only to the current Pacman process. A later sudo pacman -Syu does not remember a previously supplied configuration path.",
+    },
+  );
+
+  enCategories.find((category) => category.id === "branches")?.sections.push(
+    {
+      id: "branches-worktrees-concept",
+      title: "What a worktree is",
+      summary: "One repository has a shared Git database but can have multiple working folders. Each worktree has its own checked-out files and usually its own branch; commits and references are immediately visible from every worktree.",
+      steps: [
+        "The main worktree is the folder you originally opened as the repository.",
+        "An additional worktree is not a full clone: Git objects and history are shared while the working folder and index remain separate.",
+        "File changes stay inside their worktree. A commit created there immediately becomes part of the shared repository.",
+        "Worktrees are useful for parallel features, urgent hotfixes, reviews, or long-running builds on another branch.",
+        "Use a separate clone when you need independent remotes, configuration, or isolated experiments.",
+      ],
+      note: "A branch normally cannot be checked out in two worktrees at once. This prevents two folders from changing the same branch inconsistently.",
+    },
+    {
+      id: "branches-worktrees",
+      title: "Open multiple branches in parallel with worktrees",
+      summary: "A worktree checks out another branch into a separate folder. This lets you work on multiple tasks without switching the main folder or stashing local changes.",
+      steps: [
+        "Open Worktrees below Tags in the Branch panel.",
+        "Choose Existing branch for a local branch, New branch to create one, or Detached for a fixed commit without a branch.",
+        "Choose an empty destination folder and create the worktree. Open tab then opens it as a separate repository tab.",
+        "Move relocates an inactive worktree. Lock protects it from accidental pruning or removal, for example while stored on an external drive.",
+        "Remove deletes the worktree folder and registration but keeps its branch. Prune removes only stale registrations for missing folders.",
+      ],
+      commands: [
+        { command: "git worktree list", description: "Show all registered worktrees" },
+        { command: "git worktree add ../project-fix fix/login", description: "Check out an existing branch in a new folder" },
+        { command: "git worktree add -b feature/name ../project-feature main", description: "Create a branch and worktree from main" },
+        { command: "git worktree prune --dry-run", description: "Preview stale registrations before pruning" },
+      ],
+      note: "A branch can normally be checked out in only one worktree at a time. Commit, stash, or deliberately force removal of local changes before removing a worktree.",
+    },
+  );
+
   enCategories.find((category) => category.id === "branches")?.sections.push(
     {
       id: "branches-strategy",
@@ -1193,6 +1356,106 @@
     },
   );
 
+  deCategories.splice(1, 0, {
+    id: "changelog",
+    label: "Neu in Gitty",
+    description: "Änderungen seit der letzten veröffentlichten Version und wichtige Neuerungen früherer Releases.",
+    sections: [
+      {
+        id: "changelog-2026-07-22",
+        title: "Version 2026.07.22",
+        summary: "Dieses Release erweitert Gitty um eine AI-gestützte Aufteilung gestagter Änderungen in logisch getrennte Commits.",
+        steps: [
+          "AI-Commit-Aufteilung: Der gestagte Diff wird analysiert und als geordneter Plan aus mehreren logisch zusammengehörenden Commits vorgeschlagen.",
+          "Für jede Gruppe wird automatisch eine editierbare Conventional-Commit-Nachricht erzeugt.",
+          "Dateien können vor dem Commit zwischen den vorgeschlagenen Gruppen verschoben werden.",
+          "Mit „Commit all“ werden alle bestätigten Gruppen sicher und der Reihe nach committed.",
+          "Der Dialog erklärt leere Gruppen oder fehlende Nachrichten und schützt vor einem zwischenzeitlich veränderten Staging-Bereich.",
+          "„Commit all“ reagiert wieder zuverlässig und bricht nicht mehr beim Kopieren des reaktiven Dialogzustands ab.",
+          "Ein geschlossenes aktives Repository kann nicht mehr durch einen verspäteten Status- oder Fetch-Request erneut geöffnet werden.",
+        ],
+        note: "Die AI-Commit-Aufteilung unterstützt OpenAI, Anthropic und eigene OpenAI-kompatible Endpunkte. In Paketdateien erscheint diese Version als 2026.7.22.",
+      },
+      {
+        id: "changelog-2026-07-21",
+        title: "Version 2026.07.21",
+        summary: "Dieses Release bündelt paralleles Arbeiten mit Worktrees, präzisere Commits und die neue Arch-Linux-Verteilung.",
+        steps: [
+          "Worktree-Verwaltung: zusätzliche Arbeitsordner erstellen, öffnen, verschieben, sperren, entsperren, reparieren, entfernen und veraltete Registrierungen aufräumen.",
+          "Worktrees sind direkt über den neuen Reiter unter Tags erreichbar; Branches lassen sich außerdem aus ihrem Kontextmenü in einem Worktree öffnen.",
+          "Zeilenweises Staging: einzelne Ergänzungen und Löschungen auswählen, per Shift-Klick Bereiche markieren sowie ausgewählte Zeilen stagen, unstagen oder verwerfen.",
+          "Sicherere Dialoge: verständlichere Branch-Löschabfrage und weichgezeichneter Hintergrund bei geöffneten Dialogen.",
+          "Arch-Linux-Pakete: automatisierter Build aus dem PKGBUILD, Veröffentlichung von .pkg.tar.zst und Repository-Datenbank für Pacman auf dem CDN.",
+          "Robustere Remote-Aktionen, zentrale Fehlermeldungen und strukturierte, datensparsame Telemetrie.",
+          "Erweiterte zweisprachige Hilfe mit Worktree-, Pacman- und Line-Staging-Anleitungen.",
+        ],
+        note: "In Paketdateien kann dieselbe Version als 2026.7.21 erscheinen, weil Paketmanager numerische Versionssegmente ohne führende Null verwenden.",
+      },
+      {
+        id: "changelog-2026-7-20",
+        title: "Version 2026.7.20",
+        summary: "Der letzte veröffentlichte Stand konzentrierte sich auf produktiveres Arbeiten, bessere Orientierung und einen stabileren Paket-Build.",
+        steps: [
+          "Vor dem Commit kann eine AI-gestützte Codeprüfung den Staged-Diff analysieren.",
+          "Automatische Aktualisierung hält Repository-Status und Arbeitsbereich auf Wunsch aktuell.",
+          "Repository-Aktionsleiste, Statusdarstellung, Tabs und Diff-Ansicht wurden übersichtlicher gestaltet.",
+          "Die integrierte Hilfe wurde um ausführliche deutsche Git-Dokumentation ergänzt.",
+          "PKGBUILD und Build-Skripte wurden für die Arch-Linux-Verteilung vorbereitet.",
+        ],
+      },
+    ],
+  });
+
+  enCategories.splice(1, 0, {
+    id: "changelog",
+    label: "What's new",
+    description: "Changes since the latest published version and notable additions from earlier releases.",
+    sections: [
+      {
+        id: "changelog-2026-07-22",
+        title: "Version 2026.07.22",
+        summary: "This release adds AI-assisted splitting of staged changes into separate logical commits.",
+        steps: [
+          "AI commit splitting analyzes the staged diff and proposes an ordered plan of logically related commits.",
+          "Every group receives an automatically generated, editable Conventional Commit message.",
+          "Files can be moved between proposed groups before committing.",
+          "Commit all safely creates every accepted group in sequence.",
+          "The dialog explains empty groups or missing messages and protects against a staging area that changed after planning.",
+          "Commit all now responds reliably instead of failing while copying reactive dialog state.",
+          "Closing the active repository no longer lets a delayed status or fetch request reopen the closed tab.",
+        ],
+        note: "AI commit splitting supports OpenAI, Anthropic, and custom OpenAI-compatible endpoints. Package metadata represents this version as 2026.7.22.",
+      },
+      {
+        id: "changelog-2026-07-21",
+        title: "Version 2026.07.21",
+        summary: "This release combines parallel worktree workflows, more precise commits, and the new Arch Linux distribution.",
+        steps: [
+          "Worktree management: create, open, move, lock, unlock, repair, remove, and prune additional working folders.",
+          "Worktrees are available from the new entry below Tags; branches can also be opened in a worktree from their context menu.",
+          "Line-level staging: select additions and deletions, Shift-click ranges, and stage, unstage, or discard selected lines.",
+          "Safer dialogs: a clearer branch deletion confirmation and a blurred background while dialogs are open.",
+          "Arch Linux packages: automated PKGBUILD builds plus publication of .pkg.tar.zst and the Pacman repository database to the CDN.",
+          "More robust remote operations, centralized error messages, and structured privacy-conscious telemetry.",
+          "Expanded bilingual help for worktrees, Pacman installation, and line-level staging.",
+        ],
+        note: "Package metadata may represent the same release as 2026.7.21 because package managers use numeric version segments without leading zeroes.",
+      },
+      {
+        id: "changelog-2026-7-20",
+        title: "Version 2026.7.20",
+        summary: "The latest published version focused on productivity, clearer navigation, and a more stable package build.",
+        steps: [
+          "AI-assisted pre-commit review can analyze the staged diff before committing.",
+          "Optional automatic refresh keeps repository status and the workspace current.",
+          "The repository action bar, status presentation, tabs, and diff view became easier to scan.",
+          "The built-in help gained comprehensive German Git documentation.",
+          "PKGBUILD and build scripts prepared the Arch Linux distribution workflow.",
+        ],
+      },
+    ],
+  });
+
   let { language = "en", onClose = () => {} }: Props = $props();
   const isGerman = $derived(language === "de");
   const categories = $derived(isGerman ? deCategories : enCategories);
@@ -1297,6 +1560,7 @@
           >
             <span class="help-nav-icon">
               {#if category.id === "start"}<Home size={17} aria-hidden="true" />
+              {:else if category.id === "changelog"}<Sparkles size={17} aria-hidden="true" />
               {:else if category.id === "app"}<BookOpen size={17} aria-hidden="true" />
               {:else if category.id === "basics"}<GitCommitHorizontal size={17} aria-hidden="true" />
               {:else if category.id === "branches"}<GitBranch size={17} aria-hidden="true" />

src/lib/git.ts

@@ -2,6 +2,7 @@ import { tracedInvoke as invoke } from "./telemetry";
 
 import type {
   AiReviewResult,
+  AiCommitPlan,
   CommitAiLocalProfile,
   CommitAiProvider,
   CommitAiStatus,
@@ -322,6 +323,16 @@ export function commitAiReview(path: string, options: CommitAiGenerateOptions):
   });
 }
 
+export function commitAiSplit(path: string, options: CommitAiGenerateOptions): Promise<AiCommitPlan> {
+  return invoke<AiCommitPlan>("commit_ai_split", {
+    path,
+    provider: options.provider,
+    model: options.model,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+  });
+}
+
 export function pull(path: string, username?: string, password?: string, strategy: PullStrategy = "merge", remote?: string, branch?: string): Promise<GitStatus> {
   return invoke<GitStatus>("pull", { path, username: username ?? null, password: password ?? null, strategy, remote: remote || null, branch: branch || null });
 }

src/lib/types.ts

@@ -37,6 +37,17 @@ export interface AiReviewResult {
   findings: AiReviewFinding[];
 }
 
+export interface AiCommitGroup {
+  message: string;
+  reason: string;
+  files: string[];
+}
+
+export interface AiCommitPlan {
+  summary: string;
+  groups: AiCommitGroup[];
+}
+
 export interface LocalModelOption {
   id: string;
   label: string;