From a6b25b4507eae6a668658b129f7df9908276db05 Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 23 Mar 2026 21:41:38 +0300
Subject: [PATCH 1/6] feat: implement source control components and
 functionality

- Added ChangeSectionHeader component for displaying section headers in the source control panel.
- Introduced CommitBox component for handling commit messages and actions.
- Created FileChangeRow component to represent individual file changes with actions for staging, unstaging, and discarding.
- Developed SourceControlView component to manage the overall source control interface, including file status and commit actions.
- Implemented git source control logic with functions for staging, unstaging, committing, and discarding changes.
- Integrated AI commit message generation functionality with API interaction for generating commit messages based on diffs.
- Added CSS styles for the new components and overall layout of the source control panel.
- Defined GitChangeStatus and related types for managing file change states.
---
 .../src/SourceControl/ChangeSectionHeader.tsx |  59 +++
 .../src/SourceControl/CommitBox.tsx           | 105 +++++
 .../src/SourceControl/FileChangeRow.tsx       | 131 ++++++
 .../src/SourceControl/SourceControl.css       | 359 +++++++++++++++
 .../src/SourceControl/SourceControlView.tsx   | 421 ++++++++++++++++++
 .../components/src/SourceControl/index.ts     |   1 +
 .../packages/shared/src/git-types.ts          |  19 +
 .../packages/shared/src/window-api.d.ts       |  23 +
 collab-electron/src/main/ai-commit.ts         | 110 +++++
 .../src/main/git-source-control.ts            | 314 +++++++++++++
 collab-electron/src/main/index.ts             |   6 +-
 collab-electron/src/main/ipc-git.ts           | 135 ++++++
 collab-electron/src/main/ipc.ts               |   2 +
 collab-electron/src/preload/universal.ts      |  26 ++
 collab-electron/src/windows/nav/src/App.tsx   |  97 +++-
 .../src/windows/settings/src/App.tsx          | 172 ++++++-
 16 files changed, 1975 insertions(+), 5 deletions(-)
 create mode 100644 collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/CommitBox.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/SourceControl.css
 create mode 100644 collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/index.ts
 create mode 100644 collab-electron/packages/shared/src/git-types.ts
 create mode 100644 collab-electron/src/main/ai-commit.ts
 create mode 100644 collab-electron/src/main/git-source-control.ts
 create mode 100644 collab-electron/src/main/ipc-git.ts

diff --git a/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx b/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
new file mode 100644
index 00000000..23930893
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
@@ -0,0 +1,59 @@
+import React, { useState } from 'react';
+import {
+	CaretDown,
+	Plus,
+	Minus,
+} from '@phosphor-icons/react';
+
+interface ChangeSectionHeaderProps {
+	title: string;
+	count: number;
+	actionIcon: 'stage' | 'unstage';
+	onAction: () => void;
+	children: React.ReactNode;
+}
+
+export function ChangeSectionHeader({
+	title,
+	count,
+	actionIcon,
+	onAction,
+	children,
+}: ChangeSectionHeaderProps) {
+	const [collapsed, setCollapsed] = useState(false);
+
+	if (count === 0) return null;
+
+	const ActionIcon = actionIcon === 'stage' ? Plus : Minus;
+	const actionTitle =
+		actionIcon === 'stage' ? 'Stage All' : 'Unstage All';
+
+	return (
+		<>
+			<div
+				className="scm-section-header"
+				onClick={() => setCollapsed((c) => !c)}
+			>
+				<span
+					className={`scm-section-chevron${collapsed ? ' collapsed' : ''}`}
+				>
+					<CaretDown size={12} weight="bold" />
+				</span>
+				<span>{title}</span>
+				<span className="scm-section-count">{count}</span>
+				<button
+					type="button"
+					className="scm-section-action"
+					title={actionTitle}
+					onClick={(e) => {
+						e.stopPropagation();
+						onAction();
+					}}
+				>
+					<ActionIcon size={14} />
+				</button>
+			</div>
+			{!collapsed && children}
+		</>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
new file mode 100644
index 00000000..aeeb6f59
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
@@ -0,0 +1,105 @@
+import React, { useCallback, useState } from 'react';
+import {
+	Check,
+	Sparkle,
+	CircleNotch,
+} from '@phosphor-icons/react';
+
+interface CommitBoxProps {
+	message: string;
+	onMessageChange: (message: string) => void;
+	hasStagedChanges: boolean;
+	hasApiKey: boolean;
+	onCommit: () => void;
+	onGenerateMessage: () => void;
+	committing: boolean;
+	generating: boolean;
+}
+
+export function CommitBox({
+	message,
+	onMessageChange,
+	hasStagedChanges,
+	hasApiKey,
+	onCommit,
+	onGenerateMessage,
+	committing,
+	generating,
+}: CommitBoxProps) {
+	const canCommit =
+		hasStagedChanges && message.trim().length > 0 && !committing;
+
+	const handleKeyDown = useCallback(
+		(e: React.KeyboardEvent) => {
+			if (
+				(e.metaKey || e.ctrlKey) &&
+				e.key === 'Enter' &&
+				canCommit
+			) {
+				e.preventDefault();
+				onCommit();
+			}
+		},
+		[canCommit, onCommit],
+	);
+
+	return (
+		<div className="scm-commit-box">
+			<textarea
+				className="scm-commit-textarea"
+				placeholder="Commit message..."
+				value={message}
+				onChange={(e) =>
+					onMessageChange(e.target.value)
+				}
+				onKeyDown={handleKeyDown}
+				rows={3}
+			/>
+			<div className="scm-commit-actions">
+				<button
+					type="button"
+					className="scm-commit-button"
+					disabled={!canCommit}
+					onClick={onCommit}
+					title="Commit (Cmd+Enter)"
+				>
+					{committing ? (
+						<CircleNotch
+							size={14}
+							className="scm-spinner"
+						/>
+					) : (
+						<Check size={14} weight="bold" />
+					)}
+					<span>
+						{committing ? 'Committing...' : 'Commit'}
+					</span>
+				</button>
+				<button
+					type="button"
+					className={`scm-ai-button${generating ? ' generating' : ''}`}
+					disabled={
+						!hasStagedChanges ||
+						!hasApiKey ||
+						generating
+					}
+					onClick={onGenerateMessage}
+					title={
+						!hasApiKey
+							? 'Set API key in Settings → AI'
+							: 'Generate commit message with AI'
+					}
+				>
+					{generating ? (
+						<CircleNotch
+							size={14}
+							className="scm-spinner"
+						/>
+					) : (
+						<Sparkle size={14} weight="fill" />
+					)}
+				</button>
+			</div>
+		</div>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx b/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
new file mode 100644
index 00000000..201d76af
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
@@ -0,0 +1,131 @@
+import React, { useCallback, useRef, useState } from 'react';
+import {
+	Plus,
+	Minus,
+	ArrowCounterClockwise,
+} from '@phosphor-icons/react';
+import { getFileIcon } from '@collab/components/TreeView';
+import type { GitChangeStatus } from '@collab/shared/git-types';
+
+interface FileChangeRowProps {
+	filename: string;
+	dir: string;
+	status: GitChangeStatus;
+	section: 'staged' | 'unstaged' | 'untracked';
+	onStage?: () => void;
+	onUnstage?: () => void;
+	onDiscard?: () => void;
+	onClick: () => void;
+}
+
+export function FileChangeRow({
+	filename,
+	dir,
+	status,
+	section,
+	onStage,
+	onUnstage,
+	onDiscard,
+	onClick,
+}: FileChangeRowProps) {
+	const [confirming, setConfirming] = useState(false);
+	const confirmTimer = useRef<ReturnType<typeof setTimeout>>();
+
+	const handleDiscard = useCallback(
+		(e: React.MouseEvent) => {
+			e.stopPropagation();
+			if (!confirming) {
+				setConfirming(true);
+				confirmTimer.current = setTimeout(
+					() => setConfirming(false),
+					3000,
+				);
+				return;
+			}
+			clearTimeout(confirmTimer.current);
+			setConfirming(false);
+			onDiscard?.();
+		},
+		[confirming, onDiscard],
+	);
+
+	const iconDef = getFileIcon(filename);
+	const IconComponent = iconDef.icon;
+
+	return (
+		<div className="scm-file-row" onClick={onClick}>
+			<span className="scm-file-icon">
+				<IconComponent
+					size={14}
+					weight="duotone"
+					style={{ color: iconDef.color }}
+				/>
+			</span>
+			<span className="scm-file-info">
+				<span className="scm-file-name">{filename}</span>
+				{dir && (
+					<span className="scm-file-dir">{dir}</span>
+				)}
+			</span>
+			<span className="scm-file-actions">
+				{confirming ? (
+					<span
+						className="scm-confirm-label"
+						onClick={handleDiscard}
+					>
+						Confirm?
+					</span>
+				) : (
+					<>
+						{section === 'staged' && onUnstage && (
+							<button
+								type="button"
+								className="scm-file-action-btn"
+								title="Unstage"
+								onClick={(e) => {
+									e.stopPropagation();
+									onUnstage();
+								}}
+							>
+								<Minus size={14} />
+							</button>
+						)}
+						{(section === 'unstaged' ||
+							section === 'untracked') &&
+							onStage && (
+								<button
+									type="button"
+									className="scm-file-action-btn"
+									title="Stage"
+									onClick={(e) => {
+										e.stopPropagation();
+										onStage();
+									}}
+								>
+									<Plus size={14} />
+								</button>
+							)}
+						{onDiscard &&
+							section !== 'untracked' && (
+								<button
+									type="button"
+									className="scm-file-action-btn discard"
+									title="Discard Changes"
+									onClick={handleDiscard}
+								>
+									<ArrowCounterClockwise
+										size={14}
+									/>
+								</button>
+							)}
+					</>
+				)}
+			</span>
+			<span
+				className={`scm-file-badge badge-${status}`}
+			>
+				{status}
+			</span>
+		</div>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControl.css b/collab-electron/packages/components/src/SourceControl/SourceControl.css
new file mode 100644
index 00000000..c9b59304
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/SourceControl.css
@@ -0,0 +1,359 @@
+/* Source Control panel */
+.scm-container {
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	overflow: hidden;
+}
+
+/* Header with branch info */
+.scm-header {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 8px 12px;
+	font-size: 12px;
+	color: var(--muted-foreground);
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	flex-shrink: 0;
+}
+
+.scm-branch-name {
+	font-family: 'IBM Plex Mono', monospace;
+	font-weight: 600;
+	color: var(--foreground);
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.scm-sync-info {
+	font-size: 11px;
+	color: var(--muted-foreground);
+	margin-left: auto;
+	white-space: nowrap;
+}
+
+.scm-refresh-button {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	background: none;
+	border: none;
+	padding: 2px;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+	margin-left: auto;
+}
+
+.scm-refresh-button:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+/* Commit box */
+.scm-commit-box {
+	display: flex;
+	flex-direction: column;
+	gap: 6px;
+	padding: 8px 12px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	flex-shrink: 0;
+}
+
+.scm-commit-textarea {
+	width: 100%;
+	min-height: 60px;
+	max-height: 120px;
+	resize: vertical;
+	padding: 8px;
+	font-size: 12px;
+	font-family: inherit;
+	background: color-mix(in srgb, var(--foreground) 5%, transparent);
+	color: var(--foreground);
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+	border-radius: 6px;
+	outline: none;
+}
+
+.scm-commit-textarea:focus {
+	border-color: color-mix(in srgb, var(--foreground) 30%, transparent);
+}
+
+.scm-commit-textarea::placeholder {
+	color: var(--muted-foreground);
+	opacity: 0.6;
+}
+
+.scm-commit-actions {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+}
+
+.scm-commit-button {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 4px;
+	flex: 1;
+	padding: 5px 10px;
+	font-size: 12px;
+	font-weight: 500;
+	cursor: pointer;
+	border: none;
+	border-radius: 6px;
+	background: var(--foreground);
+	color: var(--background);
+}
+
+.scm-commit-button:hover:not(:disabled) {
+	opacity: 0.85;
+}
+
+.scm-commit-button:disabled {
+	opacity: 0.35;
+	cursor: default;
+}
+
+.scm-ai-button {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: 5px 8px;
+	cursor: pointer;
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+	border-radius: 6px;
+	background: none;
+	color: var(--muted-foreground);
+}
+
+.scm-ai-button:hover:not(:disabled) {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.scm-ai-button:disabled {
+	opacity: 0.35;
+	cursor: default;
+}
+
+.scm-ai-button.generating {
+	color: var(--foreground);
+}
+
+/* Error message */
+.scm-error {
+	font-size: 11px;
+	color: var(--destructive);
+	padding: 0 12px 4px;
+}
+
+.scm-success {
+	font-size: 11px;
+	color: #4ade80;
+	padding: 0 12px 4px;
+}
+
+/* File change list */
+.scm-file-list {
+	flex: 1;
+	overflow-y: auto;
+	overflow-x: hidden;
+}
+
+/* Section header */
+.scm-section-header {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	padding: 6px 12px;
+	font-size: 11px;
+	font-weight: 600;
+	text-transform: uppercase;
+	letter-spacing: 0.03em;
+	color: var(--muted-foreground);
+	cursor: pointer;
+	user-select: none;
+}
+
+.scm-section-header:hover {
+	color: var(--foreground);
+}
+
+.scm-section-chevron {
+	display: flex;
+	align-items: center;
+	transition: transform 0.15s ease;
+}
+
+.scm-section-chevron.collapsed {
+	transform: rotate(-90deg);
+}
+
+.scm-section-count {
+	font-family: 'IBM Plex Mono', monospace;
+	font-size: 10px;
+	font-weight: 500;
+	color: var(--muted-foreground);
+	opacity: 0.8;
+}
+
+.scm-section-action {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	margin-left: auto;
+	padding: 2px;
+	border: none;
+	background: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+	opacity: 0;
+}
+
+.scm-section-header:hover .scm-section-action {
+	opacity: 1;
+}
+
+.scm-section-action:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+/* File change row */
+.scm-file-row {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 3px 12px 3px 24px;
+	font-size: 12px;
+	cursor: pointer;
+	user-select: none;
+}
+
+.scm-file-row:hover {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-file-icon {
+	display: flex;
+	align-items: center;
+	flex-shrink: 0;
+}
+
+.scm-file-info {
+	display: flex;
+	align-items: baseline;
+	gap: 4px;
+	min-width: 0;
+	flex: 1;
+}
+
+.scm-file-name {
+	color: var(--foreground);
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.scm-file-dir {
+	font-size: 11px;
+	color: var(--muted-foreground);
+	opacity: 0.7;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	direction: rtl;
+	text-align: left;
+}
+
+.scm-file-badge {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 16px;
+	height: 16px;
+	font-family: 'IBM Plex Mono', monospace;
+	font-size: 10px;
+	font-weight: 700;
+	border-radius: 3px;
+	flex-shrink: 0;
+}
+
+.scm-file-badge.badge-M { color: #5c9bcf; }
+.scm-file-badge.badge-A { color: #4ade80; }
+.scm-file-badge.badge-D { color: var(--destructive); }
+.scm-file-badge.badge-R { color: #a78bfa; }
+.scm-file-badge.badge-U { color: #f59e0b; }
+.scm-file-badge.badge-\\? { color: var(--muted-foreground); }
+
+.scm-file-actions {
+	display: flex;
+	align-items: center;
+	gap: 2px;
+	flex-shrink: 0;
+	opacity: 0;
+}
+
+.scm-file-row:hover .scm-file-actions {
+	opacity: 1;
+}
+
+.scm-file-action-btn {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	border: none;
+	background: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+}
+
+.scm-file-action-btn:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 10%, transparent);
+}
+
+.scm-file-action-btn.discard:hover {
+	color: var(--destructive);
+}
+
+.scm-confirm-label {
+	font-size: 10px;
+	color: var(--destructive);
+	font-weight: 600;
+}
+
+/* Empty state */
+.scm-empty {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	padding: 32px 16px;
+	text-align: center;
+	color: var(--muted-foreground);
+	font-size: 12px;
+	gap: 4px;
+}
+
+.scm-empty-icon {
+	opacity: 0.4;
+	margin-bottom: 8px;
+}
+
+/* Spinner for AI loading */
+@keyframes scm-spin {
+	from { transform: rotate(0deg); }
+	to { transform: rotate(360deg); }
+}
+
+.scm-spinner {
+	animation: scm-spin 1s linear infinite;
+	display: inline-flex;
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
new file mode 100644
index 00000000..fa19ce30
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -0,0 +1,421 @@
+import React, {
+	useCallback,
+	useEffect,
+	useRef,
+	useState,
+} from 'react';
+import {
+	GitBranch,
+	ArrowsClockwise,
+	CheckCircle,
+} from '@phosphor-icons/react';
+import type { GitStatusResult } from '@collab/shared/git-types';
+import { CommitBox } from './CommitBox';
+import { ChangeSectionHeader } from './ChangeSectionHeader';
+import { FileChangeRow } from './FileChangeRow';
+
+interface SourceControlViewProps {
+	workspacePath: string;
+	isActive?: boolean;
+	onSelectFile: (path: string) => void;
+	leadingContent?: React.ReactNode;
+}
+
+export function SourceControlView({
+	workspacePath,
+	isActive,
+	onSelectFile,
+	leadingContent,
+}: SourceControlViewProps) {
+	const [status, setStatus] =
+		useState<GitStatusResult | null>(null);
+	const [commitMessage, setCommitMessage] = useState('');
+	const [committing, setCommitting] = useState(false);
+	const [generating, setGenerating] = useState(false);
+	const [hasApiKey, setHasApiKey] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+	const [success, setSuccess] = useState<string | null>(
+		null,
+	);
+	const refreshTimer = useRef<ReturnType<typeof setTimeout>>();
+
+	const refresh = useCallback(async () => {
+		try {
+			const result = await window.api.gitStatus();
+			setStatus(result);
+		} catch (err) {
+			setStatus({
+				branch: '',
+				ahead: 0,
+				behind: 0,
+				staged: [],
+				unstaged: [],
+				untracked: [],
+				isGitRepo: false,
+			});
+		}
+	}, []);
+
+	// Initial load
+	useEffect(() => {
+		refresh();
+		window.api
+			.aiHasKey()
+			.then(setHasApiKey)
+			.catch(() => {});
+	}, [workspacePath, refresh]);
+
+	// Auto-refresh on file changes (debounced)
+	useEffect(() => {
+		if (!isActive) return;
+		return window.api.onFsChanged(() => {
+			clearTimeout(refreshTimer.current);
+			refreshTimer.current = setTimeout(refresh, 200);
+		});
+	}, [isActive, refresh]);
+
+	// Cleanup timer
+	useEffect(() => {
+		return () => clearTimeout(refreshTimer.current);
+	}, []);
+
+	const handleStage = useCallback(
+		async (paths: string[]) => {
+			try {
+				await window.api.gitStage(paths);
+				await refresh();
+			} catch (err) {
+				setError(
+					err instanceof Error
+						? err.message
+						: 'Failed to stage',
+				);
+			}
+		},
+		[refresh],
+	);
+
+	const handleUnstage = useCallback(
+		async (paths: string[]) => {
+			try {
+				await window.api.gitUnstage(paths);
+				await refresh();
+			} catch (err) {
+				setError(
+					err instanceof Error
+						? err.message
+						: 'Failed to unstage',
+				);
+			}
+		},
+		[refresh],
+	);
+
+	const handleStageAll = useCallback(async () => {
+		try {
+			await window.api.gitStageAll();
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Failed to stage all',
+			);
+		}
+	}, [refresh]);
+
+	const handleUnstageAll = useCallback(async () => {
+		try {
+			await window.api.gitUnstageAll();
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Failed to unstage all',
+			);
+		}
+	}, [refresh]);
+
+	const handleDiscard = useCallback(
+		async (paths: string[]) => {
+			try {
+				await window.api.gitDiscard(paths);
+				await refresh();
+			} catch (err) {
+				setError(
+					err instanceof Error
+						? err.message
+						: 'Failed to discard',
+				);
+			}
+		},
+		[refresh],
+	);
+
+	const handleCommit = useCallback(async () => {
+		if (!commitMessage.trim()) return;
+		setCommitting(true);
+		setError(null);
+		setSuccess(null);
+		try {
+			const result = await window.api.gitCommit(
+				commitMessage,
+			);
+			setCommitMessage('');
+			setSuccess(
+				`Committed ${result.hash.slice(0, 7)}`,
+			);
+			setTimeout(() => setSuccess(null), 3000);
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Commit failed',
+			);
+		} finally {
+			setCommitting(false);
+		}
+	}, [commitMessage, refresh]);
+
+	const handleGenerateMessage = useCallback(async () => {
+		setGenerating(true);
+		setError(null);
+		try {
+			const result =
+				await window.api.gitGenerateCommitMessage();
+			setCommitMessage(result.message);
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Failed to generate message',
+			);
+		} finally {
+			setGenerating(false);
+		}
+	}, []);
+
+	// Not a git repo
+	if (status && !status.isGitRepo) {
+		return (
+			<div className="scm-container">
+				{leadingContent}
+				<div className="scm-empty">
+					<GitBranch
+						size={32}
+						weight="thin"
+						className="scm-empty-icon"
+					/>
+					<span>
+						This workspace is not a git
+						repository.
+					</span>
+				</div>
+			</div>
+		);
+	}
+
+	// Loading
+	if (!status) {
+		return (
+			<div className="scm-container">
+				{leadingContent}
+				<div className="scm-empty">
+					<span>Loading...</span>
+				</div>
+			</div>
+		);
+	}
+
+	const hasStagedChanges = status.staged.length > 0;
+	const totalChanges =
+		status.staged.length +
+		status.unstaged.length +
+		status.untracked.length;
+
+	function dirOf(filePath: string): string {
+		const lastSlash = filePath.lastIndexOf('/');
+		return lastSlash > 0
+			? filePath.slice(0, lastSlash)
+			: '';
+	}
+
+	function nameOf(filePath: string): string {
+		const lastSlash = filePath.lastIndexOf('/');
+		return lastSlash >= 0
+			? filePath.slice(lastSlash + 1)
+			: filePath;
+	}
+
+	return (
+		<div className="scm-container">
+			{leadingContent}
+
+			{/* Branch header */}
+			<div className="scm-header">
+				<GitBranch size={14} weight="bold" />
+				<span className="scm-branch-name">
+					{status.branch || 'HEAD'}
+				</span>
+				{(status.ahead > 0 ||
+					status.behind > 0) && (
+					<span className="scm-sync-info">
+						{status.ahead > 0 &&
+							`${status.ahead}↑`}
+						{status.ahead > 0 &&
+							status.behind > 0 &&
+							' '}
+						{status.behind > 0 &&
+							`${status.behind}↓`}
+					</span>
+				)}
+				<button
+					type="button"
+					className="scm-refresh-button"
+					title="Refresh"
+					onClick={refresh}
+				>
+					<ArrowsClockwise size={14} />
+				</button>
+			</div>
+
+			{/* Commit box */}
+			<CommitBox
+				message={commitMessage}
+				onMessageChange={setCommitMessage}
+				hasStagedChanges={hasStagedChanges}
+				hasApiKey={hasApiKey}
+				onCommit={handleCommit}
+				onGenerateMessage={handleGenerateMessage}
+				committing={committing}
+				generating={generating}
+			/>
+
+			{/* Status messages */}
+			{error && (
+				<div className="scm-error">{error}</div>
+			)}
+			{success && (
+				<div className="scm-success">
+					<CheckCircle
+						size={12}
+						weight="fill"
+						style={{
+							verticalAlign: 'middle',
+							marginRight: 4,
+						}}
+					/>
+					{success}
+				</div>
+			)}
+
+			{/* File list */}
+			<div className="scm-file-list">
+				{totalChanges === 0 && (
+					<div className="scm-empty">
+						<CheckCircle
+							size={32}
+							weight="thin"
+							className="scm-empty-icon"
+						/>
+						<span>
+							No changes in working tree.
+						</span>
+					</div>
+				)}
+
+				{/* Staged changes */}
+				<ChangeSectionHeader
+					title="Staged Changes"
+					count={status.staged.length}
+					actionIcon="unstage"
+					onAction={handleUnstageAll}
+				>
+					{status.staged.map((file) => (
+						<FileChangeRow
+							key={`staged-${file.path}`}
+							filename={nameOf(file.path)}
+							dir={dirOf(file.path)}
+							status={file.status}
+							section="staged"
+							onUnstage={() =>
+								handleUnstage([file.path])
+							}
+							onDiscard={() =>
+								handleDiscard([file.path])
+							}
+							onClick={() =>
+								onSelectFile(file.absPath)
+							}
+						/>
+					))}
+				</ChangeSectionHeader>
+
+				{/* Unstaged changes */}
+				<ChangeSectionHeader
+					title="Changes"
+					count={status.unstaged.length}
+					actionIcon="stage"
+					onAction={() =>
+						handleStage(
+							status.unstaged.map(
+								(f) => f.path,
+							),
+						)
+					}
+				>
+					{status.unstaged.map((file) => (
+						<FileChangeRow
+							key={`unstaged-${file.path}`}
+							filename={nameOf(file.path)}
+							dir={dirOf(file.path)}
+							status={file.status}
+							section="unstaged"
+							onStage={() =>
+								handleStage([file.path])
+							}
+							onDiscard={() =>
+								handleDiscard([file.path])
+							}
+							onClick={() =>
+								onSelectFile(file.absPath)
+							}
+						/>
+					))}
+				</ChangeSectionHeader>
+
+				{/* Untracked files */}
+				<ChangeSectionHeader
+					title="Untracked"
+					count={status.untracked.length}
+					actionIcon="stage"
+					onAction={() =>
+						handleStage(
+							status.untracked.map(
+								(f) => f.path,
+							),
+						)
+					}
+				>
+					{status.untracked.map((file) => (
+						<FileChangeRow
+							key={`untracked-${file.path}`}
+							filename={nameOf(file.path)}
+							dir={dirOf(file.path)}
+							status={file.status}
+							section="untracked"
+							onStage={() =>
+								handleStage([file.path])
+							}
+							onClick={() =>
+								onSelectFile(file.absPath)
+							}
+						/>
+					))}
+				</ChangeSectionHeader>
+			</div>
+		</div>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/index.ts b/collab-electron/packages/components/src/SourceControl/index.ts
new file mode 100644
index 00000000..40fcbedb
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/index.ts
@@ -0,0 +1 @@
+export { SourceControlView } from './SourceControlView';
diff --git a/collab-electron/packages/shared/src/git-types.ts b/collab-electron/packages/shared/src/git-types.ts
new file mode 100644
index 00000000..98be8830
--- /dev/null
+++ b/collab-electron/packages/shared/src/git-types.ts
@@ -0,0 +1,19 @@
+export type GitChangeStatus = "M" | "A" | "D" | "R" | "U" | "?";
+
+export interface GitFileChange {
+  path: string;
+  absPath: string;
+  status: GitChangeStatus;
+  oldPath?: string;
+}
+
+export interface GitStatusResult {
+  branch: string;
+  upstream?: string;
+  ahead: number;
+  behind: number;
+  staged: GitFileChange[];
+  unstaged: GitFileChange[];
+  untracked: GitFileChange[];
+  isGitRepo: boolean;
+}
diff --git a/collab-electron/packages/shared/src/window-api.d.ts b/collab-electron/packages/shared/src/window-api.d.ts
index 9e254c75..e28086db 100644
--- a/collab-electron/packages/shared/src/window-api.d.ts
+++ b/collab-electron/packages/shared/src/window-api.d.ts
@@ -4,6 +4,7 @@ import type {
   TreeNode,
 } from "./types";
 import type { ReplayMessage } from "./replay-types";
+import type { GitStatusResult } from "./git-types";
 
 type Unsubscribe = () => void;
 
@@ -366,6 +367,28 @@ export interface CollabApi {
 
   // Canvas pinch forwarding
   forwardPinch: (deltaY: number) => void;
+
+  // Git source control
+  gitStatus: () => Promise<GitStatusResult>;
+  gitStage: (paths: string[]) => Promise<void>;
+  gitUnstage: (paths: string[]) => Promise<void>;
+  gitStageAll: () => Promise<void>;
+  gitUnstageAll: () => Promise<void>;
+  gitDiscard: (paths: string[]) => Promise<void>;
+  gitDiscardAll: () => Promise<void>;
+  gitCommit: (message: string) => Promise<{ hash: string }>;
+  gitDiff: (
+    filePath: string,
+    cached: boolean,
+  ) => Promise<string>;
+  gitGenerateCommitMessage: () => Promise<{
+    message: string;
+    model: string;
+  }>;
+  aiValidateKey: (
+    key: string,
+  ) => Promise<{ valid: boolean }>;
+  aiHasKey: () => Promise<boolean>;
 }
 
 declare global {
diff --git a/collab-electron/src/main/ai-commit.ts b/collab-electron/src/main/ai-commit.ts
new file mode 100644
index 00000000..89220c46
--- /dev/null
+++ b/collab-electron/src/main/ai-commit.ts
@@ -0,0 +1,110 @@
+const MAX_DIFF_CHARS = 100_000;
+const API_URL = "https://api.anthropic.com/v1/messages";
+const API_VERSION = "2023-06-01";
+const MODEL = "claude-sonnet-4-20250514";
+
+const SYSTEM_PROMPT = `You are a commit message generator. Analyze the provided git diff and write a concise, conventional commit message.
+
+Rules:
+1. Use conventional commits format: type(scope): description
+2. Types: feat, fix, refactor, docs, style, test, chore, perf, ci, build
+3. The first line MUST be 72 characters or fewer
+4. Focus on WHY the change was made, not WHAT changed (the diff shows what)
+5. If the scope is obvious from the diff, include it; otherwise omit it
+6. For complex changes, add a blank line then a brief body (2-3 bullet points max)
+7. Do not wrap the message in markdown code fences or quotes
+8. Do not include the diff in your response
+9. If the diff is truncated, infer intent from the visible portion
+
+Output ONLY the commit message text, nothing else.`;
+
+function prepareDiff(rawDiff: string): string {
+  if (rawDiff.length <= MAX_DIFF_CHARS) return rawDiff;
+
+  const lines = rawDiff.split("\n");
+  let charCount = 0;
+  let cutLine = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    charCount += lines[i]!.length + 1;
+    if (charCount > MAX_DIFF_CHARS) {
+      cutLine = i;
+      break;
+    }
+  }
+
+  const truncated = lines.slice(0, cutLine).join("\n");
+  return `${truncated}\n\n[TRUNCATED -- showing first ${cutLine} of ${lines.length} lines]`;
+}
+
+interface ApiResponse {
+  content: Array<{ type: string; text: string }>;
+  model: string;
+}
+
+interface ApiError {
+  error?: { type: string; message: string };
+}
+
+export async function generateCommitMessage(
+  apiKey: string,
+  diff: string,
+): Promise<{ message: string; model: string }> {
+  const preparedDiff = prepareDiff(diff);
+
+  const res = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": API_VERSION,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      max_tokens: 512,
+      system: SYSTEM_PROMPT,
+      messages: [{ role: "user", content: preparedDiff }],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = (await res.json().catch(() => ({}))) as ApiError;
+    const detail = body.error?.message ?? res.statusText;
+    if (res.status === 401) {
+      throw new Error(`Invalid API key: ${detail}`);
+    }
+    if (res.status === 429) {
+      throw new Error(`Rate limit exceeded. Please try again shortly.`);
+    }
+    throw new Error(`API error (${res.status}): ${detail}`);
+  }
+
+  const data = (await res.json()) as ApiResponse;
+  const text =
+    data.content.find((c) => c.type === "text")?.text ?? "";
+
+  return { message: text.trim(), model: data.model };
+}
+
+export async function validateApiKey(
+  key: string,
+): Promise<boolean> {
+  try {
+    const res = await fetch(API_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": key,
+        "anthropic-version": API_VERSION,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        model: MODEL,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }],
+      }),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
diff --git a/collab-electron/src/main/git-source-control.ts b/collab-electron/src/main/git-source-control.ts
new file mode 100644
index 00000000..9b0c675e
--- /dev/null
+++ b/collab-electron/src/main/git-source-control.ts
@@ -0,0 +1,314 @@
+import { execFile } from "node:child_process";
+import { accessSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import type {
+  GitChangeStatus,
+  GitFileChange,
+  GitStatusResult,
+} from "@collab/shared/git-types";
+
+const execFileAsync = promisify(execFile);
+const MAX_BUFFER = 50 * 1024 * 1024;
+
+async function git(
+  args: string[],
+  cwd: string,
+): Promise<string> {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    maxBuffer: MAX_BUFFER,
+  });
+  return stdout;
+}
+
+export function isGitRepo(cwd: string): boolean {
+  try {
+    accessSync(join(cwd, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function assertGitRepo(cwd: string): void {
+  if (!isGitRepo(cwd)) {
+    throw new Error("Not a git repository");
+  }
+}
+
+/**
+ * Parse `git status --porcelain=v2 --branch` output.
+ *
+ * Header lines start with `#`:
+ *   # branch.oid <hash>
+ *   # branch.head <name>
+ *   # branch.upstream <remote>/<branch>
+ *   # branch.ab +<ahead> -<behind>
+ *
+ * Changed entries start with `1` (ordinary) or `2` (rename/copy):
+ *   1 XY <sub> <mH> <mI> <mW> <hH> <hI> <path>
+ *   2 XY <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path>\t<origPath>
+ *
+ * Untracked entries start with `?`:
+ *   ? <path>
+ *
+ * Unmerged entries start with `u`:
+ *   u XY <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
+ */
+export async function gitStatus(
+  cwd: string,
+): Promise<GitStatusResult> {
+  if (!isGitRepo(cwd)) {
+    return {
+      branch: "",
+      ahead: 0,
+      behind: 0,
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      isGitRepo: false,
+    };
+  }
+
+  const raw = await git(
+    ["status", "--porcelain=v2", "--branch", "-uall"],
+    cwd,
+  );
+
+  let branch = "";
+  let upstream: string | undefined;
+  let ahead = 0;
+  let behind = 0;
+  const staged: GitFileChange[] = [];
+  const unstaged: GitFileChange[] = [];
+  const untracked: GitFileChange[] = [];
+
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+
+    // Header lines
+    if (line.startsWith("# branch.head ")) {
+      branch = line.slice("# branch.head ".length);
+    } else if (line.startsWith("# branch.upstream ")) {
+      upstream = line.slice("# branch.upstream ".length);
+    } else if (line.startsWith("# branch.ab ")) {
+      const match = line.match(/\+(\d+) -(\d+)/);
+      if (match) {
+        ahead = parseInt(match[1]!, 10);
+        behind = parseInt(match[2]!, 10);
+      }
+    }
+
+    // Untracked
+    else if (line.startsWith("? ")) {
+      const path = line.slice(2);
+      untracked.push({
+        path,
+        absPath: join(cwd, path),
+        status: "?",
+      });
+    }
+
+    // Unmerged
+    else if (line.startsWith("u ")) {
+      const parts = line.split(" ");
+      // u XY sub m1 m2 m3 mW h1 h2 h3 path
+      const path = parts.slice(10).join(" ");
+      unstaged.push({
+        path,
+        absPath: join(cwd, path),
+        status: "U",
+      });
+    }
+
+    // Ordinary changed entry
+    else if (line.startsWith("1 ")) {
+      const parts = line.split(" ");
+      const xy = parts[1]!;
+      // parts[8] onwards is the path (may contain spaces)
+      const path = parts.slice(8).join(" ");
+      const indexStatus = xy[0]!;
+      const worktreeStatus = xy[1]!;
+
+      if (indexStatus !== ".") {
+        staged.push({
+          path,
+          absPath: join(cwd, path),
+          status: mapStatus(indexStatus),
+        });
+      }
+      if (worktreeStatus !== ".") {
+        unstaged.push({
+          path,
+          absPath: join(cwd, path),
+          status: mapStatus(worktreeStatus),
+        });
+      }
+    }
+
+    // Rename/copy entry
+    else if (line.startsWith("2 ")) {
+      const parts = line.split("\t");
+      const meta = parts[0]!.split(" ");
+      const xy = meta[1]!;
+      const newPath = parts[0]!.split(" ").slice(9).join(" ");
+      const oldPath = parts[1]!;
+      const indexStatus = xy[0]!;
+      const worktreeStatus = xy[1]!;
+
+      if (indexStatus !== ".") {
+        staged.push({
+          path: newPath,
+          absPath: join(cwd, newPath),
+          status: "R",
+          oldPath,
+        });
+      }
+      if (worktreeStatus !== ".") {
+        unstaged.push({
+          path: newPath,
+          absPath: join(cwd, newPath),
+          status: "R",
+          oldPath,
+        });
+      }
+    }
+  }
+
+  return {
+    branch,
+    upstream,
+    ahead,
+    behind,
+    staged,
+    unstaged,
+    untracked,
+    isGitRepo: true,
+  };
+}
+
+function mapStatus(char: string): GitChangeStatus {
+  switch (char) {
+    case "M":
+      return "M";
+    case "A":
+      return "A";
+    case "D":
+      return "D";
+    case "R":
+      return "R";
+    case "C":
+      return "A"; // copy treated as add
+    case "U":
+      return "U";
+    default:
+      return "M";
+  }
+}
+
+export async function gitStage(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  if (paths.length === 0) return;
+  await git(["add", "--", ...paths], cwd);
+}
+
+export async function gitUnstage(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  if (paths.length === 0) return;
+  await git(["restore", "--staged", "--", ...paths], cwd);
+}
+
+export async function gitStageAll(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["add", "-A"], cwd);
+}
+
+export async function gitUnstageAll(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  try {
+    await git(["reset", "HEAD"], cwd);
+  } catch {
+    // reset HEAD fails on repos with no commits; use rm --cached instead
+    await git(["rm", "--cached", "-r", "."], cwd);
+  }
+}
+
+export async function gitDiscard(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  if (paths.length === 0) return;
+
+  // Separate tracked (checkout) vs untracked (clean) files
+  const statusRaw = await git(
+    ["status", "--porcelain", "--", ...paths],
+    cwd,
+  );
+
+  const untrackedPaths: string[] = [];
+  const trackedPaths: string[] = [];
+
+  for (const line of statusRaw.split("\n")) {
+    if (!line) continue;
+    const status = line.slice(0, 2);
+    const filePath = line.slice(3);
+    if (status === "??") {
+      untrackedPaths.push(filePath);
+    } else {
+      trackedPaths.push(filePath);
+    }
+  }
+
+  if (trackedPaths.length > 0) {
+    await git(["checkout", "--", ...trackedPaths], cwd);
+  }
+  if (untrackedPaths.length > 0) {
+    await git(["clean", "-f", "--", ...untrackedPaths], cwd);
+  }
+}
+
+export async function gitDiscardAll(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["checkout", "--", "."], cwd);
+  await git(["clean", "-fd"], cwd);
+}
+
+export async function gitCommit(
+  cwd: string,
+  message: string,
+): Promise<{ hash: string }> {
+  assertGitRepo(cwd);
+  if (!message.trim()) {
+    throw new Error("Commit message cannot be empty");
+  }
+  const output = await git(["commit", "-m", message], cwd);
+  // Extract short hash from output like "[branch abc1234] message"
+  const match = output.match(/\[.+\s+([a-f0-9]+)\]/);
+  const hash = match?.[1] ?? "";
+  return { hash };
+}
+
+export async function gitDiff(
+  cwd: string,
+  filePath: string,
+  cached: boolean,
+): Promise<string> {
+  assertGitRepo(cwd);
+  const args = ["diff"];
+  if (cached) args.push("--cached");
+  args.push("--", filePath);
+  return git(args, cwd);
+}
+
+export async function gitDiffCached(cwd: string): Promise<string> {
+  assertGitRepo(cwd);
+  return git(["diff", "--cached"], cwd);
+}
diff --git a/collab-electron/src/main/index.ts b/collab-electron/src/main/index.ts
index 23bb006c..d180d69e 100644
--- a/collab-electron/src/main/index.ts
+++ b/collab-electron/src/main/index.ts
@@ -550,7 +550,11 @@ ipcMain.handle("shell:get-view-config", () => {
 
 ipcMain.handle(
   "pref:get",
-  (_event, key: string) => getPref(config, key),
+  (_event, key: string) => {
+    // Never expose API keys to renderer processes
+    if (key === "ai.apiKey") return null;
+    return getPref(config, key);
+  },
 );
 
 ipcMain.handle(
diff --git a/collab-electron/src/main/ipc-git.ts b/collab-electron/src/main/ipc-git.ts
new file mode 100644
index 00000000..e0c7ad3c
--- /dev/null
+++ b/collab-electron/src/main/ipc-git.ts
@@ -0,0 +1,135 @@
+import { ipcMain } from "electron";
+import type { AppConfig } from "./config";
+import {
+  gitStatus,
+  gitStage,
+  gitUnstage,
+  gitStageAll,
+  gitUnstageAll,
+  gitDiscard,
+  gitDiscardAll,
+  gitCommit,
+  gitDiff,
+  gitDiffCached,
+} from "./git-source-control";
+import {
+  generateCommitMessage,
+  validateApiKey,
+} from "./ai-commit";
+
+export interface IpcGitContext {
+  config: () => AppConfig;
+}
+
+function activeWorkspacePath(config: AppConfig): string {
+  return config.workspaces[0] ?? "";
+}
+
+export function registerGitHandlers(ctx: IpcGitContext): void {
+  ipcMain.handle("git:status", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) {
+      return {
+        branch: "",
+        ahead: 0,
+        behind: 0,
+        staged: [],
+        unstaged: [],
+        untracked: [],
+        isGitRepo: false,
+      };
+    }
+    return gitStatus(cwd);
+  });
+
+  ipcMain.handle(
+    "git:stage",
+    async (_event, paths: string[]) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitStage(cwd, paths);
+    },
+  );
+
+  ipcMain.handle(
+    "git:unstage",
+    async (_event, paths: string[]) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitUnstage(cwd, paths);
+    },
+  );
+
+  ipcMain.handle("git:stage-all", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitStageAll(cwd);
+  });
+
+  ipcMain.handle("git:unstage-all", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitUnstageAll(cwd);
+  });
+
+  ipcMain.handle(
+    "git:discard",
+    async (_event, paths: string[]) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitDiscard(cwd, paths);
+    },
+  );
+
+  ipcMain.handle("git:discard-all", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitDiscardAll(cwd);
+  });
+
+  ipcMain.handle(
+    "git:commit",
+    async (_event, message: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      return gitCommit(cwd, message);
+    },
+  );
+
+  ipcMain.handle(
+    "git:diff",
+    async (_event, filePath: string, cached: boolean) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      return gitDiff(cwd, filePath, cached);
+    },
+  );
+
+  ipcMain.handle("git:generate-commit-message", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    const apiKey = ctx.config().ui?.["ai.apiKey"];
+    if (typeof apiKey !== "string" || !apiKey) {
+      throw new Error(
+        "No API key configured. Add your Anthropic API key in Settings → AI.",
+      );
+    }
+    const diff = await gitDiffCached(cwd);
+    if (!diff.trim()) {
+      throw new Error("No staged changes found. Stage files first.");
+    }
+    return generateCommitMessage(apiKey, diff);
+  });
+
+  ipcMain.handle(
+    "ai:validate-key",
+    async (_event, key: string) => {
+      return { valid: await validateApiKey(key) };
+    },
+  );
+
+  ipcMain.handle("ai:has-key", () => {
+    const key = ctx.config().ui?.["ai.apiKey"];
+    return typeof key === "string" && key.length > 0;
+  });
+}
diff --git a/collab-electron/src/main/ipc.ts b/collab-electron/src/main/ipc.ts
index a96f823d..af61e383 100644
--- a/collab-electron/src/main/ipc.ts
+++ b/collab-electron/src/main/ipc.ts
@@ -17,6 +17,7 @@ import {
 import { registerKnowledgeHandlers } from "./ipc-knowledge";
 import { registerCanvasHandlers } from "./ipc-canvas";
 import { registerMiscHandlers } from "./ipc-misc";
+import { registerGitHandlers } from "./ipc-git";
 
 const FS_CHANGE_DELETED = 3;
 
@@ -132,4 +133,5 @@ export function registerIpcHandlers(config: AppConfig): void {
   registerKnowledgeHandlers(knowledgeCtx);
   registerCanvasHandlers(canvasCtx);
   registerMiscHandlers(miscCtx);
+  registerGitHandlers({ config: () => appConfig });
 }
diff --git a/collab-electron/src/preload/universal.ts b/collab-electron/src/preload/universal.ts
index 030bb989..d4e18948 100644
--- a/collab-electron/src/preload/universal.ts
+++ b/collab-electron/src/preload/universal.ts
@@ -690,6 +690,32 @@ contextBridge.exposeInMainWorld("api", {
         "agent:session-failed", handler,
       );
   },
+
+  // Git source control
+  gitStatus: () =>
+    ipcRenderer.invoke("git:status"),
+  gitStage: (paths: string[]) =>
+    ipcRenderer.invoke("git:stage", paths),
+  gitUnstage: (paths: string[]) =>
+    ipcRenderer.invoke("git:unstage", paths),
+  gitStageAll: () =>
+    ipcRenderer.invoke("git:stage-all"),
+  gitUnstageAll: () =>
+    ipcRenderer.invoke("git:unstage-all"),
+  gitDiscard: (paths: string[]) =>
+    ipcRenderer.invoke("git:discard", paths),
+  gitDiscardAll: () =>
+    ipcRenderer.invoke("git:discard-all"),
+  gitCommit: (message: string) =>
+    ipcRenderer.invoke("git:commit", message),
+  gitDiff: (filePath: string, cached: boolean) =>
+    ipcRenderer.invoke("git:diff", filePath, cached),
+  gitGenerateCommitMessage: () =>
+    ipcRenderer.invoke("git:generate-commit-message"),
+  aiValidateKey: (key: string) =>
+    ipcRenderer.invoke("ai:validate-key", key),
+  aiHasKey: () =>
+    ipcRenderer.invoke("ai:has-key"),
 });
 
 // Forward ctrl+wheel (trackpad pinch) from tile webviews to the canvas
diff --git a/collab-electron/src/windows/nav/src/App.tsx b/collab-electron/src/windows/nav/src/App.tsx
index b17793a4..996c83b3 100644
--- a/collab-electron/src/windows/nav/src/App.tsx
+++ b/collab-electron/src/windows/nav/src/App.tsx
@@ -29,6 +29,15 @@ import {
 	isSubpath,
 	parentPath,
 } from '@collab/shared/path-utils';
+import {
+	TreeView as TreeViewIcon,
+	GitBranch,
+} from '@phosphor-icons/react';
+import { SourceControlView } from '@collab/components/SourceControl';
+import '@collab/components/SourceControl/SourceControl.css';
+
+type NavViewMode = 'tree' | 'scm';
+const VIEW_MODE_KEY = 'collab:nav-view-mode';
 
 const PLATFORM = window.api.getPlatform();
 
@@ -195,6 +204,32 @@ export default function App() {
 		});
 	}, []);
 
+	const [viewMode, setViewMode] =
+		useState<NavViewMode>('tree');
+
+	useEffect(() => {
+		window.api.getPref(VIEW_MODE_KEY).then((v) => {
+			if (v === 'scm') setViewMode('scm');
+		});
+	}, []);
+
+	const scmWorkspacePath = useMemo(() => {
+		if (selectedPath) {
+			const ws = workspacePaths.find(
+				(p) =>
+					selectedPath === p ||
+					selectedPath.startsWith(`${p}/`),
+			);
+			if (ws) return ws;
+		}
+		return workspacePaths[0] ?? '';
+	}, [selectedPath, workspacePaths]);
+
+	const switchViewMode = useCallback((mode: NavViewMode) => {
+		setViewMode(mode);
+		void window.api.setPref(VIEW_MODE_KEY, mode);
+	}, []);
+
 	const workspaces = useMemo(
 		() =>
 			workspacePaths.map((p) => ({
@@ -269,8 +304,9 @@ export default function App() {
 
 	const focusActiveSearch = useCallback(() => {
 		window.focus();
+		if (viewMode === 'scm') return;
 		treeSearchRef.current?.focusSearch();
-	}, []);
+	}, [viewMode]);
 
 	// Tooltip system — same data-tooltip pattern as shell window
 	useEffect(() => {
@@ -1315,6 +1351,41 @@ export default function App() {
 			);
 	}, [focusActiveSearch, selectFile, getAllFlatItems]);
 
+	const renderViewModeToggle = () => (
+		<div className="nav-view-toggle">
+			<button
+				type="button"
+				className={`nav-view-toggle-button${viewMode === 'tree' ? ' active' : ''}`}
+				onClick={() => switchViewMode('tree')}
+				title="Tree view"
+			>
+				<TreeViewIcon
+					size={14}
+					weight={
+						viewMode === 'tree'
+							? 'fill'
+							: 'regular'
+					}
+				/>
+			</button>
+			<button
+				type="button"
+				className={`nav-view-toggle-button${viewMode === 'scm' ? ' active' : ''}`}
+				onClick={() => switchViewMode('scm')}
+				title="Source Control"
+			>
+				<GitBranch
+					size={14}
+					weight={
+						viewMode === 'scm'
+							? 'fill'
+							: 'regular'
+					}
+				/>
+			</button>
+		</div>
+	);
+
 	return (
 		<div className="app">
 			<div className="workspace-content">
@@ -1329,8 +1400,11 @@ export default function App() {
 					</div>
 				)}
 
-				{!loading && !error && (
+				{!loading && !error && workspacePaths.length > 0 && (
+					<>
+						{viewMode === 'tree' && (
 						<div className="table-container items-table">
+							{renderViewModeToggle()}
 							<SearchSortControls
 								ref={
 									treeSearchRef
@@ -1502,7 +1576,24 @@ export default function App() {
 								</div>
 							</div>
 						</div>
-					)}
+						)}
+						{viewMode === 'scm' && scmWorkspacePath && (
+							<SourceControlView
+								workspacePath={scmWorkspacePath}
+								isActive={viewMode === 'scm'}
+								onSelectFile={selectFile}
+								leadingContent={renderViewModeToggle()}
+							/>
+						)}
+					</>
+				)}
+				{!loading && !error && workspacePaths.length === 0 && (
+					<div className="empty-state">
+						<p>
+							No workspace selected. Open a folder in Settings.
+						</p>
+					</div>
+				)}
 			</div>
 			{importModal && (
 				<ImportWebArticleModal
diff --git a/collab-electron/src/windows/settings/src/App.tsx b/collab-electron/src/windows/settings/src/App.tsx
index b993666d..8388aed1 100644
--- a/collab-electron/src/windows/settings/src/App.tsx
+++ b/collab-electron/src/windows/settings/src/App.tsx
@@ -8,6 +8,10 @@ import {
   Moon,
   Monitor,
   Terminal,
+  Sparkle,
+  CheckCircle,
+  XCircle,
+  CircleNotch,
 } from "@phosphor-icons/react";
 
 type ThemeMode = "light" | "dark" | "system";
@@ -595,7 +599,12 @@ function IntegrationsPane() {
   );
 }
 
-type Pane = "appearance" | "terminal" | "integrations" | "controls";
+type Pane =
+  | "appearance"
+  | "terminal"
+  | "integrations"
+  | "controls"
+  | "ai";
 
 const NAV_ITEMS: {
   id: Pane;
@@ -606,8 +615,168 @@ const NAV_ITEMS: {
     { id: "terminal", label: "Terminal", icon: Terminal },
     { id: "integrations", label: "Integrations", icon: PuzzlePiece },
     { id: "controls", label: "Controls", icon: Keyboard },
+    { id: "ai", label: "AI", icon: Sparkle },
   ];
 
+function AiPane() {
+  const [apiKey, setApiKey] = useState("");
+  const [hasExistingKey, setHasExistingKey] = useState(false);
+  const [validating, setValidating] = useState(false);
+  const [validationResult, setValidationResult] = useState<
+    "valid" | "invalid" | null
+  >(null);
+
+  useEffect(() => {
+    api.getPref("ai.hasKey").then(() => {
+      // We can't read the key (guarded), so check via aiHasKey
+      (window as unknown as { api: { aiHasKey: () => Promise<boolean> } }).api
+        .aiHasKey()
+        .then((has: boolean) => {
+          setHasExistingKey(has);
+        })
+        .catch(() => {});
+    }).catch(() => {});
+  }, []);
+
+  async function handleSave() {
+    if (!apiKey.trim() || apiKey.startsWith("sk-ant-\u2022")) return;
+    setValidating(true);
+    setValidationResult(null);
+    try {
+      const { valid } = await (
+        window as unknown as {
+          api: { aiValidateKey: (k: string) => Promise<{ valid: boolean }> };
+        }
+      ).api.aiValidateKey(apiKey.trim());
+      if (valid) {
+        await api.setPref("ai.apiKey", apiKey.trim());
+        setHasExistingKey(true);
+        setValidationResult("valid");
+        setApiKey("");
+      } else {
+        setValidationResult("invalid");
+      }
+    } catch {
+      setValidationResult("invalid");
+    } finally {
+      setValidating(false);
+    }
+  }
+
+  async function handleRemove() {
+    await api.setPref("ai.apiKey", "");
+    setHasExistingKey(false);
+    setApiKey("");
+    setValidationResult(null);
+  }
+
+  return (
+    <div className="space-y-6 p-6">
+      <div className="space-y-1">
+        <h2 className="text-base font-semibold">AI</h2>
+        <p className="text-sm text-muted-foreground">
+          Configure AI-powered features like commit message generation.
+        </p>
+      </div>
+
+      <div className="space-y-3">
+        <div className="space-y-1">
+          <p className="text-sm font-medium">Anthropic API Key</p>
+          <p className="text-xs text-muted-foreground">
+            Used for AI-generated commit messages in Source Control.
+          </p>
+        </div>
+
+        {hasExistingKey && !apiKey && (
+          <div className="flex items-center gap-2">
+            <div
+              className="flex-1 rounded-md px-3 py-2 text-sm"
+              style={{
+                backgroundColor:
+                  "color-mix(in srgb, var(--foreground) 5%, transparent)",
+                border:
+                  "1px solid color-mix(in srgb, var(--border) 60%, transparent)",
+                color: "var(--muted-foreground)",
+              }}
+            >
+              sk-ant-\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022
+            </div>
+            <button
+              type="button"
+              onClick={handleRemove}
+              className="rounded-md px-3 py-2 text-sm font-medium cursor-pointer"
+              style={{
+                border:
+                  "1px solid color-mix(in srgb, var(--border) 60%, transparent)",
+                background: "none",
+                color: "var(--destructive)",
+              }}
+            >
+              Remove
+            </button>
+          </div>
+        )}
+
+        {(!hasExistingKey || apiKey) && (
+          <div className="flex items-center gap-2">
+            <input
+              type="password"
+              placeholder="sk-ant-api03-..."
+              value={apiKey}
+              onChange={(e) => {
+                setApiKey(e.target.value);
+                setValidationResult(null);
+              }}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") void handleSave();
+              }}
+              className="flex-1 rounded-md px-3 py-2 text-sm outline-none"
+              style={{
+                backgroundColor:
+                  "color-mix(in srgb, var(--foreground) 5%, transparent)",
+                border:
+                  "1px solid color-mix(in srgb, var(--border) 60%, transparent)",
+                color: "var(--foreground)",
+              }}
+            />
+            <button
+              type="button"
+              onClick={() => void handleSave()}
+              disabled={!apiKey.trim() || validating}
+              className="rounded-md px-3 py-2 text-sm font-medium cursor-pointer"
+              style={{
+                background: "var(--foreground)",
+                color: "var(--background)",
+                border: "none",
+                opacity: !apiKey.trim() || validating ? 0.4 : 1,
+              }}
+            >
+              {validating ? (
+                <CircleNotch size={14} className="animate-spin" />
+              ) : (
+                "Save"
+              )}
+            </button>
+          </div>
+        )}
+
+        {validationResult === "valid" && (
+          <div className="flex items-center gap-1.5 text-xs" style={{ color: "#4ade80" }}>
+            <CheckCircle size={14} weight="fill" />
+            <span>API key validated and saved.</span>
+          </div>
+        )}
+        {validationResult === "invalid" && (
+          <div className="flex items-center gap-1.5 text-xs" style={{ color: "var(--destructive)" }}>
+            <XCircle size={14} weight="fill" />
+            <span>Invalid API key. Please check and try again.</span>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
 function CloseButton({ onClick }: { onClick: () => void }) {
   return (
     <div className="flex flex-col items-center gap-0.5">
@@ -730,6 +899,7 @@ export default function App() {
         {activePane === "terminal" && <TerminalPane />}
         {activePane === "integrations" && <IntegrationsPane />}
         {activePane === "controls" && <ControlsPane />}
+        {activePane === "ai" && <AiPane />}
       </div>
     </div>
   );

From 043790f5ebe86f5f34b0f41dbc867e5666848371 Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 23 Mar 2026 22:08:10 +0300
Subject: [PATCH 2/6] feat: enhance AI commit message generation with agent
 detection and fallback API key support

---
 .../src/SourceControl/CommitBox.tsx           |  33 ++--
 .../src/SourceControl/SourceControlView.tsx   |  19 ++-
 .../packages/shared/src/window-api.d.ts       |   5 +-
 collab-electron/src/main/ai-commit.ts         | 142 +++++++++++++++++-
 .../src/main/git-source-control.ts            |   5 +
 collab-electron/src/main/integrations.ts      |   2 +-
 collab-electron/src/main/ipc-git.ts           |  41 +++--
 collab-electron/src/preload/universal.ts      |   4 +-
 .../src/windows/settings/src/App.tsx          |  21 ++-
 9 files changed, 232 insertions(+), 40 deletions(-)

diff --git a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
index aeeb6f59..9149a6c2 100644
--- a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
+++ b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useState } from 'react';
+import React, { useCallback } from 'react';
 import {
 	Check,
 	Sparkle,
@@ -9,7 +9,9 @@ interface CommitBoxProps {
 	message: string;
 	onMessageChange: (message: string) => void;
 	hasStagedChanges: boolean;
-	hasApiKey: boolean;
+	canGenerate: boolean;
+	agentName?: string;
+	hasAnyChanges: boolean;
 	onCommit: () => void;
 	onGenerateMessage: () => void;
 	committing: boolean;
@@ -20,7 +22,9 @@ export function CommitBox({
 	message,
 	onMessageChange,
 	hasStagedChanges,
-	hasApiKey,
+	canGenerate,
+	agentName,
+	hasAnyChanges,
 	onCommit,
 	onGenerateMessage,
 	committing,
@@ -43,6 +47,17 @@ export function CommitBox({
 		[canCommit, onCommit],
 	);
 
+	const aiDisabled =
+		!canGenerate || !hasAnyChanges || generating;
+
+	let aiTitle = 'Generate commit message with AI';
+	if (!canGenerate) {
+		aiTitle =
+			'Install Claude Code, Codex, or Gemini CLI to generate commit messages';
+	} else if (agentName) {
+		aiTitle = `Generate commit message with ${agentName}`;
+	}
+
 	return (
 		<div className="scm-commit-box">
 			<textarea
@@ -78,17 +93,9 @@ export function CommitBox({
 				<button
 					type="button"
 					className={`scm-ai-button${generating ? ' generating' : ''}`}
-					disabled={
-						!hasStagedChanges ||
-						!hasApiKey ||
-						generating
-					}
+					disabled={aiDisabled}
 					onClick={onGenerateMessage}
-					title={
-						!hasApiKey
-							? 'Set API key in Settings → AI'
-							: 'Generate commit message with AI'
-					}
+					title={aiTitle}
 				>
 					{generating ? (
 						<CircleNotch
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
index fa19ce30..bba8e0f4 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -32,7 +32,8 @@ export function SourceControlView({
 	const [commitMessage, setCommitMessage] = useState('');
 	const [committing, setCommitting] = useState(false);
 	const [generating, setGenerating] = useState(false);
-	const [hasApiKey, setHasApiKey] = useState(false);
+	const [canGenerate, setCanGenerate] = useState(false);
+	const [agentName, setAgentName] = useState<string | undefined>();
 	const [error, setError] = useState<string | null>(null);
 	const [success, setSuccess] = useState<string | null>(
 		null,
@@ -60,8 +61,11 @@ export function SourceControlView({
 	useEffect(() => {
 		refresh();
 		window.api
-			.aiHasKey()
-			.then(setHasApiKey)
+			.aiCanGenerate()
+			.then((result) => {
+				setCanGenerate(result.available);
+				setAgentName(result.agent);
+			})
 			.catch(() => {});
 	}, [workspacePath, refresh]);
 
@@ -230,6 +234,11 @@ export function SourceControlView({
 	}
 
 	const hasStagedChanges = status.staged.length > 0;
+	const hasAnyChanges =
+		status.staged.length +
+			status.unstaged.length +
+			status.untracked.length >
+		0;
 	const totalChanges =
 		status.staged.length +
 		status.unstaged.length +
@@ -286,7 +295,9 @@ export function SourceControlView({
 				message={commitMessage}
 				onMessageChange={setCommitMessage}
 				hasStagedChanges={hasStagedChanges}
-				hasApiKey={hasApiKey}
+				canGenerate={canGenerate}
+				agentName={agentName}
+				hasAnyChanges={hasAnyChanges}
 				onCommit={handleCommit}
 				onGenerateMessage={handleGenerateMessage}
 				committing={committing}
diff --git a/collab-electron/packages/shared/src/window-api.d.ts b/collab-electron/packages/shared/src/window-api.d.ts
index e28086db..a1dfb87c 100644
--- a/collab-electron/packages/shared/src/window-api.d.ts
+++ b/collab-electron/packages/shared/src/window-api.d.ts
@@ -388,7 +388,10 @@ export interface CollabApi {
   aiValidateKey: (
     key: string,
   ) => Promise<{ valid: boolean }>;
-  aiHasKey: () => Promise<boolean>;
+  aiCanGenerate: () => Promise<{
+    available: boolean;
+    agent?: string;
+  }>;
 }
 
 declare global {
diff --git a/collab-electron/src/main/ai-commit.ts b/collab-electron/src/main/ai-commit.ts
index 89220c46..49acca6c 100644
--- a/collab-electron/src/main/ai-commit.ts
+++ b/collab-electron/src/main/ai-commit.ts
@@ -1,9 +1,9 @@
+import { spawn } from "node:child_process";
+import { agentDetected, type AgentId } from "./integrations";
+
 const MAX_DIFF_CHARS = 100_000;
-const API_URL = "https://api.anthropic.com/v1/messages";
-const API_VERSION = "2023-06-01";
-const MODEL = "claude-sonnet-4-20250514";
 
-const SYSTEM_PROMPT = `You are a commit message generator. Analyze the provided git diff and write a concise, conventional commit message.
+const COMMIT_PROMPT = `You are a commit message generator. Analyze the provided git diff and write a concise, conventional commit message.
 
 Rules:
 1. Use conventional commits format: type(scope): description
@@ -37,6 +37,132 @@ function prepareDiff(rawDiff: string): string {
   return `${truncated}\n\n[TRUNCATED -- showing first ${cutLine} of ${lines.length} lines]`;
 }
 
+// -- Agent detection --
+
+const AGENT_PRIORITY: AgentId[] = ["claude", "codex", "gemini"];
+
+export function getAvailableAgent(): AgentId | null {
+  for (const id of AGENT_PRIORITY) {
+    if (agentDetected(id)) return id;
+  }
+  return null;
+}
+
+export function canGenerate(apiKey?: string): {
+  available: boolean;
+  agent?: string;
+} {
+  const agent = getAvailableAgent();
+  if (agent) {
+    const names: Record<AgentId, string> = {
+      claude: "Claude Code",
+      codex: "Codex CLI",
+      gemini: "Gemini CLI",
+    };
+    return { available: true, agent: names[agent] };
+  }
+  if (typeof apiKey === "string" && apiKey.length > 0) {
+    return { available: true, agent: "Anthropic API" };
+  }
+  return { available: false };
+}
+
+// -- CLI-based generation --
+
+function runCliAgent(
+  command: string,
+  args: string[],
+  stdinData: string,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+
+    proc.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on("error", (err) => {
+      reject(
+        new Error(`Failed to run ${command}: ${err.message}`),
+      );
+    });
+
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          new Error(
+            `${command} exited with code ${code}: ${stderr.slice(0, 500)}`,
+          ),
+        );
+        return;
+      }
+      resolve(stdout.trim());
+    });
+
+    proc.stdin.write(stdinData);
+    proc.stdin.end();
+  });
+}
+
+export async function generateCommitMessageViaCli(
+  agent: AgentId,
+  diff: string,
+): Promise<{ message: string; agent: string }> {
+  const preparedDiff = prepareDiff(diff);
+  const fullPrompt = `${COMMIT_PROMPT}\n\nHere is the git diff:\n\n${preparedDiff}`;
+
+  let result: string;
+
+  switch (agent) {
+    case "claude":
+      result = await runCliAgent("claude", ["-p", fullPrompt], "");
+      break;
+    case "codex":
+      result = await runCliAgent(
+        "codex",
+        ["--quiet", "--prompt", fullPrompt],
+        "",
+      );
+      break;
+    case "gemini":
+      result = await runCliAgent(
+        "gemini",
+        ["--prompt", fullPrompt],
+        "",
+      );
+      break;
+  }
+
+  // Clean up any markdown fences the CLI might add
+  let message = result;
+  if (message.startsWith("```") && message.endsWith("```")) {
+    message = message.slice(3, -3).trim();
+  }
+  // Remove leading language identifier if present
+  if (message.startsWith("```")) {
+    const newlineIdx = message.indexOf("\n");
+    message = message.slice(newlineIdx + 1).trim();
+  }
+
+  return { message, agent };
+}
+
+// -- API key fallback --
+
+const API_URL = "https://api.anthropic.com/v1/messages";
+const API_VERSION = "2023-06-01";
+const MODEL = "claude-sonnet-4-20250514";
+
 interface ApiResponse {
   content: Array<{ type: string; text: string }>;
   model: string;
@@ -46,10 +172,10 @@ interface ApiError {
   error?: { type: string; message: string };
 }
 
-export async function generateCommitMessage(
+export async function generateCommitMessageViaApi(
   apiKey: string,
   diff: string,
-): Promise<{ message: string; model: string }> {
+): Promise<{ message: string; agent: string }> {
   const preparedDiff = prepareDiff(diff);
 
   const res = await fetch(API_URL, {
@@ -62,7 +188,7 @@ export async function generateCommitMessage(
     body: JSON.stringify({
       model: MODEL,
       max_tokens: 512,
-      system: SYSTEM_PROMPT,
+      system: COMMIT_PROMPT,
       messages: [{ role: "user", content: preparedDiff }],
     }),
   });
@@ -83,7 +209,7 @@ export async function generateCommitMessage(
   const text =
     data.content.find((c) => c.type === "text")?.text ?? "";
 
-  return { message: text.trim(), model: data.model };
+  return { message: text.trim(), agent: "Anthropic API" };
 }
 
 export async function validateApiKey(
diff --git a/collab-electron/src/main/git-source-control.ts b/collab-electron/src/main/git-source-control.ts
index 9b0c675e..d72ae129 100644
--- a/collab-electron/src/main/git-source-control.ts
+++ b/collab-electron/src/main/git-source-control.ts
@@ -308,6 +308,11 @@ export async function gitDiff(
   return git(args, cwd);
 }
 
+export async function gitDiffAll(cwd: string): Promise<string> {
+  assertGitRepo(cwd);
+  return git(["diff"], cwd);
+}
+
 export async function gitDiffCached(cwd: string): Promise<string> {
   assertGitRepo(cwd);
   return git(["diff", "--cached"], cwd);
diff --git a/collab-electron/src/main/integrations.ts b/collab-electron/src/main/integrations.ts
index 7e019cea..fbaf11be 100644
--- a/collab-electron/src/main/integrations.ts
+++ b/collab-electron/src/main/integrations.ts
@@ -20,7 +20,7 @@ interface AgentStatus {
 }
 
 
-function agentDetected(id: AgentId): boolean {
+export function agentDetected(id: AgentId): boolean {
   const home = homedir();
   switch (id) {
     case "claude":
diff --git a/collab-electron/src/main/ipc-git.ts b/collab-electron/src/main/ipc-git.ts
index e0c7ad3c..d12e1e4c 100644
--- a/collab-electron/src/main/ipc-git.ts
+++ b/collab-electron/src/main/ipc-git.ts
@@ -10,10 +10,14 @@ import {
   gitDiscardAll,
   gitCommit,
   gitDiff,
+  gitDiffAll,
   gitDiffCached,
 } from "./git-source-control";
 import {
-  generateCommitMessage,
+  getAvailableAgent,
+  canGenerate,
+  generateCommitMessageViaCli,
+  generateCommitMessageViaApi,
   validateApiKey,
 } from "./ai-commit";
 
@@ -108,17 +112,31 @@ export function registerGitHandlers(ctx: IpcGitContext): void {
   ipcMain.handle("git:generate-commit-message", async () => {
     const cwd = activeWorkspacePath(ctx.config());
     if (!cwd) throw new Error("No active workspace");
-    const apiKey = ctx.config().ui?.["ai.apiKey"];
-    if (typeof apiKey !== "string" || !apiKey) {
-      throw new Error(
-        "No API key configured. Add your Anthropic API key in Settings → AI.",
-      );
+
+    let diff = await gitDiffCached(cwd);
+    if (!diff.trim()) {
+      const status = await gitStatus(cwd);
+      if (status.unstaged.length > 0 || status.untracked.length > 0) {
+        diff = await gitDiffAll(cwd);
+      }
     }
-    const diff = await gitDiffCached(cwd);
     if (!diff.trim()) {
-      throw new Error("No staged changes found. Stage files first.");
+      throw new Error("No changes found to generate a message from.");
+    }
+
+    const agent = getAvailableAgent();
+    if (agent) {
+      return generateCommitMessageViaCli(agent, diff);
+    }
+
+    const apiKey = ctx.config().ui?.["ai.apiKey"];
+    if (typeof apiKey === "string" && apiKey) {
+      return generateCommitMessageViaApi(apiKey, diff);
     }
-    return generateCommitMessage(apiKey, diff);
+
+    throw new Error(
+      "No AI agent found. Install Claude Code, Codex, or Gemini CLI — or add an API key in Settings → AI.",
+    );
   });
 
   ipcMain.handle(
@@ -132,4 +150,9 @@ export function registerGitHandlers(ctx: IpcGitContext): void {
     const key = ctx.config().ui?.["ai.apiKey"];
     return typeof key === "string" && key.length > 0;
   });
+
+  ipcMain.handle("ai:can-generate", () => {
+    const apiKey = ctx.config().ui?.["ai.apiKey"];
+    return canGenerate(typeof apiKey === "string" ? apiKey : undefined);
+  });
 }
diff --git a/collab-electron/src/preload/universal.ts b/collab-electron/src/preload/universal.ts
index d4e18948..c90d5aa9 100644
--- a/collab-electron/src/preload/universal.ts
+++ b/collab-electron/src/preload/universal.ts
@@ -714,8 +714,8 @@ contextBridge.exposeInMainWorld("api", {
     ipcRenderer.invoke("git:generate-commit-message"),
   aiValidateKey: (key: string) =>
     ipcRenderer.invoke("ai:validate-key", key),
-  aiHasKey: () =>
-    ipcRenderer.invoke("ai:has-key"),
+  aiCanGenerate: () =>
+    ipcRenderer.invoke("ai:can-generate"),
 });
 
 // Forward ctrl+wheel (trackpad pinch) from tile webviews to the canvas
diff --git a/collab-electron/src/windows/settings/src/App.tsx b/collab-electron/src/windows/settings/src/App.tsx
index 8388aed1..bf10a605 100644
--- a/collab-electron/src/windows/settings/src/App.tsx
+++ b/collab-electron/src/windows/settings/src/App.tsx
@@ -679,11 +679,28 @@ function AiPane() {
         </p>
       </div>
 
+      <div
+        className="rounded-md px-3 py-2.5 text-xs"
+        style={{
+          backgroundColor:
+            "color-mix(in srgb, var(--foreground) 5%, transparent)",
+          border: "1px solid color-mix(in srgb, var(--border) 40%, transparent)",
+          color: "var(--muted-foreground)",
+          lineHeight: 1.5,
+        }}
+      >
+        If you have <strong style={{ color: "var(--foreground)" }}>Claude Code</strong>,{" "}
+        <strong style={{ color: "var(--foreground)" }}>Codex CLI</strong>, or{" "}
+        <strong style={{ color: "var(--foreground)" }}>Gemini CLI</strong> installed,
+        commit messages will use your existing subscription automatically.
+        An API key is only needed as a fallback.
+      </div>
+
       <div className="space-y-3">
         <div className="space-y-1">
-          <p className="text-sm font-medium">Anthropic API Key</p>
+          <p className="text-sm font-medium">Anthropic API Key (Fallback)</p>
           <p className="text-xs text-muted-foreground">
-            Used for AI-generated commit messages in Source Control.
+            Only used if no CLI agent is installed.
           </p>
         </div>
 

From ef12d57f6d4adee46c1bf4d7ebf402df7708c29e Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 23 Mar 2026 22:40:40 +0300
Subject: [PATCH 3/6] feat: add Git branch and stash management features

- Introduced GitBranch, GitRemote, and GitStash interfaces in git-types.ts.
- Expanded CollabApi interface in window-api.d.ts to include methods for Git operations: push, pull, fetch, branch management, and stash operations.
- Implemented gitPush, gitPull, gitFetch, gitBranches, gitCheckout, gitCreateBranch, gitDeleteBranch, gitStashSave, gitStashList, gitStashPop, gitStashApply, gitStashDrop, and gitShowFile functions in git-source-control.ts.
- Registered IPC handlers for new Git operations in ipc.ts.
- Exposed Git API methods in preload script for renderer access.
- Created BranchPicker component for branch selection and management.
- Developed DiffView component for displaying file diffs.
- Added StashSection component for managing stashes.
- Implemented SyncBar component for synchronizing branches with remote.
---
 .../src/SourceControl/BranchPicker.tsx        | 319 +++++++++++++++
 .../components/src/SourceControl/DiffView.tsx | 145 +++++++
 .../src/SourceControl/SourceControl.css       | 364 ++++++++++++++++++
 .../src/SourceControl/SourceControlView.tsx   | 152 +++++++-
 .../src/SourceControl/StashSection.tsx        | 237 ++++++++++++
 .../components/src/SourceControl/SyncBar.tsx  | 149 +++++++
 .../packages/shared/src/git-types.ts          |  19 +
 .../packages/shared/src/window-api.d.ts       |  40 +-
 .../src/main/git-source-control.ts            | 212 ++++++++++
 collab-electron/src/main/ipc-git.ts           | 139 +++++++
 collab-electron/src/preload/universal.ts      |  40 ++
 11 files changed, 1797 insertions(+), 19 deletions(-)
 create mode 100644 collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/DiffView.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/StashSection.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/SyncBar.tsx

diff --git a/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx b/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
new file mode 100644
index 00000000..73559068
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
@@ -0,0 +1,319 @@
+import React, {
+	useCallback,
+	useEffect,
+	useRef,
+	useState,
+} from 'react';
+import {
+	GitBranch,
+	MagnifyingGlass,
+	Plus,
+	Trash,
+	Check,
+} from '@phosphor-icons/react';
+import type { GitBranch as GitBranchType } from '@collab/shared/git-types';
+
+interface BranchPickerProps {
+	currentBranch: string;
+	onSwitch: (branch: string) => Promise<void>;
+	onCreate: (name: string) => Promise<void>;
+	onDelete: (name: string) => Promise<void>;
+	onError: (msg: string) => void;
+}
+
+export function BranchPicker({
+	currentBranch,
+	onSwitch,
+	onCreate,
+	onDelete,
+	onError,
+}: BranchPickerProps) {
+	const [open, setOpen] = useState(false);
+	const [branches, setBranches] = useState<GitBranchType[]>(
+		[],
+	);
+	const [filter, setFilter] = useState('');
+	const [creating, setCreating] = useState(false);
+	const [newName, setNewName] = useState('');
+	const [loading, setLoading] = useState(false);
+	const containerRef = useRef<HTMLDivElement>(null);
+	const inputRef = useRef<HTMLInputElement>(null);
+
+	const loadBranches = useCallback(async () => {
+		try {
+			const result = await window.api.gitBranches();
+			setBranches(result);
+		} catch {
+			setBranches([]);
+		}
+	}, []);
+
+	useEffect(() => {
+		if (open) {
+			loadBranches();
+			setTimeout(() => inputRef.current?.focus(), 50);
+		} else {
+			setFilter('');
+			setCreating(false);
+			setNewName('');
+		}
+	}, [open, loadBranches]);
+
+	// Close on outside click
+	useEffect(() => {
+		if (!open) return;
+		const handler = (e: MouseEvent) => {
+			if (
+				containerRef.current &&
+				!containerRef.current.contains(
+					e.target as Node,
+				)
+			) {
+				setOpen(false);
+			}
+		};
+		document.addEventListener('mousedown', handler);
+		return () =>
+			document.removeEventListener(
+				'mousedown',
+				handler,
+			);
+	}, [open]);
+
+	// Close on Escape
+	useEffect(() => {
+		if (!open) return;
+		const handler = (e: KeyboardEvent) => {
+			if (e.key === 'Escape') setOpen(false);
+		};
+		window.addEventListener('keydown', handler);
+		return () =>
+			window.removeEventListener('keydown', handler);
+	}, [open]);
+
+	const handleSwitch = useCallback(
+		async (branch: string) => {
+			if (branch === currentBranch) return;
+			setLoading(true);
+			try {
+				await onSwitch(branch);
+				setOpen(false);
+			} catch (err) {
+				onError(
+					err instanceof Error
+						? err.message
+						: 'Switch failed',
+				);
+			} finally {
+				setLoading(false);
+			}
+		},
+		[currentBranch, onSwitch, onError],
+	);
+
+	const handleCreate = useCallback(async () => {
+		if (!newName.trim()) return;
+		setLoading(true);
+		try {
+			await onCreate(newName.trim());
+			setOpen(false);
+		} catch (err) {
+			onError(
+				err instanceof Error
+					? err.message
+					: 'Create failed',
+			);
+		} finally {
+			setLoading(false);
+		}
+	}, [newName, onCreate, onError]);
+
+	const handleDelete = useCallback(
+		async (name: string) => {
+			setLoading(true);
+			try {
+				await onDelete(name);
+				await loadBranches();
+			} catch (err) {
+				onError(
+					err instanceof Error
+						? err.message
+						: 'Delete failed',
+				);
+			} finally {
+				setLoading(false);
+			}
+		},
+		[onDelete, onError, loadBranches],
+	);
+
+	const localBranches = branches.filter(
+		(b) =>
+			!b.isRemote &&
+			b.name
+				.toLowerCase()
+				.includes(filter.toLowerCase()),
+	);
+	const remoteBranches = branches.filter(
+		(b) =>
+			b.isRemote &&
+			b.name
+				.toLowerCase()
+				.includes(filter.toLowerCase()),
+	);
+
+	return (
+		<div className="scm-branch-picker" ref={containerRef}>
+			<button
+				type="button"
+				className="scm-branch-trigger"
+				onClick={() => setOpen((o) => !o)}
+				title="Switch branch"
+			>
+				<GitBranch size={14} weight="bold" />
+				<span className="scm-branch-name">
+					{currentBranch || 'HEAD'}
+				</span>
+			</button>
+
+			{open && (
+				<div className="scm-branch-dropdown">
+					<div className="scm-branch-search">
+						<MagnifyingGlass
+							size={12}
+							weight="bold"
+						/>
+						<input
+							ref={inputRef}
+							type="text"
+							placeholder="Filter branches..."
+							value={filter}
+							onChange={(e) =>
+								setFilter(e.target.value)
+							}
+							className="scm-branch-search-input"
+						/>
+					</div>
+
+					<div className="scm-branch-list">
+						{localBranches.length > 0 && (
+							<div className="scm-branch-group">
+								<div className="scm-branch-group-label">
+									Local
+								</div>
+								{localBranches.map((b) => (
+									<div
+										key={b.name}
+										className={`scm-branch-item${b.current ? ' current' : ''}`}
+										onClick={() =>
+											handleSwitch(
+												b.name,
+											)
+										}
+									>
+										<span className="scm-branch-item-name">
+											{b.name}
+										</span>
+										{b.current && (
+											<Check
+												size={12}
+												weight="bold"
+											/>
+										)}
+										{!b.current && (
+											<button
+												type="button"
+												className="scm-branch-delete"
+												title="Delete branch"
+												onClick={(
+													e,
+												) => {
+													e.stopPropagation();
+													handleDelete(
+														b.name,
+													);
+												}}
+											>
+												<Trash
+													size={12}
+												/>
+											</button>
+										)}
+									</div>
+								))}
+							</div>
+						)}
+
+						{remoteBranches.length > 0 && (
+							<div className="scm-branch-group">
+								<div className="scm-branch-group-label">
+									Remote
+								</div>
+								{remoteBranches.map((b) => (
+									<div
+										key={b.name}
+										className="scm-branch-item"
+										onClick={() =>
+											handleSwitch(
+												b.name,
+											)
+										}
+									>
+										<span className="scm-branch-item-name">
+											{b.name}
+										</span>
+									</div>
+								))}
+							</div>
+						)}
+					</div>
+
+					<div className="scm-branch-footer">
+						{creating ? (
+							<div className="scm-branch-create-input">
+								<input
+									type="text"
+									placeholder="New branch name..."
+									value={newName}
+									onChange={(e) =>
+										setNewName(
+											e.target.value,
+										)
+									}
+									onKeyDown={(e) => {
+										if (
+											e.key === 'Enter'
+										)
+											handleCreate();
+										if (
+											e.key === 'Escape'
+										)
+											setCreating(
+												false,
+											);
+									}}
+									autoFocus
+									className="scm-branch-search-input"
+								/>
+							</div>
+						) : (
+							<button
+								type="button"
+								className="scm-branch-item create"
+								onClick={() =>
+									setCreating(true)
+								}
+							>
+								<Plus
+									size={12}
+									weight="bold"
+								/>
+								<span>Create new branch</span>
+							</button>
+						)}
+					</div>
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/DiffView.tsx b/collab-electron/packages/components/src/SourceControl/DiffView.tsx
new file mode 100644
index 00000000..1b818ef8
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/DiffView.tsx
@@ -0,0 +1,145 @@
+import React, {
+	useCallback,
+	useEffect,
+	useState,
+} from 'react';
+import { X, ArrowsOutSimple } from '@phosphor-icons/react';
+
+interface DiffViewProps {
+	filePath: string;
+	relativePath: string;
+	cached: boolean;
+	onClose: () => void;
+	onOpenFile: (path: string) => void;
+}
+
+interface DiffLine {
+	type: 'add' | 'remove' | 'context' | 'header' | 'meta';
+	content: string;
+}
+
+function parseDiff(raw: string): DiffLine[] {
+	const lines: DiffLine[] = [];
+	for (const line of raw.split('\n')) {
+		if (
+			line.startsWith('@@') ||
+			line.startsWith('diff ') ||
+			line.startsWith('index ')
+		) {
+			lines.push({ type: 'header', content: line });
+		} else if (
+			line.startsWith('---') ||
+			line.startsWith('+++')
+		) {
+			lines.push({ type: 'meta', content: line });
+		} else if (line.startsWith('+')) {
+			lines.push({ type: 'add', content: line });
+		} else if (line.startsWith('-')) {
+			lines.push({ type: 'remove', content: line });
+		} else {
+			lines.push({ type: 'context', content: line });
+		}
+	}
+	return lines;
+}
+
+export function DiffView({
+	filePath,
+	relativePath,
+	cached,
+	onClose,
+	onOpenFile,
+}: DiffViewProps) {
+	const [diff, setDiff] = useState<string | null>(null);
+	const [loading, setLoading] = useState(true);
+
+	useEffect(() => {
+		setLoading(true);
+		window.api
+			.gitDiff(relativePath, cached)
+			.then((result) => {
+				setDiff(result);
+				setLoading(false);
+			})
+			.catch(() => {
+				setDiff('');
+				setLoading(false);
+			});
+	}, [relativePath, cached]);
+
+	if (loading) {
+		return (
+			<div className="scm-diff-container">
+				<div className="scm-diff-header">
+					<span className="scm-diff-title">
+						Loading...
+					</span>
+				</div>
+			</div>
+		);
+	}
+
+	if (!diff) {
+		return (
+			<div className="scm-diff-container">
+				<div className="scm-diff-header">
+					<span className="scm-diff-title">
+						{relativePath}
+					</span>
+					<button
+						type="button"
+						className="scm-diff-close"
+						onClick={onClose}
+					>
+						<X size={14} />
+					</button>
+				</div>
+				<div className="scm-diff-empty">
+					No differences found
+				</div>
+			</div>
+		);
+	}
+
+	const lines = parseDiff(diff);
+
+	return (
+		<div className="scm-diff-container">
+			<div className="scm-diff-header">
+				<span className="scm-diff-title">
+					{relativePath}
+				</span>
+				<div className="scm-diff-header-actions">
+					<button
+						type="button"
+						className="scm-diff-action"
+						title="Open file"
+						onClick={() => onOpenFile(filePath)}
+					>
+						<ArrowsOutSimple size={14} />
+					</button>
+					<button
+						type="button"
+						className="scm-diff-action"
+						title="Close diff"
+						onClick={onClose}
+					>
+						<X size={14} />
+					</button>
+				</div>
+			</div>
+			<div className="scm-diff-content">
+				{lines.map((line, i) => (
+					<div
+						key={i}
+						className={`scm-diff-line scm-diff-${line.type}`}
+					>
+						<span className="scm-diff-line-text">
+							{line.content || ' '}
+						</span>
+					</div>
+				))}
+			</div>
+		</div>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControl.css b/collab-electron/packages/components/src/SourceControl/SourceControl.css
index c9b59304..f149b920 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControl.css
+++ b/collab-electron/packages/components/src/SourceControl/SourceControl.css
@@ -357,3 +357,367 @@
 	animation: scm-spin 1s linear infinite;
 	display: inline-flex;
 }
+
+/* Sync bar */
+.scm-sync-bar {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	padding: 4px 12px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+}
+
+.scm-sync-button {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 3px;
+	padding: 4px 8px;
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+	border-radius: 5px;
+	background: none;
+	color: var(--muted-foreground);
+	cursor: pointer;
+	font-size: 11px;
+}
+
+.scm-sync-button:hover:not(:disabled) {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-sync-button:disabled {
+	opacity: 0.35;
+	cursor: default;
+}
+
+.scm-sync-button.publish {
+	flex: 1;
+	gap: 5px;
+}
+
+.scm-sync-badge {
+	font-family: 'IBM Plex Mono', monospace;
+	font-size: 10px;
+	font-weight: 700;
+	min-width: 14px;
+	text-align: center;
+}
+
+/* Branch picker */
+.scm-branch-picker {
+	position: relative;
+}
+
+.scm-branch-trigger {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	background: none;
+	border: none;
+	padding: 0;
+	cursor: pointer;
+	color: inherit;
+	font: inherit;
+}
+
+.scm-branch-trigger:hover .scm-branch-name {
+	text-decoration: underline;
+}
+
+.scm-branch-dropdown {
+	position: absolute;
+	top: calc(100% + 6px);
+	left: 0;
+	width: 240px;
+	max-height: 320px;
+	background: var(--background);
+	border: 1px solid var(--border);
+	border-radius: 8px;
+	box-shadow: 0 4px 16px rgba(0, 0, 0, 0.15);
+	z-index: 100;
+	overflow: hidden;
+	display: flex;
+	flex-direction: column;
+}
+
+.scm-branch-search {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 8px 10px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	color: var(--muted-foreground);
+}
+
+.scm-branch-search-input {
+	flex: 1;
+	border: none;
+	background: none;
+	outline: none;
+	font-size: 12px;
+	color: var(--foreground);
+}
+
+.scm-branch-search-input::placeholder {
+	color: var(--muted-foreground);
+	opacity: 0.6;
+}
+
+.scm-branch-list {
+	flex: 1;
+	overflow-y: auto;
+	max-height: 220px;
+}
+
+.scm-branch-group {
+	padding: 4px 0;
+}
+
+.scm-branch-group-label {
+	font-size: 10px;
+	font-weight: 600;
+	text-transform: uppercase;
+	letter-spacing: 0.04em;
+	color: var(--muted-foreground);
+	padding: 4px 10px 2px;
+}
+
+.scm-branch-item {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 5px 10px;
+	font-size: 12px;
+	cursor: pointer;
+	color: var(--foreground);
+}
+
+.scm-branch-item:hover {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-branch-item.current {
+	font-weight: 600;
+}
+
+.scm-branch-item-name {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.scm-branch-delete {
+	display: flex;
+	opacity: 0;
+	border: none;
+	background: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	padding: 2px;
+	border-radius: 3px;
+}
+
+.scm-branch-item:hover .scm-branch-delete {
+	opacity: 1;
+}
+
+.scm-branch-delete:hover {
+	color: var(--destructive);
+}
+
+.scm-branch-footer {
+	border-top: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	padding: 4px 0;
+}
+
+.scm-branch-item.create {
+	color: var(--muted-foreground);
+	font-size: 11px;
+}
+
+.scm-branch-create-input {
+	padding: 4px 10px;
+}
+
+/* Stash section */
+.scm-stash-row {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 3px 12px 3px 24px;
+	font-size: 12px;
+}
+
+.scm-stash-row:hover {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-stash-message {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	color: var(--foreground);
+}
+
+.scm-stash-actions {
+	display: flex;
+	gap: 2px;
+	opacity: 0;
+}
+
+.scm-stash-row:hover .scm-stash-actions {
+	opacity: 1;
+}
+
+.scm-stash-empty {
+	padding: 8px 24px;
+	font-size: 11px;
+	color: var(--muted-foreground);
+}
+
+.scm-stash-input-row {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	padding: 4px 12px 4px 24px;
+}
+
+.scm-stash-input {
+	flex: 1;
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+	background: color-mix(in srgb, var(--foreground) 5%, transparent);
+	border-radius: 4px;
+	padding: 4px 8px;
+	font-size: 11px;
+	color: var(--foreground);
+	outline: none;
+}
+
+.scm-stash-save-btn {
+	border: none;
+	background: var(--foreground);
+	color: var(--background);
+	border-radius: 4px;
+	padding: 4px 8px;
+	font-size: 11px;
+	font-weight: 500;
+	cursor: pointer;
+}
+
+/* Diff view */
+.scm-diff-container {
+	display: flex;
+	flex-direction: column;
+	border-top: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	max-height: 50%;
+	min-height: 120px;
+}
+
+.scm-diff-header {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 6px 12px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+	flex-shrink: 0;
+}
+
+.scm-diff-title {
+	font-size: 11px;
+	font-weight: 600;
+	font-family: 'IBM Plex Mono', monospace;
+	color: var(--foreground);
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.scm-diff-header-actions {
+	display: flex;
+	gap: 2px;
+}
+
+.scm-diff-action {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	border: none;
+	background: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+}
+
+.scm-diff-action:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 10%, transparent);
+}
+
+.scm-diff-close {
+	display: flex;
+	align-items: center;
+	padding: 2px;
+	border: none;
+	background: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+}
+
+.scm-diff-close:hover {
+	color: var(--foreground);
+}
+
+.scm-diff-content {
+	flex: 1;
+	overflow: auto;
+	font-family: 'IBM Plex Mono', monospace;
+	font-size: 11px;
+	line-height: 1.5;
+}
+
+.scm-diff-line {
+	padding: 0 12px;
+	white-space: pre;
+}
+
+.scm-diff-line-text {
+	display: inline;
+}
+
+.scm-diff-add {
+	background: color-mix(in srgb, #4ade80 15%, transparent);
+	color: #4ade80;
+}
+
+.scm-diff-remove {
+	background: color-mix(in srgb, var(--destructive) 15%, transparent);
+	color: var(--destructive);
+}
+
+.scm-diff-header {
+	color: var(--muted-foreground);
+	font-weight: 600;
+}
+
+.scm-diff-meta {
+	color: var(--muted-foreground);
+	font-style: italic;
+}
+
+.scm-diff-context {
+	color: var(--foreground);
+	opacity: 0.6;
+}
+
+.scm-diff-empty {
+	padding: 16px 12px;
+	font-size: 12px;
+	color: var(--muted-foreground);
+	text-align: center;
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
index bba8e0f4..a301c39d 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -13,6 +13,10 @@ import type { GitStatusResult } from '@collab/shared/git-types';
 import { CommitBox } from './CommitBox';
 import { ChangeSectionHeader } from './ChangeSectionHeader';
 import { FileChangeRow } from './FileChangeRow';
+import { SyncBar } from './SyncBar';
+import { BranchPicker } from './BranchPicker';
+import { StashSection } from './StashSection';
+import { DiffView } from './DiffView';
 
 interface SourceControlViewProps {
 	workspacePath: string;
@@ -38,12 +42,23 @@ export function SourceControlView({
 	const [success, setSuccess] = useState<string | null>(
 		null,
 	);
+	const [hasUpstream, setHasUpstream] = useState(false);
+	const [diffFile, setDiffFile] = useState<{
+		filePath: string;
+		absPath: string;
+		relativePath: string;
+		cached: boolean;
+	} | null>(null);
 	const refreshTimer = useRef<ReturnType<typeof setTimeout>>();
 
 	const refresh = useCallback(async () => {
 		try {
 			const result = await window.api.gitStatus();
 			setStatus(result);
+			window.api
+				.gitHasUpstream()
+				.then(setHasUpstream)
+				.catch(() => setHasUpstream(false));
 		} catch (err) {
 			setStatus({
 				branch: '',
@@ -201,6 +216,77 @@ export function SourceControlView({
 		}
 	}, []);
 
+	// Push / Pull / Sync handlers
+	const handlePush = useCallback(async () => {
+		await window.api.gitPush();
+		await refresh();
+	}, [refresh]);
+
+	const handlePull = useCallback(async () => {
+		await window.api.gitPull();
+		await refresh();
+	}, [refresh]);
+
+	const handleSync = useCallback(async () => {
+		await window.api.gitFetch();
+		await window.api.gitPull();
+		await window.api.gitPush();
+		await refresh();
+	}, [refresh]);
+
+	const handlePublish = useCallback(async () => {
+		const remotes = await window.api.gitRemotes();
+		const remote = remotes[0]?.name ?? 'origin';
+		const branch = status?.branch ?? 'main';
+		await window.api.gitPushSetUpstream(
+			remote,
+			branch,
+		);
+		await refresh();
+	}, [status?.branch, refresh]);
+
+	// Branch handlers
+	const handleBranchSwitch = useCallback(
+		async (branch: string) => {
+			await window.api.gitCheckout(branch);
+			await refresh();
+		},
+		[refresh],
+	);
+
+	const handleBranchCreate = useCallback(
+		async (name: string) => {
+			await window.api.gitCreateBranch(name);
+			await refresh();
+		},
+		[refresh],
+	);
+
+	const handleBranchDelete = useCallback(
+		async (name: string) => {
+			await window.api.gitDeleteBranch(name);
+			await refresh();
+		},
+		[refresh],
+	);
+
+	// Diff handler
+	const handleFileClick = useCallback(
+		(
+			absPath: string,
+			relativePath: string,
+			cached: boolean,
+		) => {
+			setDiffFile({
+				filePath: absPath,
+				absPath,
+				relativePath,
+				cached,
+			});
+		},
+		[],
+	);
+
 	// Not a git repo
 	if (status && !status.isGitRepo) {
 		return (
@@ -264,22 +350,13 @@ export function SourceControlView({
 
 			{/* Branch header */}
 			<div className="scm-header">
-				<GitBranch size={14} weight="bold" />
-				<span className="scm-branch-name">
-					{status.branch || 'HEAD'}
-				</span>
-				{(status.ahead > 0 ||
-					status.behind > 0) && (
-					<span className="scm-sync-info">
-						{status.ahead > 0 &&
-							`${status.ahead}↑`}
-						{status.ahead > 0 &&
-							status.behind > 0 &&
-							' '}
-						{status.behind > 0 &&
-							`${status.behind}↓`}
-					</span>
-				)}
+				<BranchPicker
+					currentBranch={status.branch}
+					onSwitch={handleBranchSwitch}
+					onCreate={handleBranchCreate}
+					onDelete={handleBranchDelete}
+					onError={setError}
+				/>
 				<button
 					type="button"
 					className="scm-refresh-button"
@@ -290,6 +367,19 @@ export function SourceControlView({
 				</button>
 			</div>
 
+			{/* Sync bar */}
+			<SyncBar
+				ahead={status.ahead}
+				behind={status.behind}
+				hasUpstream={hasUpstream}
+				branch={status.branch}
+				onPush={handlePush}
+				onPull={handlePull}
+				onSync={handleSync}
+				onPublish={handlePublish}
+				onError={setError}
+			/>
+
 			{/* Commit box */}
 			<CommitBox
 				message={commitMessage}
@@ -358,7 +448,11 @@ export function SourceControlView({
 								handleDiscard([file.path])
 							}
 							onClick={() =>
-								onSelectFile(file.absPath)
+								handleFileClick(
+									file.absPath,
+									file.path,
+									true,
+								)
 							}
 						/>
 					))}
@@ -391,7 +485,11 @@ export function SourceControlView({
 								handleDiscard([file.path])
 							}
 							onClick={() =>
-								onSelectFile(file.absPath)
+								handleFileClick(
+									file.absPath,
+									file.path,
+									false,
+								)
 							}
 						/>
 					))}
@@ -426,7 +524,25 @@ export function SourceControlView({
 						/>
 					))}
 				</ChangeSectionHeader>
+
+				{/* Stash section */}
+				<StashSection
+					isActive={isActive ?? false}
+					onRefresh={refresh}
+					onError={setError}
+				/>
 			</div>
+
+			{/* Diff viewer */}
+			{diffFile && (
+				<DiffView
+					filePath={diffFile.absPath}
+					relativePath={diffFile.relativePath}
+					cached={diffFile.cached}
+					onClose={() => setDiffFile(null)}
+					onOpenFile={onSelectFile}
+				/>
+			)}
 		</div>
 	);
 }
diff --git a/collab-electron/packages/components/src/SourceControl/StashSection.tsx b/collab-electron/packages/components/src/SourceControl/StashSection.tsx
new file mode 100644
index 00000000..cbec5c38
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/StashSection.tsx
@@ -0,0 +1,237 @@
+import React, {
+	useCallback,
+	useEffect,
+	useRef,
+	useState,
+} from 'react';
+import {
+	CaretDown,
+	Tray,
+	ArrowCounterClockwise,
+	ArrowLineUp,
+	Trash,
+} from '@phosphor-icons/react';
+import type { GitStash } from '@collab/shared/git-types';
+
+interface StashSectionProps {
+	isActive: boolean;
+	onRefresh: () => void;
+	onError: (msg: string) => void;
+}
+
+export function StashSection({
+	isActive,
+	onRefresh,
+	onError,
+}: StashSectionProps) {
+	const [stashes, setStashes] = useState<GitStash[]>([]);
+	const [collapsed, setCollapsed] = useState(true);
+	const [stashInput, setStashInput] = useState(false);
+	const [stashMessage, setStashMessage] = useState('');
+	const inputRef = useRef<HTMLInputElement>(null);
+
+	const loadStashes = useCallback(async () => {
+		try {
+			const list = await window.api.gitStashList();
+			setStashes(list);
+		} catch {
+			setStashes([]);
+		}
+	}, []);
+
+	useEffect(() => {
+		if (isActive) loadStashes();
+	}, [isActive, loadStashes]);
+
+	const handleSave = useCallback(async () => {
+		try {
+			await window.api.gitStashSave(
+				stashMessage.trim() || undefined,
+			);
+			setStashInput(false);
+			setStashMessage('');
+			await loadStashes();
+			onRefresh();
+		} catch (err) {
+			onError(
+				err instanceof Error
+					? err.message
+					: 'Stash failed',
+			);
+		}
+	}, [stashMessage, loadStashes, onRefresh, onError]);
+
+	const handlePop = useCallback(
+		async (index: number) => {
+			try {
+				await window.api.gitStashPop(index);
+				await loadStashes();
+				onRefresh();
+			} catch (err) {
+				onError(
+					err instanceof Error
+						? err.message
+						: 'Pop failed',
+				);
+			}
+		},
+		[loadStashes, onRefresh, onError],
+	);
+
+	const handleApply = useCallback(
+		async (index: number) => {
+			try {
+				await window.api.gitStashApply(index);
+				await loadStashes();
+				onRefresh();
+			} catch (err) {
+				onError(
+					err instanceof Error
+						? err.message
+						: 'Apply failed',
+				);
+			}
+		},
+		[loadStashes, onRefresh, onError],
+	);
+
+	const handleDrop = useCallback(
+		async (index: number) => {
+			try {
+				await window.api.gitStashDrop(index);
+				await loadStashes();
+			} catch (err) {
+				onError(
+					err instanceof Error
+						? err.message
+						: 'Drop failed',
+				);
+			}
+		},
+		[loadStashes, onError],
+	);
+
+	return (
+		<>
+			<div
+				className="scm-section-header"
+				onClick={() => {
+					setCollapsed((c) => !c);
+					if (collapsed) loadStashes();
+				}}
+			>
+				<span
+					className={`scm-section-chevron${collapsed ? ' collapsed' : ''}`}
+				>
+					<CaretDown size={12} weight="bold" />
+				</span>
+				<span>Stashes</span>
+				{stashes.length > 0 && (
+					<span className="scm-section-count">
+						{stashes.length}
+					</span>
+				)}
+				<button
+					type="button"
+					className="scm-section-action"
+					title="Stash Changes"
+					onClick={(e) => {
+						e.stopPropagation();
+						setStashInput(true);
+						setCollapsed(false);
+					}}
+				>
+					<Tray size={14} />
+				</button>
+			</div>
+
+			{!collapsed && (
+				<>
+					{stashInput && (
+						<div className="scm-stash-input-row">
+							<input
+								ref={inputRef}
+								type="text"
+								placeholder="Stash message (optional)..."
+								value={stashMessage}
+								onChange={(e) =>
+									setStashMessage(
+										e.target.value,
+									)
+								}
+								onKeyDown={(e) => {
+									if (e.key === 'Enter')
+										handleSave();
+									if (e.key === 'Escape') {
+										setStashInput(false);
+										setStashMessage('');
+									}
+								}}
+								autoFocus
+								className="scm-stash-input"
+							/>
+							<button
+								type="button"
+								className="scm-stash-save-btn"
+								onClick={handleSave}
+							>
+								Stash
+							</button>
+						</div>
+					)}
+
+					{stashes.map((s) => (
+						<div
+							key={s.index}
+							className="scm-stash-row"
+						>
+							<span className="scm-stash-message">
+								{s.message}
+							</span>
+							<span className="scm-stash-actions">
+								<button
+									type="button"
+									className="scm-file-action-btn"
+									title="Pop (apply & remove)"
+									onClick={() =>
+										handlePop(s.index)
+									}
+								>
+									<ArrowLineUp size={13} />
+								</button>
+								<button
+									type="button"
+									className="scm-file-action-btn"
+									title="Apply (keep stash)"
+									onClick={() =>
+										handleApply(s.index)
+									}
+								>
+									<ArrowCounterClockwise
+										size={13}
+									/>
+								</button>
+								<button
+									type="button"
+									className="scm-file-action-btn discard"
+									title="Drop"
+									onClick={() =>
+										handleDrop(s.index)
+									}
+								>
+									<Trash size={13} />
+								</button>
+							</span>
+						</div>
+					))}
+
+					{stashes.length === 0 && !stashInput && (
+						<div className="scm-stash-empty">
+							No stashes
+						</div>
+					)}
+				</>
+			)}
+		</>
+	);
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SyncBar.tsx b/collab-electron/packages/components/src/SourceControl/SyncBar.tsx
new file mode 100644
index 00000000..1810cd1d
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/SyncBar.tsx
@@ -0,0 +1,149 @@
+import React, { useCallback, useState } from 'react';
+import {
+	ArrowUp,
+	ArrowDown,
+	ArrowsClockwise,
+	CloudArrowUp,
+	CircleNotch,
+} from '@phosphor-icons/react';
+
+interface SyncBarProps {
+	ahead: number;
+	behind: number;
+	hasUpstream: boolean;
+	branch: string;
+	onPush: () => Promise<void>;
+	onPull: () => Promise<void>;
+	onSync: () => Promise<void>;
+	onPublish: () => Promise<void>;
+	onError: (msg: string) => void;
+}
+
+export function SyncBar({
+	ahead,
+	behind,
+	hasUpstream,
+	branch,
+	onPush,
+	onPull,
+	onSync,
+	onPublish,
+	onError,
+}: SyncBarProps) {
+	const [pushing, setPushing] = useState(false);
+	const [pulling, setPulling] = useState(false);
+	const [syncing, setSyncing] = useState(false);
+	const [publishing, setPublishing] = useState(false);
+
+	const busy = pushing || pulling || syncing || publishing;
+
+	const wrap = useCallback(
+		(
+			setter: (v: boolean) => void,
+			action: () => Promise<void>,
+		) =>
+			async () => {
+				if (busy) return;
+				setter(true);
+				try {
+					await action();
+				} catch (err) {
+					onError(
+						err instanceof Error
+							? err.message
+							: 'Operation failed',
+					);
+				} finally {
+					setter(false);
+				}
+			},
+		[busy, onError],
+	);
+
+	if (!hasUpstream) {
+		return (
+			<div className="scm-sync-bar">
+				<button
+					type="button"
+					className="scm-sync-button publish"
+					disabled={busy}
+					onClick={wrap(setPublishing, onPublish)}
+					title={`Publish branch "${branch}" to remote`}
+				>
+					{publishing ? (
+						<CircleNotch
+							size={13}
+							className="scm-spinner"
+						/>
+					) : (
+						<CloudArrowUp size={13} weight="bold" />
+					)}
+					<span>Publish Branch</span>
+				</button>
+			</div>
+		);
+	}
+
+	return (
+		<div className="scm-sync-bar">
+			<button
+				type="button"
+				className="scm-sync-button"
+				disabled={busy || ahead === 0}
+				onClick={wrap(setPushing, onPush)}
+				title={`Push ${ahead} commit${ahead !== 1 ? 's' : ''}`}
+			>
+				{pushing ? (
+					<CircleNotch
+						size={13}
+						className="scm-spinner"
+					/>
+				) : (
+					<ArrowUp size={13} weight="bold" />
+				)}
+				{ahead > 0 && (
+					<span className="scm-sync-badge">
+						{ahead}
+					</span>
+				)}
+			</button>
+			<button
+				type="button"
+				className="scm-sync-button"
+				disabled={busy || behind === 0}
+				onClick={wrap(setPulling, onPull)}
+				title={`Pull ${behind} commit${behind !== 1 ? 's' : ''}`}
+			>
+				{pulling ? (
+					<CircleNotch
+						size={13}
+						className="scm-spinner"
+					/>
+				) : (
+					<ArrowDown size={13} weight="bold" />
+				)}
+				{behind > 0 && (
+					<span className="scm-sync-badge">
+						{behind}
+					</span>
+				)}
+			</button>
+			<button
+				type="button"
+				className="scm-sync-button"
+				disabled={busy}
+				onClick={wrap(setSyncing, onSync)}
+				title="Fetch, pull, then push"
+			>
+				{syncing ? (
+					<CircleNotch
+						size={13}
+						className="scm-spinner"
+					/>
+				) : (
+					<ArrowsClockwise size={13} weight="bold" />
+				)}
+			</button>
+		</div>
+	);
+}
diff --git a/collab-electron/packages/shared/src/git-types.ts b/collab-electron/packages/shared/src/git-types.ts
index 98be8830..9bb6f4ad 100644
--- a/collab-electron/packages/shared/src/git-types.ts
+++ b/collab-electron/packages/shared/src/git-types.ts
@@ -17,3 +17,22 @@ export interface GitStatusResult {
   untracked: GitFileChange[];
   isGitRepo: boolean;
 }
+
+export interface GitBranch {
+  name: string;
+  current: boolean;
+  upstream?: string;
+  isRemote: boolean;
+}
+
+export interface GitRemote {
+  name: string;
+  fetchUrl: string;
+  pushUrl: string;
+}
+
+export interface GitStash {
+  index: number;
+  message: string;
+  date: string;
+}
diff --git a/collab-electron/packages/shared/src/window-api.d.ts b/collab-electron/packages/shared/src/window-api.d.ts
index a1dfb87c..6d480c8c 100644
--- a/collab-electron/packages/shared/src/window-api.d.ts
+++ b/collab-electron/packages/shared/src/window-api.d.ts
@@ -4,7 +4,12 @@ import type {
   TreeNode,
 } from "./types";
 import type { ReplayMessage } from "./replay-types";
-import type { GitStatusResult } from "./git-types";
+import type {
+  GitStatusResult,
+  GitBranch,
+  GitRemote,
+  GitStash,
+} from "./git-types";
 
 type Unsubscribe = () => void;
 
@@ -392,6 +397,39 @@ export interface CollabApi {
     available: boolean;
     agent?: string;
   }>;
+
+  // Push / Pull / Fetch
+  gitPush: () => Promise<void>;
+  gitPushSetUpstream: (
+    remote: string,
+    branch: string,
+  ) => Promise<void>;
+  gitPull: () => Promise<void>;
+  gitFetch: () => Promise<void>;
+  gitRemotes: () => Promise<GitRemote[]>;
+  gitHasUpstream: () => Promise<boolean>;
+
+  // Branch operations
+  gitBranches: () => Promise<GitBranch[]>;
+  gitCheckout: (branch: string) => Promise<void>;
+  gitCreateBranch: (
+    name: string,
+    startPoint?: string,
+  ) => Promise<void>;
+  gitDeleteBranch: (name: string) => Promise<void>;
+
+  // Stash operations
+  gitStashSave: (message?: string) => Promise<void>;
+  gitStashList: () => Promise<GitStash[]>;
+  gitStashPop: (index: number) => Promise<void>;
+  gitStashApply: (index: number) => Promise<void>;
+  gitStashDrop: (index: number) => Promise<void>;
+
+  // Show file at ref (for diff viewer)
+  gitShowFile: (
+    ref: string,
+    filePath: string,
+  ) => Promise<string>;
 }
 
 declare global {
diff --git a/collab-electron/src/main/git-source-control.ts b/collab-electron/src/main/git-source-control.ts
index d72ae129..3acd6c34 100644
--- a/collab-electron/src/main/git-source-control.ts
+++ b/collab-electron/src/main/git-source-control.ts
@@ -6,6 +6,9 @@ import type {
   GitChangeStatus,
   GitFileChange,
   GitStatusResult,
+  GitBranch,
+  GitRemote,
+  GitStash,
 } from "@collab/shared/git-types";
 
 const execFileAsync = promisify(execFile);
@@ -317,3 +320,212 @@ export async function gitDiffCached(cwd: string): Promise<string> {
   assertGitRepo(cwd);
   return git(["diff", "--cached"], cwd);
 }
+
+// -- Push / Pull / Fetch --
+
+export async function gitPush(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["push"], cwd);
+}
+
+export async function gitPushSetUpstream(
+  cwd: string,
+  remote: string,
+  branch: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["push", "-u", remote, branch], cwd);
+}
+
+export async function gitPull(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["pull"], cwd);
+}
+
+export async function gitFetch(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["fetch", "--all"], cwd);
+}
+
+export async function gitRemotes(
+  cwd: string,
+): Promise<GitRemote[]> {
+  assertGitRepo(cwd);
+  const raw = await git(["remote", "-v"], cwd);
+  const map = new Map<string, GitRemote>();
+
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+    if (!match) continue;
+    const [, name, url, type] = match;
+    let remote = map.get(name!);
+    if (!remote) {
+      remote = { name: name!, fetchUrl: "", pushUrl: "" };
+      map.set(name!, remote);
+    }
+    if (type === "fetch") remote.fetchUrl = url!;
+    else remote.pushUrl = url!;
+  }
+
+  return Array.from(map.values());
+}
+
+export async function gitHasUpstream(cwd: string): Promise<boolean> {
+  assertGitRepo(cwd);
+  try {
+    await git(
+      ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+      cwd,
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// -- Branch operations --
+
+export async function gitBranches(
+  cwd: string,
+): Promise<GitBranch[]> {
+  assertGitRepo(cwd);
+  const raw = await git(
+    [
+      "branch",
+      "-a",
+      "--format=%(refname:short)|%(HEAD)|%(upstream:short)",
+    ],
+    cwd,
+  );
+
+  const branches: GitBranch[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("|");
+    const name = parts[0]!.trim();
+    const isCurrent = parts[1]?.trim() === "*";
+    const upstream = parts[2]?.trim() || undefined;
+    const isRemote = name.startsWith("origin/") || name.includes("/");
+
+    // Skip HEAD pointers like "origin/HEAD"
+    if (name.endsWith("/HEAD")) continue;
+
+    branches.push({ name, current: isCurrent, upstream, isRemote });
+  }
+
+  return branches;
+}
+
+export async function gitCheckout(
+  cwd: string,
+  branch: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["checkout", branch], cwd);
+}
+
+export async function gitCreateBranch(
+  cwd: string,
+  name: string,
+  startPoint?: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  const args = ["checkout", "-b", name];
+  if (startPoint) args.push(startPoint);
+  await git(args, cwd);
+}
+
+export async function gitDeleteBranch(
+  cwd: string,
+  name: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["branch", "-d", name], cwd);
+}
+
+// -- Stash operations --
+
+export async function gitStashSave(
+  cwd: string,
+  message?: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  const args = ["stash", "push"];
+  if (message) args.push("-m", message);
+  await git(args, cwd);
+}
+
+export async function gitStashList(
+  cwd: string,
+): Promise<GitStash[]> {
+  assertGitRepo(cwd);
+  let raw: string;
+  try {
+    raw = await git(
+      ["stash", "list", "--format=%gd|%s|%ai"],
+      cwd,
+    );
+  } catch {
+    return [];
+  }
+
+  const stashes: GitStash[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("|");
+    if (parts.length < 3) continue;
+    const ref = parts[0]!; // stash@{0}
+    const indexMatch = ref.match(/\{(\d+)\}/);
+    const index = indexMatch ? parseInt(indexMatch[1]!, 10) : 0;
+    stashes.push({
+      index,
+      message: parts[1]!.trim(),
+      date: parts[2]!.trim(),
+    });
+  }
+
+  return stashes;
+}
+
+export async function gitStashPop(
+  cwd: string,
+  index: number,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["stash", "pop", `stash@{${index}}`], cwd);
+}
+
+export async function gitStashApply(
+  cwd: string,
+  index: number,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["stash", "apply", `stash@{${index}}`], cwd);
+}
+
+export async function gitStashDrop(
+  cwd: string,
+  index: number,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["stash", "drop", `stash@{${index}}`], cwd);
+}
+
+// -- Show file at ref --
+
+export async function gitShowFile(
+  cwd: string,
+  ref: string,
+  filePath: string,
+): Promise<string> {
+  assertGitRepo(cwd);
+  // ref = "HEAD" for committed, "" or ":" for index
+  const spec = ref ? `${ref}:${filePath}` : `:${filePath}`;
+  try {
+    return await git(["show", spec], cwd);
+  } catch {
+    // File doesn't exist at that ref (new file)
+    return "";
+  }
+}
diff --git a/collab-electron/src/main/ipc-git.ts b/collab-electron/src/main/ipc-git.ts
index d12e1e4c..3303f460 100644
--- a/collab-electron/src/main/ipc-git.ts
+++ b/collab-electron/src/main/ipc-git.ts
@@ -12,6 +12,22 @@ import {
   gitDiff,
   gitDiffAll,
   gitDiffCached,
+  gitPush,
+  gitPushSetUpstream,
+  gitPull,
+  gitFetch,
+  gitRemotes,
+  gitHasUpstream,
+  gitBranches,
+  gitCheckout,
+  gitCreateBranch,
+  gitDeleteBranch,
+  gitStashSave,
+  gitStashList,
+  gitStashPop,
+  gitStashApply,
+  gitStashDrop,
+  gitShowFile,
 } from "./git-source-control";
 import {
   getAvailableAgent,
@@ -155,4 +171,127 @@ export function registerGitHandlers(ctx: IpcGitContext): void {
     const apiKey = ctx.config().ui?.["ai.apiKey"];
     return canGenerate(typeof apiKey === "string" ? apiKey : undefined);
   });
+
+  ipcMain.handle("git:push", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitPush(cwd);
+  });
+
+  ipcMain.handle(
+    "git:push-set-upstream",
+    async (_event, remote: string, branch: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitPushSetUpstream(cwd, remote, branch);
+    },
+  );
+
+  ipcMain.handle("git:pull", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitPull(cwd);
+  });
+
+  ipcMain.handle("git:fetch", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) throw new Error("No active workspace");
+    await gitFetch(cwd);
+  });
+
+  ipcMain.handle("git:remotes", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) return [];
+    return gitRemotes(cwd);
+  });
+
+  ipcMain.handle("git:has-upstream", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) return false;
+    return gitHasUpstream(cwd);
+  });
+
+  ipcMain.handle("git:branches", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) return [];
+    return gitBranches(cwd);
+  });
+
+  ipcMain.handle(
+    "git:checkout",
+    async (_event, branch: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitCheckout(cwd, branch);
+    },
+  );
+
+  ipcMain.handle(
+    "git:create-branch",
+    async (_event, name: string, startPoint?: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitCreateBranch(cwd, name, startPoint);
+    },
+  );
+
+  ipcMain.handle(
+    "git:delete-branch",
+    async (_event, name: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitDeleteBranch(cwd, name);
+    },
+  );
+
+  ipcMain.handle(
+    "git:stash-save",
+    async (_event, message?: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitStashSave(cwd, message);
+    },
+  );
+
+  ipcMain.handle("git:stash-list", async () => {
+    const cwd = activeWorkspacePath(ctx.config());
+    if (!cwd) return [];
+    return gitStashList(cwd);
+  });
+
+  ipcMain.handle(
+    "git:stash-pop",
+    async (_event, index: number) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitStashPop(cwd, index);
+    },
+  );
+
+  ipcMain.handle(
+    "git:stash-apply",
+    async (_event, index: number) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitStashApply(cwd, index);
+    },
+  );
+
+  ipcMain.handle(
+    "git:stash-drop",
+    async (_event, index: number) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      await gitStashDrop(cwd, index);
+    },
+  );
+
+  ipcMain.handle(
+    "git:show-file",
+    async (_event, ref: string, filePath: string) => {
+      const cwd = activeWorkspacePath(ctx.config());
+      if (!cwd) throw new Error("No active workspace");
+      return gitShowFile(cwd, ref, filePath);
+    },
+  );
 }
diff --git a/collab-electron/src/preload/universal.ts b/collab-electron/src/preload/universal.ts
index c90d5aa9..5a94b3ea 100644
--- a/collab-electron/src/preload/universal.ts
+++ b/collab-electron/src/preload/universal.ts
@@ -716,6 +716,46 @@ contextBridge.exposeInMainWorld("api", {
     ipcRenderer.invoke("ai:validate-key", key),
   aiCanGenerate: () =>
     ipcRenderer.invoke("ai:can-generate"),
+
+  // Push / Pull / Fetch
+  gitPush: () =>
+    ipcRenderer.invoke("git:push"),
+  gitPushSetUpstream: (remote: string, branch: string) =>
+    ipcRenderer.invoke("git:push-set-upstream", remote, branch),
+  gitPull: () =>
+    ipcRenderer.invoke("git:pull"),
+  gitFetch: () =>
+    ipcRenderer.invoke("git:fetch"),
+  gitRemotes: () =>
+    ipcRenderer.invoke("git:remotes"),
+  gitHasUpstream: () =>
+    ipcRenderer.invoke("git:has-upstream"),
+
+  // Branch operations
+  gitBranches: () =>
+    ipcRenderer.invoke("git:branches"),
+  gitCheckout: (branch: string) =>
+    ipcRenderer.invoke("git:checkout", branch),
+  gitCreateBranch: (name: string, startPoint?: string) =>
+    ipcRenderer.invoke("git:create-branch", name, startPoint),
+  gitDeleteBranch: (name: string) =>
+    ipcRenderer.invoke("git:delete-branch", name),
+
+  // Stash operations
+  gitStashSave: (message?: string) =>
+    ipcRenderer.invoke("git:stash-save", message),
+  gitStashList: () =>
+    ipcRenderer.invoke("git:stash-list"),
+  gitStashPop: (index: number) =>
+    ipcRenderer.invoke("git:stash-pop", index),
+  gitStashApply: (index: number) =>
+    ipcRenderer.invoke("git:stash-apply", index),
+  gitStashDrop: (index: number) =>
+    ipcRenderer.invoke("git:stash-drop", index),
+
+  // Show file at ref (for diff viewer)
+  gitShowFile: (ref: string, filePath: string) =>
+    ipcRenderer.invoke("git:show-file", ref, filePath),
 });
 
 // Forward ctrl+wheel (trackpad pinch) from tile webviews to the canvas

From c406c958e0d776940fcd9d984d5452d970bd6637 Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 23 Mar 2026 22:50:27 +0300
Subject: [PATCH 4/6] refactor: consolidate unstaged and untracked changes
 display in SourceControlView

---
 .../src/SourceControl/SourceControlView.tsx   | 39 ++++++-------------
 1 file changed, 11 insertions(+), 28 deletions(-)

diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
index a301c39d..264d2861 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -15,7 +15,6 @@ import { ChangeSectionHeader } from './ChangeSectionHeader';
 import { FileChangeRow } from './FileChangeRow';
 import { SyncBar } from './SyncBar';
 import { BranchPicker } from './BranchPicker';
-import { StashSection } from './StashSection';
 import { DiffView } from './DiffView';
 
 interface SourceControlViewProps {
@@ -458,17 +457,23 @@ export function SourceControlView({
 					))}
 				</ChangeSectionHeader>
 
-				{/* Unstaged changes */}
+				{/* Changes (unstaged + untracked combined) */}
 				<ChangeSectionHeader
 					title="Changes"
-					count={status.unstaged.length}
+					count={
+						status.unstaged.length +
+						status.untracked.length
+					}
 					actionIcon="stage"
 					onAction={() =>
-						handleStage(
-							status.unstaged.map(
+						handleStage([
+							...status.unstaged.map(
+								(f) => f.path,
+							),
+							...status.untracked.map(
 								(f) => f.path,
 							),
-						)
+						])
 					}
 				>
 					{status.unstaged.map((file) => (
@@ -493,21 +498,6 @@ export function SourceControlView({
 							}
 						/>
 					))}
-				</ChangeSectionHeader>
-
-				{/* Untracked files */}
-				<ChangeSectionHeader
-					title="Untracked"
-					count={status.untracked.length}
-					actionIcon="stage"
-					onAction={() =>
-						handleStage(
-							status.untracked.map(
-								(f) => f.path,
-							),
-						)
-					}
-				>
 					{status.untracked.map((file) => (
 						<FileChangeRow
 							key={`untracked-${file.path}`}
@@ -524,13 +514,6 @@ export function SourceControlView({
 						/>
 					))}
 				</ChangeSectionHeader>
-
-				{/* Stash section */}
-				<StashSection
-					isActive={isActive ?? false}
-					onRefresh={refresh}
-					onError={setError}
-				/>
 			</div>
 
 			{/* Diff viewer */}

From 69ddf3e6809d5516a875ce7251990e774b46edc3 Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 23 Mar 2026 22:59:48 +0300
Subject: [PATCH 5/6] feat: enhance commit process by auto-staging untracked
 files and improving diff retrieval

---
 .../packages/components/src/SourceControl/CommitBox.tsx  | 2 +-
 .../components/src/SourceControl/SourceControlView.tsx   | 4 ++++
 collab-electron/src/main/ipc-git.ts                      | 9 +++++++--
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
index 9149a6c2..cb787f49 100644
--- a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
+++ b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
@@ -31,7 +31,7 @@ export function CommitBox({
 	generating,
 }: CommitBoxProps) {
 	const canCommit =
-		hasStagedChanges && message.trim().length > 0 && !committing;
+		hasAnyChanges && message.trim().length > 0 && !committing;
 
 	const handleKeyDown = useCallback(
 		(e: React.KeyboardEvent) => {
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
index 264d2861..5d7295d8 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -177,6 +177,10 @@ export function SourceControlView({
 		setError(null);
 		setSuccess(null);
 		try {
+			// Auto-stage all if nothing is staged (VS Code behavior)
+			if (!status || status.staged.length === 0) {
+				await window.api.gitStageAll();
+			}
 			const result = await window.api.gitCommit(
 				commitMessage,
 			);
diff --git a/collab-electron/src/main/ipc-git.ts b/collab-electron/src/main/ipc-git.ts
index 3303f460..4c73c7b9 100644
--- a/collab-electron/src/main/ipc-git.ts
+++ b/collab-electron/src/main/ipc-git.ts
@@ -130,10 +130,15 @@ export function registerGitHandlers(ctx: IpcGitContext): void {
     if (!cwd) throw new Error("No active workspace");
 
     let diff = await gitDiffCached(cwd);
+    if (!diff.trim()) {
+      diff = await gitDiffAll(cwd);
+    }
     if (!diff.trim()) {
       const status = await gitStatus(cwd);
-      if (status.unstaged.length > 0 || status.untracked.length > 0) {
-        diff = await gitDiffAll(cwd);
+      if (status.untracked.length > 0 || status.unstaged.length > 0) {
+        await gitStageAll(cwd);
+        diff = await gitDiffCached(cwd);
+        await gitUnstageAll(cwd);
       }
     }
     if (!diff.trim()) {

From 40cdd511684cdcd3b6fe8b961a807e3f4cdfc145 Mon Sep 17 00:00:00 2001
From: enesteve0 <enes05ozkan05@gmail.com>
Date: Mon, 1 Jun 2026 10:57:14 +0300
Subject: [PATCH 6/6] feat: enhance source control functionality with improved
 branch and tag management

- Updated BranchPicker to support Git tags alongside branches.
- Modified CommitBox to include options for amending and signing commits.
- Enhanced SyncBar to manage multiple remotes and streamline push/pull operations.
- Refactored various components to utilize workspacePath for Git operations.
- Improved styling and layout for better user experience in the source control panel.
---
 .gitignore                                    |  11 +-
 collab-electron/.gitignore                    |   8 +-
 collab-electron/docs/SCM_TEST_MATRIX.md       |  71 ++
 .../docs/screenshots/scm/01-scm-overview.png  | Bin 0 -> 47752 bytes
 .../docs/screenshots/scm/02-commit-box.png    | Bin 0 -> 19740 bytes
 .../docs/screenshots/scm/03-branch-picker.png | Bin 0 -> 52741 bytes
 .../docs/screenshots/scm/04-sync-remotes.png  | Bin 0 -> 47392 bytes
 .../screenshots/scm/05-merge-conflicts.png    | Bin 0 -> 48475 bytes
 .../docs/screenshots/scm/06-history.png       | Bin 0 -> 62066 bytes
 .../screenshots/scm/07-interactive-rebase.png | Bin 0 -> 61141 bytes
 .../docs/screenshots/scm/08-stash.png         | Bin 0 -> 54744 bytes
 .../docs/screenshots/scm/09-viewer-diff.png   | Bin 0 -> 72286 bytes
 .../docs/screenshots/scm/10-settings-git.png  | Bin 0 -> 52855 bytes
 .../docs/screenshots/scm/QA_RESULTS.md        |  34 +
 .../docs/screenshots/scm/README.md            |  30 +
 .../src/DiffEditorView/DiffEditorView.css     |  33 +
 .../src/DiffEditorView/DiffEditorView.tsx     | 106 +++
 .../components/src/DiffEditorView/index.ts    |   2 +
 .../src/SourceControl/BranchPicker.tsx        | 168 +++-
 .../src/SourceControl/ChangeSectionHeader.tsx |  60 +-
 .../SourceControl/CloneRepositoryModal.tsx    | 103 +++
 .../src/SourceControl/CommitBox.tsx           |  78 +-
 .../src/SourceControl/CompareBranchModal.tsx  |  69 ++
 .../components/src/SourceControl/DiffView.tsx |  14 +-
 .../src/SourceControl/FileChangeRow.tsx       |  17 +-
 .../src/SourceControl/HistoryPanel.tsx        | 158 ++++
 .../SourceControl/InteractiveRebasePanel.tsx  | 163 ++++
 .../src/SourceControl/MergeBanner.tsx         |  69 ++
 .../src/SourceControl/RemoteManagerModal.tsx  | 136 +++
 .../src/SourceControl/SourceControl.css       | 602 ++++++++++++-
 .../src/SourceControl/SourceControlView.tsx   | 752 +++++++++++++---
 .../src/SourceControl/StashSection.tsx        |  37 +-
 .../src/SourceControl/SubmodulesSection.tsx   |  59 ++
 .../components/src/SourceControl/SyncBar.tsx  | 110 ++-
 .../src/SourceControl/WorktreesSection.tsx    |  65 ++
 .../src/SourceControl/scmContextMenu.ts       |  96 ++
 .../src/SourceControl/scmOpenDiff.ts          |  30 +
 .../packages/shared/src/git-types.ts          |  99 ++
 .../packages/shared/src/window-api.d.ts       | 238 ++++-
 .../scripts/capture-scm-screenshots.mjs       | 299 +++++++
 .../scripts/scm-screenshot-git-bridge.mjs     | 153 ++++
 .../scm-screenshot-harness.vite.config.ts     |  26 +
 .../GitSettingsPane.tsx                       |  91 ++
 .../scripts/scm-screenshot-harness/index.html |  36 +
 .../scripts/scm-screenshot-harness/main.tsx   | 132 +++
 .../scm-screenshot-harness/mock-api.ts        | 114 +++
 .../scm-screenshots/.deps/package.json        |   7 +
 .../scripts/scm-screenshots/capture.mjs       | 185 ++++
 .../scripts/scm-screenshots/collect-data.mjs  |  96 ++
 .../harness/SettingsGitPane.tsx               |  42 +
 .../scm-screenshots/harness/index.html        |  12 +
 .../scripts/scm-screenshots/harness/main.tsx  |  73 ++
 .../scm-screenshots/harness/mock-api.ts       | 102 +++
 .../scm-screenshots/harness/screenshot.css    |  73 ++
 .../scripts/scm-screenshots/harness/types.ts  |  41 +
 .../scm-screenshots/harness/vite.config.ts    |  25 +
 collab-electron/src/main/ai-commit.ts         |  12 +-
 .../main/git-source-control.fixture.test.ts   | 210 +++++
 .../src/main/git-source-control.ts            | 847 +++++++++++++++++-
 collab-electron/src/main/ipc-git.ts           | 835 ++++++++++++++---
 collab-electron/src/main/ipc-workspace.ts     |   2 +-
 collab-electron/src/main/ipc.ts               |   9 +-
 collab-electron/src/preload/universal.ts      | 315 +++++--
 .../src/windows/settings/src/App.tsx          |  96 +-
 .../src/windows/shell/src/renderer.js         |   3 +
 .../src/windows/viewer/src/App.tsx            | 108 ++-
 fixtures/git/README.md                        |  33 +
 fixtures/git/setup-all.sh                     |   7 +
 fixtures/git/setup-dirty-worktree.sh          |  57 ++
 fixtures/git/setup-merge-conflict.sh          |  30 +
 fixtures/git/setup-rebase-todo.sh             |  29 +
 fixtures/git/setup-submodule.sh               |  24 +
 72 files changed, 7037 insertions(+), 505 deletions(-)
 create mode 100644 collab-electron/docs/SCM_TEST_MATRIX.md
 create mode 100644 collab-electron/docs/screenshots/scm/01-scm-overview.png
 create mode 100644 collab-electron/docs/screenshots/scm/02-commit-box.png
 create mode 100644 collab-electron/docs/screenshots/scm/03-branch-picker.png
 create mode 100644 collab-electron/docs/screenshots/scm/04-sync-remotes.png
 create mode 100644 collab-electron/docs/screenshots/scm/05-merge-conflicts.png
 create mode 100644 collab-electron/docs/screenshots/scm/06-history.png
 create mode 100644 collab-electron/docs/screenshots/scm/07-interactive-rebase.png
 create mode 100644 collab-electron/docs/screenshots/scm/08-stash.png
 create mode 100644 collab-electron/docs/screenshots/scm/09-viewer-diff.png
 create mode 100644 collab-electron/docs/screenshots/scm/10-settings-git.png
 create mode 100644 collab-electron/docs/screenshots/scm/QA_RESULTS.md
 create mode 100644 collab-electron/docs/screenshots/scm/README.md
 create mode 100644 collab-electron/packages/components/src/DiffEditorView/DiffEditorView.css
 create mode 100644 collab-electron/packages/components/src/DiffEditorView/DiffEditorView.tsx
 create mode 100644 collab-electron/packages/components/src/DiffEditorView/index.ts
 create mode 100644 collab-electron/packages/components/src/SourceControl/CloneRepositoryModal.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/CompareBranchModal.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/HistoryPanel.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/InteractiveRebasePanel.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/MergeBanner.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/RemoteManagerModal.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/SubmodulesSection.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/WorktreesSection.tsx
 create mode 100644 collab-electron/packages/components/src/SourceControl/scmContextMenu.ts
 create mode 100644 collab-electron/packages/components/src/SourceControl/scmOpenDiff.ts
 create mode 100644 collab-electron/scripts/capture-scm-screenshots.mjs
 create mode 100644 collab-electron/scripts/scm-screenshot-git-bridge.mjs
 create mode 100644 collab-electron/scripts/scm-screenshot-harness.vite.config.ts
 create mode 100644 collab-electron/scripts/scm-screenshot-harness/GitSettingsPane.tsx
 create mode 100644 collab-electron/scripts/scm-screenshot-harness/index.html
 create mode 100644 collab-electron/scripts/scm-screenshot-harness/main.tsx
 create mode 100644 collab-electron/scripts/scm-screenshot-harness/mock-api.ts
 create mode 100644 collab-electron/scripts/scm-screenshots/.deps/package.json
 create mode 100644 collab-electron/scripts/scm-screenshots/capture.mjs
 create mode 100644 collab-electron/scripts/scm-screenshots/collect-data.mjs
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/SettingsGitPane.tsx
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/index.html
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/main.tsx
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/mock-api.ts
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/screenshot.css
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/types.ts
 create mode 100644 collab-electron/scripts/scm-screenshots/harness/vite.config.ts
 create mode 100644 collab-electron/src/main/git-source-control.fixture.test.ts
 create mode 100644 fixtures/git/README.md
 create mode 100755 fixtures/git/setup-all.sh
 create mode 100755 fixtures/git/setup-dirty-worktree.sh
 create mode 100755 fixtures/git/setup-merge-conflict.sh
 create mode 100755 fixtures/git/setup-rebase-todo.sh
 create mode 100755 fixtures/git/setup-submodule.sh

diff --git a/.gitignore b/.gitignore
index 0710bc1e..2587ee22 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,11 +2,18 @@
 *.swp
 *.swo
 *~
-docs/
+/docs/
 .collaborator
 .superpowers
 .claude/
 notes/
 Screenshots/
 .worktrees
-opencode.json
\ No newline at end of file
+opencode.json
+
+# Generated SCM QA repos (scripts in fixtures/git/ are tracked)
+fixtures/git/merge-conflict/
+fixtures/git/submodule/
+fixtures/git/rebase-todo/
+fixtures/git/dirty-worktree/
+fixtures/git/_bare-dirty.git/
\ No newline at end of file
diff --git a/collab-electron/.gitignore b/collab-electron/.gitignore
index face5070..2d3a3098 100644
--- a/collab-electron/.gitignore
+++ b/collab-electron/.gitignore
@@ -21,6 +21,8 @@ data/
 
 # Playwright MCP
 .playwright-mcp/
+scripts/scm-screenshots/.deps/node_modules/
+scripts/scm-screenshots/harness/fixture-data.json
 
 # Editor/IDE
 *.swp
@@ -40,6 +42,10 @@ electron/out/
 # Back up these files separately when migrating machines
 .claude/
 CLAUDE.md
-docs/
+# Private docs — allow versioned SCM QA docs (tracked specs live under docs/superpowers/)
+docs/*
+!docs/SCM_TEST_MATRIX.md
+!docs/screenshots/
+!docs/screenshots/**
 dev-app-update.yml
 build-debug.log
diff --git a/collab-electron/docs/SCM_TEST_MATRIX.md b/collab-electron/docs/SCM_TEST_MATRIX.md
new file mode 100644
index 00000000..566204c1
--- /dev/null
+++ b/collab-electron/docs/SCM_TEST_MATRIX.md
@@ -0,0 +1,71 @@
+# SCM test matrix
+
+Manual QA checklist for Source Control (Phase 0–2).
+
+## Foundation
+
+- [ ] `git status` shows `repoState` (clean, merging, rebasing, interactive-rebase, cherry-picking, reverting)
+- [ ] Selected remote in SyncBar matches Commit & Push / Commit & Sync
+- [ ] Refresh updates counts and branch
+
+## Phase A — Viewer diff
+
+- [ ] Click staged/unstaged file opens Monaco diff in viewer tile
+- [ ] Header shows path and ref labels; Esc closes diff
+- [ ] Compare with Branch opens branch picker and diff
+
+## Phase B — Clone & remotes
+
+- [ ] Clone Repository from non-repo workspace adds workspace
+- [ ] Manage remotes: add, remove (with confirm)
+
+## Phase C — Conflicts
+
+- [ ] Merge banner shows Continue / Abort during merge
+- [ ] Accept Current / Incoming / Mark Resolved on conflict files
+- [ ] Commit disabled while conflicts exist
+
+## Phase D — Context menus
+
+- [ ] Right-click file: stage, unstage, discard, open changes, reveal
+- [ ] SCM header menu: refresh, pull, push, open .gitignore
+
+## Phase E — History
+
+- [ ] History section lists commits; context menu revert/cherry-pick/reset
+- [ ] Open Graph starts replay
+
+## Phase F — Interactive rebase
+
+- [ ] During `git rebase -i`, todo list appears with reorder and action dropdowns
+- [ ] Continue / Abort work
+
+## Phase G — Submodules & worktrees
+
+- [ ] Submodules listed when `.gitmodules` exists; Update runs
+- [ ] Worktrees listed when multiple exist
+
+## Phase H — Partial staging
+
+- [ ] Stage hunk from diff viewer (when hunks available)
+
+## Phase I — Signing & config
+
+- [ ] Sign commit checkbox when `commit.gpgsign` configured
+- [ ] Settings → Git shows read-only user.name, email, credential.helper
+
+## Fixtures
+
+From repo root, run `./fixtures/git/setup-all.sh` (see `fixtures/git/README.md`). Open a generated folder as a workspace:
+
+| Path | Covers |
+|------|--------|
+| `fixtures/git/merge-conflict` | Phase C — merge banner, conflict markers in `base.txt` |
+| `fixtures/git/submodule` | Phase G — `child` submodule |
+| `fixtures/git/rebase-todo` | Phase F — interactive rebase paused at `break` |
+| `fixtures/git/dirty-worktree` | Overview — staged/unstaged/untracked, tags, stashes, sync bar |
+
+## Phase I — LFS badge
+
+- [ ] Repo with `*.bin filter=lfs diff=lfs merge=lfs -text` in `.gitattributes` shows **LFS** badge on matching changed files
+- [ ] Badge absent when `git-lfs` is not installed or path is not LFS-tracked
diff --git a/collab-electron/docs/screenshots/scm/01-scm-overview.png b/collab-electron/docs/screenshots/scm/01-scm-overview.png
new file mode 100644
index 0000000000000000000000000000000000000000..e732d11f2960bf48b483b15ef2319f6525200cdd
GIT binary patch
literal 47752
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

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/02-commit-box.png b/collab-electron/docs/screenshots/scm/02-commit-box.png
new file mode 100644
index 0000000000000000000000000000000000000000..e6190d3d8f5b12723483270b5339c10de79c5c55
GIT binary patch
literal 19740
zcmeFZRb16w_b+M(B1j2HNtd*Ov~+`ngmg<w$08JvkZzEa6h&!}R=T^ElyrCZ9?N(C
z_r5q+=kq!5-MQj<5Ekn<=a^%BYp%eT@)Gya9-&>ia^=31q^Q!BE7y*$T)8TH=Nf#6
zZC6+N%9RIKq(p^OT$0u%oZWGUE-trmq$R(Q?@b2b3VlSQ5bF(6f6;VpwCP*A&eeN#
z-gF=DS4~<7)o_Yp5q$}`k99LzC+l!h=JDRtYWFc)*s=8=nuPF)w$oz?(!{p4jkWH!
zq(k@a=xc$2f#RZ~qErDpgjiTu5$}|GQD1)j7r!v**(trhcC(%PBQ8BQK7LC+>hJHA
zWk`h4(9+UUQ(H||yRHs@KQp(Jl{GL(Z@XGpSXgR4^i?TK`r_<3Bp@I_(ma%ex6FE?
z5|2@pSipUB?j7-69^>|Cvp*%d->25bD>&M0|NeSUDG^El57Rb=_V9`N&$rVQ7>Ocu
zE1k)_aVw$QiI+k-Wt22DeqRTRj5}Jn{w=~Yv7m?4oVW}sOO1gzjklzEo7IkIXJ<pa
z7*z8{(}b=ob;mMk#xiSv#SVqHk?DiQh{hd!Ey6`QhQV>`?{AOO1H#KALI?F)j_&6^
z(Z#O23(qWuQSTul_+<yO2EjF}VU)~n+`bk6)6jipae02|>#L497P5QgPV28JDJUqg
zIqMrfi}>HcZoE57HsvjEX=#ZpGQMjJKeU(wuY+}WY<srF%J;E6yvf$1#_}}fA6neE
zz7wbo^tHh6N8UUoX}nt$x*cdElw;8J@k~})njOARp<xgvn(b!bJ~Ni}F$j;*M4mYn
zwU7@-KS~J;d!v55Mdzx9kOXW+QRl6@WH#UaYWB9pZF*(sal2Kaq5d)_;-&x*gZt;I
zxFGmVJ^Cfo3;cik<=E+PXN^w1K(Ez9I*d%vdQ*2LPWS`b_HOTI5pk;WzDEj4&ux#k
z^l|3vk00Me!);9!yzGO*A>lO<6_u|DxWhv!9{fcuU#GRPE0K#uyV7BMrfIf0#E{Xf
zDAR3!#p7fzSF_w&ON+S9X?2*1n;RK0mx4_#?Y`4SdwRIJIayN`Xrk{KK4x9D9x21@
zdcHqWceW!#NnzJ6CfZvl$$@LPW{Ac&PhvGzW`!)8pA8fA{QK)_loakqQjfhpyZLr%
zYU-{84u9>Qq|qFs94Dy4!Bjs?GHWWjlGnRWoGO1*EPR^pi1XU(lMok8*S&EwnOwxL
z^V74A^O*Cd0R_SH>_ltx;XLHu-#%pSTS8G%jw^%Y^J~cB#go<io(dtx_MPvqOO-y;
z>A~yeMN-QYt(aXA7rjPqhbc~zc6KmkBbwCUkI7}$pD7tZK@$a)+0+A7z1&L-Rai~$
z&A^lUr$E2q>#J{cG+fr>E`LhQHue}^eRY6`Hyg;ld-twP?2`n3#6dK@^6+;})5}Nr
z_=j5!nB{N!yj#|i*mjzHCaRpn2-xboUsk(pfBRAS70MisL1nbgOHko#<y(Gr{^pDa
zOWm2>N0FwFc!pANWDc6}buGt#_Fe3M_9taf&JOmFIAuQC8&Fv6N;D<gJyFxLy(yO4
zpCz+7R&KN0pT#$E{>|}l!kLzahP_?2#%&*iglF*UtJU+vDbwzfTAbK9_&X-kgn!1W
zob%6*raTU{TP^i#pNZv<=pd{HvgIb152w5Y@t)N(*FN=R()!7o8qIYAPjNSSeXM-(
znTFosyKVVo9&MND4|&n?@dV}<oyTposl<FPtVV@Zj;l@^6^lEed8)T?j_XBYX_=Pu
zZ;l)<rcPDZn?9uE<aFwYWs0IzxY+4nA^hoJ`ew91Ka7;$6Ursk>muQH$^BZ9*jObB
z`$~WBth(0&y1LQiELCgl4`VpX3|lZ%yG&C(V(k<;9JZVAQ#}rlu+vw+9eLkl*1J*;
zHRMj$f4P|Im10L#4sFk!;zC*d8LW$Lg&lQ|cCkqaua9=1#mEnj-7YQ-pExbMyB$5=
z+sKv>q84Rg9oBQN!nKU6#qt`KwRC?P>Ob6D_b>ITSxiBw-*k5@i3+Ff_r2H-^U6~%
zoSAT*Dpfu+UwP_RwNcq&&DG7fE9*QYcsv(1sY*rBN8Rs(VQI7SeM#l3%5ueGis5Oi
zq1(U!iRJRi;bxE1_;dfG(eE+FWCK#8y34GiKMIc**yhvwLs8A|!bjlO>G0mu=x9r<
zMDA7IrLh#Zm0Us&6V?dRzJ0f;n>e)cC77cZwOjS~4nn>#DC(!1@~`F<kG{LuZXw&K
zdTKrxpdi}PEIuqx?wIg&%iJ>0s_>&&I)~owM46SQ+pwCB>pV2+1dml%qo$S?|LS{F
zwE31{e>uDR<lT8{U)_4(%EH^nuecGbX<f0?&KP3<W4zF?rTguclZZctBQIX$Z5u00
zZd2DK1B>B2DZ#@|j-GIC*-Cb;d&A$$C#8uBf`p8w?X{gJ9QU%X-$H+To$%@hOyNU8
z_oKJ<0}EY=Qs`a8W%wn<s2$eOofMllRDD|lLrJ&Jll<JmPu+9Utv^!=ig!kA%~`YS
zcO)k9^Iq+d=H=6b8BZ}h5{IE4fzv0yTe}U_C@!Ck@HlOZOJRJQ{i`|S)q>bj@w+rY
z4(2GN%COW73M_b7@EqY**WUloh>^}=lgz&4u>L3J)!&WSqtU@*i}rQD^OfKL(eIL&
zJi&3rH|KtjSJ<!PI@S5zCu*jNpXdz}yog_aro8k9d1^E;47HTqi|7k1n#lCg7daj^
z4BHkRV|!_*r<>G8fe6nK4>2eYoA~Lp{-+SjR3hoouPLuftEn&WY!0Lji_vV&VPrii
z6l3i{%#{Hto~_~J4uY~3(|$ywiYB)f7D?7|)+GsLns&CtEv=^9R+&z?vmKWEKTJBm
zYw)0)P4bqR+J#QX#_|41^0gPxc97A<b@DW`lv|>1^N7uwI5m^<)6>nmo;6MXFg&60
zxd!$}ttsW}_{*EeJIE=I<*c}ilU0^l9XB~N`BIA!8ocvW-OHjWZX4<L>9LE$x=UDd
zb306_`P9oZ+SQ=f!aR=2Z->2Yc?5^kstBGCopV{#3HjWr-p5hkn-00z7%?|DH)c~e
zae#Dibk|mSzQk+VozxcXplZRh8g$eo;e;Ra<CDPALZVGJNzs)j=oy7HQFNADwJNw@
zstP&>)zn9Dhv+7I-PZYx9<^g<Cf&uMaX(!zR~e+!a$FmYn0e^xtuV)QxrHgl?VG>R
zBX~KdMj@aP71PAE{7|y~7@q_AcG7h*!cLv?X?L!2PX85kO83jW0N#zCKAEk2f@fRT
zQzNSDKW;G#-s{YvtoU<f(MCDPxTsPi{x+$L-f!=l?lMkp54(LIM6_a6v@8`Q8wYjX
zien;~Ww$m<mXBuQMO3bNjooKHZ)uI7q(_ei2=g0@ckHVF=@loc4<613s>>Xs$Sh2~
zAgO05DQ0V<g?laNzkl9)yO``;lzP}FLAI^N!*q~yS2NlhP?xlzoWzU=zD}<PCBhnC
z#IPDmf!qXH;~E=f?W4x1@+Djo{cRtzShDW&f|ukK50R>ywP$}D)?alO0o+8FF|mr$
z*v?wV_$B!O`szE$%=e@un!bKEol!87V5hj(5IJytn@REg<BZX8X=lf7?#1w1OWaE`
z!NoWVG#REdiBxEryV=uuHy_THjalz9-zx5Fh+w*7Wc8;+|7vx9Tbzi)TSgrB-8t-8
z^l&8oa-OPM`+igU&VFT3J8rEz1%{76iTa=KZG6~xoAv5MuAxJ6end~-JQ!%BzTv=&
zc}e4r7rdm{Z#d{@;|XY!rS^zIMlx?ZmhQ#AcT+L_?K4dzL-r|BZuHVXLp*zWk!#9b
z<bF(kYxctxFLVkHVN(l^l7~A_Q-k7{JecctyxP5f$c0>RI(~A1GpZCSSrU}?5d)z(
zIm7LE&q-<d3qg(-l*+`iL+TkZhly<K!18mXvXP*`xwC%aXtAk+jw>LI$>p*yzrMtt
z#~3_IetJ$kX0U1bgq+&rBU-Rq=B2oklz12^3Hx~mOP$eTJOhu-bPZiPZ)3Os&vpBq
z6aOD%US|>W<)tA{svVE24X>tQ|KgI;r_ZDk`SiI+I7}?nNd5<V`*m_!HbpFQ;w}DN
zirkcAvW3@rY+o`mwa_c+CZlD4;m`1236d@FJa^kn^2M8t&XXM#9>x!9chPDWd)ECi
zZ6#K}Ll*BIr^kuIW;CF3Ry_&#>6_~<w6C!SkK~oa+03b|qntkEiJl@Y2ER<pw=LAE
z`?Z=6Y74gu=RH}8c6x6mYm^tR-oyKcCu^wI1L0ZOkjy<YC`QFfLANx@U-4k==YZ?W
zi9+7D4oN@;41Bt+dBm=5COJhX*JYp5TvojftNLJUAwy;shFPE~d+=^Ob#$XRP^;KP
zuKm2CB6M%+!~9%~>#w&;t*I`*?-Oy39`0W}>zsW>zdwM<madp3jdx&?t64y@$Y{5U
zqv5j3%EpSzeq?}XRMBl8<3?`Aa@9cB5i!X)sc#1a#xPAeALLu{aP6~TE^{+5i1B%c
zEcDzmoh8yZoY3(7rW_dy#dY>xc8zC~SS4>=!f2c#9PjW{XWZ8mCFUySP*>fh^6L-I
zk<!c)<$9p$?i9-)ATVj-y>=O7+{zU7;H}2~6NdbR9k1{iViB9@Pixad2Lpvaj_+`m
zEodp@M?4NpOA`r9F(^G{Ow?XkJoqKWsjgC%AXza<D&KnK@s&k5f7$xsKs}@L=4A4t
zpU#+*DX;VyA1usaSfAuaVZ;uQYKEInB*x9-C|=pJ_HJ0aM&B{O|FW>IS*WMcll62d
znt2UjJpH{P+U{<{S*#21Y!Y_NFnYE8Ya!aR5d}w1-oEa?(#JyMjIaDy=EV9nZdEa>
z)8~EaB#k6iaxJoiBV+z%_vtP1rL{H#RmmuM$HIxg4a?fIAme}s&6kfqFdtG~KP1K4
zh}_CzV;}u2a{KG^XvYu^>!u!h<?PXZo9<_hSa&1upz%~Wt)ng9`l9r*(G%bjVMV!S
z2??*$sQo*Cbizp0Mckr>N8Zu9fW!uT`tKJI8dFNXOp7z#J%{Gsk{lu(X)7&2BeP~#
ziD)DDDy1#<4Nm^hL#ilBE7a25<A%X-cJL&J*kkp9zNbtz3CR|bO?8C%CpI&O#pyav
zp5o(E*WxntygRD589%%-WT$6iW1AN}{XDLgLAO(Xk0qSoC?5Tg6}Rb7cF5nzEG(@(
z8nuA|Wo`gT+5WWFk<MD28JQiMl0AQ`CwV`RO~V^wcPwq-hc@plVL4BXoVIAXT4t(a
zQ!l#VjcBJ)FJLV62s_IMxs9wR;U6rb2o}%%@BIBAE#L{c5=M{lUQ1Ptb$@1{Gbiu(
zi(J0>w+&`F$-}@-n{lfbIsNsx6W)8fXGzDbO_ww4goicwIQ)o?dYGbF@<x$?XRc0=
zxVd8TZfcfdhPaxp$Ft9@$~IP2w{<w?Lh5B*4jf%FqP+}QlGp;c?H78N*@>pqzviIj
zuymG&cN>fb=IEsgB#X`Sno<OP`cUPf`c0MT-+BzX49Ias*bywbo-F6o_%FL)R^8P-
zxNPcgQ4>0&m@m-9vLpNueUHy#_(>$%y@taVE9tLxzaglGb1hdWuxls|^BCj!Gn*$$
zOZlbSZ67$DqJWFI;JI3{&q>|+fo7`?y%^<YK5#Ts#?<g|JxouB!m9w~Hvy?VVt<5f
zcj)NM4VChUJ$Z+hr6Xvp;Uh<uMzM)ubFeG)*P5|a$JJrv7<HvYpx@>2!5?9Vo=M~q
zw}GLd9KjlqqB?_SS)Mb`e&WUX>6Fu$)xk9?C(cbmtA{lsThk4<(FtBuFb|Dj+B0RA
z5;V7!ZlG&~+m&Whe;0d3tH9p=hrK|4qWIero&`>;KU?pF1Ck9A_ke$F%5l5z$|Z6>
z(}?WyD%{(){fNgXPHj@}dv|i#7mrA;Iv}{rvq5vrt~*mIs+ya9@sr!pHyu$5E!;B>
zj!a`de>zWi@BSDhl`|h1s~3~m=e&Ru;i#@1KUyyEAK<i^9OvEsW09XFY@NjDSAny>
z%&|9o5Nti0v}&X<ug7r?C<_^g{)G*#d7((Z!EbWp3@}V&RMaw)rS2;8;(GbiMy-p9
zA{MgBnWbuTMAxgvS>!Ct>#X59Er;pB_jN+9y~d4&N&Z*7#K1pt!e6AG^on4{Fl+yj
z&-5Yp-tt~E8arPWygZ9y_Wy+AVf6mmWnF-zoyXSi+kw`$wzkVjzlpkEOFFW-P@-vf
zHvf!Aa5^6Kzy7`~S@C5FR2mEaq2JPl%5+S<uXfv~wfsVdwt=HnNl5L!>uKd;bzD*5
z;zrV}^M@p<dCo;hSPDzK23DhgIA(dcaJ$g)30KD-3$kJ-_5BUL`SuvZOd##rZ1~Nx
zZ}DCVh<)Gi4w(f}<#K;AMRo_4czOy&CbS>HmRxxUuYWZY`nen+O_Af6kDdn9??bJP
zG8u}PC2>U7LXY3m4I$m`mtircjjz1(!B+VC1h#fP?`E~g_-9-pvGZ=;%}jX#&odW<
znd@Yz{xvk2oK#PqF@cj2I8H;&EUWo-7Y2fp-OVQFHHVXw5xtoF`-93pw=rv1e^fC8
zEq3!*xv%ngv=LN`VV$4U#iPbvvmsn`CR<o2{xumYkgZeWw&zuye~N7IvS`K_C0ZE!
zi^F!SF(-r8aQZlMJy(`+M!DEr@;V4ya~{jbcb@vPBHqR%`_B+E2I&%N8IHIE@ovOI
zJjA{lP%gi?-=KBxEQW6Ur>$WX0eaNXcg?ugCW9@0qt7lT{p#PBSs2#CADE;TIj*YK
z+JD6@p?0(7ihJ<cB^gEJUbVHZarE#-bz3m&RL7G#?=AI-il<28TZc8dPJh53clA7;
z#~*&Y8d1kCn1z)h+!dCe4l`%&I(A?cb3GQ!`FJwltE#F~&qlOF2Hc>430*!3c<{`Z
zzrTKaC*F<f72_kK)urMdfz`<x-VWJQTN|_b=Z{#ddmb1254h^`(SG6~OVH;nyPN91
zbJs>9ij>_*k`q$~J3=d3@E)&wZqY1_C63$zipuY~uT^Hb$)oYBM$yQPPF9@G^O?w(
zX;=<?Q^~F8Ois4pxz71>WBp?=2YbD03XuA`ixqhz=a8J;PkS#c|C$ee5#rivXUs2<
z%fu-ikO+BX+%Zc<UKVdTk6hW-vGhVl_P2z`R?D;=eEK3(-p(gV9XpVMS3UWAz*R0b
z>d`HdEqq<~>6$0uwg>F4%%|CtThR~8s_)@58x?9$jfE9?DX>T?EUf!AxLY9Z^Q2#&
z!mFWVjFA6e<3sXh_ztB3Cq*w~uh#(53z{f-hX{-OVoUuN8Wnb>h>ktL{4jx&FNXzp
zbxZ-6K4C3>^+PLRemW5NK|=r*B|D!eS5m1SzK`=FlRCPIVFEtW>pf6d5H=d&=22H_
zW^dway%^g{!Al)BmoxR~O5smzDh_HN=^ilqBDx4O*Tr;p%2&PFa&EAMf<-9yK+2{|
z@BY<LmXKFc&%EhGGPhF5dvIsb_1La6MsOd$3ufCsFGzazO*M-RL^-zPn9*-)EW(Q|
zWL|5e9>lQi&&lA`bdRqAxo&fAWsKsu)4~@dX8isbr*E;ag*1`Znfbk6eyD4;+S@b}
z5jT_LW6o+?lh=TiXG^FrV${*a?`jA?3~LYHFl4b~Ko(0|k#n9JDDi)%ymyE3487u~
zMrctBQBjjo{)CS1v$Ms1qC#@R>k|I@J#n^Kd_F#tAGiz@K7~ho=*TQea;Q0Q@^L`d
zcuw)`)!zA@zU6tjB{EV~_0Hw@z&j2H?nD{_G9PNgZ2|>iY}&@~{q*#Y7M4G%8z-Ew
z!{Kpai%;l@>{3oE4yF+mDB#-9G>So5EUHK2NvS{$@p!PVM&MH^ZDnQce{QYHvk(xV
zr=7Et(5QW*<8;x)E{aytVvVC&Q$7NErQlTjp)bpV>*e{O2D-TAz{ycgQErf=d~sZ{
zf@|?gUf@g`CAQvVn&A$^ioKDlA1|m;;{45%w`4@G^-QJV+-zA2kR%l)|CnS-#__h9
zH3|f7zMCWwk|l4ag>TvRS2h~x{8}0+pYlYkjj}Z_FLoy2us1%Tz@|a{(9<^k9af5N
zpbC~C^h)42VgHxK{{Nzn@c+N`f6=8GFNbLmbsg6M<qgFlqoZ&%B>uSrc2Qkiz={pP
zmI#^p&p(g+q^A`S@B|UG+2&?2$`!EQ$|fd7C*>PGlKamu{ic`X7XSC3@-@m)cEMpS
zOT>bnNvSvQJ$#C?C(LAM=SLsg&b4CA;!JsWg9UP=@$;=d$`Xn6D^Utfw)XM8k5{|J
zw6r!+HA45#dic|?z<pLCL_tsAhB88m?HA=U(onx)CMh^Sy1Il*ujJbT?3qJgn`vp(
zm_eh+NJ}dTWuk1ivd*)59Boa5+I?2(aq5KnqZqGfisYfQt`6oJ!b6M7qtVW9{RM@e
zMiM-jc@X5AX+3oaUBOXk2_rMz`wF__KhtO}n!|2RlH!JtL0`I9v!LfKl8-$19zOXi
z^Z^YIMoI)r>IMrrysgWq;eES!QXHIJfDq9vx+%JMvD@0(ng!XwgKJg;C95n$4ba}}
zTK8kXq5m<uP>|6sAS7gd8#tyUMzh+*Z4wZ0%A}%bZlaxS7IoalARb)=rJx6V5Y(^C
zSv7u|X$r!(AC<<utKXf(Es$b4-yV_X^YiCV06Ghe=fh&KrIIN73_6CFM4lEmo&(BB
zh-G-iKu-R?T70kY87Zt%TgR6vVjhP8wp0-OH%AK%M}BD2w9Hwe3_`3nF&;K)Sfy(+
z|917i`Q_WY?V$wI6ePG7*KVSL0Yss!5F8lD?Y6fB>h|T?t^#V)XZ+(E8%1ZMK*?qV
zU&ly6OKbdFeyurbD~r0yKgt6;kmLp@WF2gViAqN>!D4fB{<q&S1wb2?9Eye4b;sym
z)$!MoWGLszlX!v(S_%$Ff*ki>dcKI9-JgKY{_Xpi`?saJp43ZN8Du9NYWrA>*~3he
zohM!SMl0;0@p8!R{Z$_MqG$+?re>KX8|rO>tA|1Fp9;0Xj(iCv?n%n;HfW>+lENb{
z>rNklbe&*o0qdZVMhSJ)x;1X4-YB=R&fDJ2_55W2xB|pf@0%b}YmT7KS_*!68V=Z~
zOFdwUX3Hkj=jS9leS$5D;OkjjU7Cvp-)p`nHPx<rW1@=i%2%xlJE+sc&8f}g9GN&~
zc;-Yl!)ByusvN_|kdTQIvw_XJ%WliypQT_2f#-^j_zsHpLT3V0+Ll1v<5#edQ2K10
zjjQ?ERk4RVp`po+!x~UONv!(U^2bZelu2zSDr5S-z~T0NVt%|cPiXv2r-sMJ<H-vL
z5_u|cIkm50J6PUbgg;a!*b&3n5?yz3(!q;4t1*XXcZ=KySGd;<x=F55R&y}nK!yaS
zHx?TmIr(Sfj@UUWno55(w#67V9gS>R!t}P^KDSqSUCu$-Cl&M@?^Z?@0@Hz&P*Rtc
zm!~1v4&C0~o^1O29mZ%Zi>`o9Qj$ucftWC+Z3}AgFzyKV(krIl2z<X*WHG|*sa<3w
z1uLR_i-dLTV0}#2>)ernEAu}4?Y3E<`{Qs9Zj-sc2&I3S_Tq43BH=s8$h!+&9NpB3
zER{<XN*MW^Kw7S$DdqzAG)ne50~6QdF!^*QI=cJ$Y%m;Ao5|_~UHX;1HRNuReYd`=
zi$`{Nx(hw2?5C$@a9Dk*Rz#|+ZvBCxwUc}h+P58R|LZ00vq-4fD0yK;pMlf=(E=7S
zIXP@+M3peY+6YA-%qC5Ai6VvxxSMM+uo?wE^ftU1gw_FN&80a@-V$y@cezz7_7Qix
zRsh+WO&nfHP);GQs8ghjDmnrr_=~1ppNwUMe2c+eHeG+hfjZ(ZA9#l%YGZht{P4cA
zliQQ>IJ{ZxPTt6O>ZF67i+I{o>9~5dJW1Hl91Z8nRd*5mm~X1z*;Dw8pkyXbzj?4w
z#GMZbq{YrA``a?J1609^AbzkfqJ~a|B~3si?JycxCa#pPQ_~hji?CsNWEW6KqDZmi
zLc1|m9+s+Nu$Irc<gnEH8GQ9gB$)VblF|%u!tm_Av7CN8RqB+Tc+-=@zi>%``RdEd
z->{tlQ|SUrqqg6m|LFoPA@^c<UGfGj_K`dd!=m3h*CO_!R`Bj{JX;avly<zJt1SBr
zCEyUak%ohVBZ6Ew+Mb0ziU9yM2fV??G|OAb-!;pJ^EB+iB%N%R8)lUjoA;Y*yz|Mq
zGK?!6A08)v34><{fG;?ViVHxX?;qp1ri+I>0*R6VYQ!n@ptRgLjU5-;K~fM1F~k~*
zMYN|!%dCima-ae4F7`OnHa9o>5ig;dj%VP8PsI9k^TAy10~I;dd>y%Q^3`}tI0_<4
zN=m?Ks{Q*^^3+k}bbT;43PF<mcJzw_Fj<7mbI|H_+}*4Hv&2n!B<AGNuf7bs^px+s
zu6D779(GqGm*z7oH7%{z@q8T0JsVQftpT?YW%a@^>WyO2t%X&io_n#d_g%fv08Tu3
z=$m~Rx5?LF_^D(P7*JkObVsELX3FU>c)*yZS1<SrW2v7fKJJQ;w!b2+U%7C1c{{Fn
zesc(s#Ea=HNi|tWJsg6S+>fTdTwwYht8QiJTT6ap_GaxVGY!o@NI*r~c;rZB2}aQI
zF%Xu-H9}UsD}oZC#AdLuNsyL!8CbZOWhx;oe693Lc$IA+Y;@iK?Y+42bgA)qMUMD7
z?V_2pEn#DZQN>}O!v8JA!r1TDgMx7|+!HMe6v~|qAHcWUvd=t|ca*^Zh3*D@_p8hH
z3}0DGk#E@VG-z4DWP%saexWsXEi~Dn#s><m{N1S9l$V!3n6x7wkb!amQyhrmzi5YL
z(Dq?bb;zS<=FnGxrg0EC2Rw(jpTK5#%aP<ivx#8B>jk`$H$!E9@Do_UNQ|2#@K)|V
z`R{$nyCzOW3s0W!oAL6q@PEP*by#h#Ezlg@_TJdp?M%YftRd~sj%=g&&D$aw-EG=j
zU!o#6SZ!AwZb7rndfz8P5HT(?Rbao^4M(A0KfY60CiYH5S8S3g{gPxToob#soUe5q
zmQxCUOtJ;RsMJ3s5z0O<v5AOe#HURGZ`mFMk9^l`v9`_DkzmrWi_>M|W>N0Nx{R^k
zddI8}kOEeUjiSPzlmf8F5AT*lE*lg7=bf})sbxgl>}0xUcUoFnh_EiVywr1*s7a})
zsTGZfLi6W%4&IrCIQ9H|)0aMI_@&F}=t-$j;8P8Yw)8Yg&l#`$*QMql)}C=~Ad6c9
zM1#TdMUtk&PQw&Si;^@ofuB}SFmE$(aH}}_1`~Df{^0Qtm*kCfjsE9m=}!mu7FA?o
zB_DdqJOofFU@#ZY9}JfD+Mm*n0MSeUL<6E`Uk+aQtK?G4%-zeO4$4ZStVK-{!LaAS
zlA`I|He)$fKXR31Vq5X$WgY@bayPu3A`s-H!0IF&2-ojbgmpC4WEUf$Tvlq6aW}-Y
z9Er)Jsz;vxb?9z*DHHoePt$I?{zFLSzhBKK`Zhp9U5`|f<B8)|g?|m#|Idp;DK_-L
z8zYFgW0D_Wm}v2JFp`?VXf(1(2^;tS9k**o{=>|f+Eq>@JPuz}zrThgM$khhbE=~C
zsX8whi$LX}cj(e6q$EX08&OeGOGl@Dh-1>^<mPsTluaV16_3kSTA(~cu>ymFpvve{
z>y1PT4Vq9E{kLr%M%BE4Nfs)FyGk+(#iIzyE&3w+2#eCWE3LU{QStFEAcN^RA&pVk
z2%G;S4}j;sT8~rMI**Iv#Z6Gtx|4ZBGP5Dmf^v8#DoYP<)kFCZLXKsrFGDJX=Fd3z
z#~{a@!0ZNM?iTe51exvoT;snyL(lhNJdr_4=Zj)Su;|ynrACj)Qv+_7kK4(_Dp$R>
zW1W-i<z7s(2aue7B3DA0d9c(s3n3sv9tXN163R<8$b5hj{CD!r0w6v>H9>)as0IiN
zB2T`Xg4iHui>GTz*-jJkaoO4*(N#!br*1etetojHY)D21*u;|-!YS*Zdex#LMG>@N
zB}RN(zpe)}J<<9ZeqN4lit$#ad$S;wuADi~z5X{oqEp{4@=|DVSkq>GqN<!(nuOrS
zFeFC~LbxVfpxp;2iGH}8_9x4x{kshUayBT<_6xEMb1;ug1&d%J10-_?DRx;feRVP%
zl`{eBd99`kr|Jlr)y!}31+lsrq4b*sTwq%Xukf#z43K)A*>dKhB1XM|FNCbx00JB1
zrrbsxtl826;w*<u+3CUhy+yoh$ViR8GYJXd+g2P8r)WDwW<EP25zz}bQhnqBCEVo^
z_x`Zp0{S&zLC3SBZE<42uEib=s11Q9su+lSqQP#|`k*Wrkh4ig>z%)-jKa?HnT`LH
zRl#PAU6_9i_Ci;@k_XQiJ|ZLO0f$K^E3)D79YHReNk0Ah8>E1*{WpE{y)lL)=h{qU
z$~<1hBj$37sPi4-E$^tyECi)X+E8K;rOwhOj7M!!mHBhNhq|Vtec0BMCUUSy)*$(U
zf3H`>C>aFofjQUxl_A5C@Y}%LBujhuFHScF4@M37o*$0e*Gz~&Nme><dM+fG($LTp
zofd%+dU4XlHRa-L{HM&S<L&eh?J9_Qc}8SFsh{!K&NKqn<1mGF9!=J}ia{pOd9A>{
z;!PjL;WBKVVT0fOHb#gF9m7kES2|iuTEOw)i>pyOJqecBqFCGPhRNH2DY!@K;|Rve
zvp2o(@Z<=?<S;v4epR7A&GEX}O%0YNG99=ax9`c?pD(!HC2wzOnYaGS<yVf$36yZK
zX#A7%xuc__4(6)hJyb}Lhv8Nk!Ek0<-^&SCyK?F==f$fX3U?QEFHi7)e~4|vm1cix
z!%O6$`nm=Gb}n@kxw_|U@NX;{iaEbh>wXHCLYJqRKYu=d<g-~SBIwf%;9;FVT<)4*
z3}QY;jbVwvl*pVcn2>{J$U~#7Tcr*SpSjw3Q^%P?vki+<ob`d8*F0I3N!O=L|C9Yy
z!SlU=jcot#++)t1$TN|Nw+;85D9j+oM;c7G-QL5u8_drWIbt)A-9>1cWD5r$R(H6&
zZ8#}sU>lu;Ct9!q2dKjZ6nx(REC9b#{*QE@b4PLNaVvg~EeAv;8gDP(fhY6nHw3H1
z*KCE<ZXK3XZ=LWy=2#|}GRuZ7q0g}Oi-sf3Dl>1}j6L4avTeena`}|NYr0WpG}+4h
zc|GPxw>YBP4qqTyfRU9c!OJMoF7&zV9Qj5s6&jDa3a8%%Y3Zyc^XF$jFFCMP@(ei1
zc%9Z*U5OG^P9G=#IjXxnx7o};^WocW#K|Of$`LqO$~fL##D@+DC(4Rs?>_l%9G#-K
zdRr3MTSWGd|44>&o5M2w9r@X4F-Cg~5^q2fqJDV47hAEK%;B;a4xY$>RG23W1wfbS
zGJ0j;G}MAL0p+{<({^^$bf#jBde<A;w=oO%yoBD!$BW=+-Br7cyj=&qzSnPK#FuQ(
zfWbH&0xd}dQ^LQo5mVskai@s;oJzZ}O!f$>Sy;VHBRGce&49B~caDk_nkxhqkG~xf
z<V(J3L!D;VblwHM4i(8ohi$zQqoOqaLv91*&<<u&4gZ@aHAm`BJ4{RAu8vpi{uX{5
zE47fIM$TE4F^KTo72MUf?|KG!WbtZM4#0_09AxgiR~2jpsw03~R%g(J=ImJ+1<FPr
z|EMl1(^vTbjVbuC79_9^JdPPfF!$ITu8`YEgzXF}D<JLXN6(FQV?DnBP2DqPsowHt
z!Y>x=`gJ3J`M`-h9s(g|*1ZV}tc3da#7r9`g|J$H;p=+rze+B}Pblh*48%1}c6^8l
zU|meM5J!sqX)(;2{>Sh_^`LLnCktY~W*;s6OZ)lbpPs>7<z0E1vfFywVqz}sh3b+B
z9)h5*&{)XLs)-B0`iIP2y+IPSSh)SH`!mC|;D>GcSzNL4Xu}GUcgeqlx(ZKSV3r<S
zRX9A5s!r2R0Xm0B?QjaIN3`b@bF7fAwm2EJMN;#@X!6^}yvfi!JFdH|7i~wO8mnms
z(7zR<2fE`MUH?|>9o*76Em7;Vr^4h&(YwPm_c{%TE{`5MC~;cf%>>w;$k&sSV$S$<
zT5q#4CASa|Pq<(o*V<&wSmps4#M5{Vw^R5LYZXPSBl(BjhN%`w-@*|&(4>c|%rtA=
zD?A?TI3O0RPFlu|&<r0y)dU9x&Bm-xYr#yYJlpA5*F|D&PSst)5PB1KHBu`M8Ecuu
zQF2@XI!QQ|tbxBAxp`YeLyA=Q*TC?Mum=6GmnMZCojkQSNi@l#ehqx|<1h8KN<xS$
zNuzUAP2pvn9@u`pe#6NC`mac~f0COXV-Gpbz#q@76Rpkb9a9|KIM~?Mb>~i`mQ%Io
z?;-I7KA&ZeGqlBI&y(fmWlCPhmBwD5Ffp^X(9SX=`y%s5bD1(){uo9zW{6bqYBO<{
zkLHC}Ery%E*VZHJv4RR+QpI%jRecJ{R1>nnJPnTTuD9+#+Jl}JLdfA4asl68bE*~%
z#HL>?;r)>CNFYEKs8G2GIl6fPj)L0W(QH_8PWNzZvY{W9C7T}f?n$3l)cD3_)QM5|
zpAAX-X`e>FNI&;``QEJUc;`GnD6But5PuTC5>X+UeGVDjgWs>zv}0DRZ)-|bEpkC<
zhVulh?edYyg1E=K=`T~`<KOVzCKJtXk6|3Uec*C$cI^QwmAMvO9CWsn5%$MNy|^Uu
z?f=OIc*zNG%a~{u*)mhTNpegsA}g9L{<jI_(F0uSTgjXE^3o_H%`8{fhpSOOa08yU
z^OQ$<&D#%%kY{83P!*r*Yn{7MNyFH<b#$!Oi6viRzKBS~s)SR(L?EzKGH$y}TR*;|
zOerZTv*asJa&%%f*_Zj|s&DB0PT9k46Kdf!DV_WBch+?rjfX;G8@e)b`Z$QCHvW$%
z5DuB=qvswlJmE|lUTku!q9WP;@yRC5rwY95PdTGM+{54aQ)&Sj+Th~*=g@xSMAHpy
z1W}<=%{osH0mIklzGDsB6`!72m@wXeY{QODMe1fFVwt<mG2tIbDZPz9<v5}Z13n-q
z$WRQ@%Jq}SjsQe*C+R7KSpzzIV258u7LsucAqOLi)8M#47ya1zt#e7ZnL^`t*#&q~
zhQDfoPAonbHi_qR-2qc=T;vJT0j9S*WE>&YRH7{d{BB)bAM9q_2FhaweDt@ym#@CR
z-iK`P;s}^wNXAv)$3M;?tG%{VTy+VBGDfujfw*Q8^47Zmzx>HOS+NP($085c$55&2
z0YBiG9^eHHY@;CJ595!-C2xsnC<cHsw;J7ulOT0%l&?5h`KCNMtIWiGFQEFs^A*-l
zdSx*QsvsDrjy?Q`1(z%QyWaO_cIG=!ULeYip7V`J;4qDJ1nt5wDQGFmF8)0ei-*X`
z$fIsYz{Mw^bS(d3C+78nM2+CZk>RQB(L3v@7ldh`^c}3ZF<d2gjtw7=LB>{Fjd8AU
z@pb5IHvTYHWoF_|JnZW<1HR!7;bS0giPK0W^S0@XSdo>|#atIMxN(7aY;+*D$rS#j
zbf>2RdNW`UC}TAsZw*-E0RZ-x5!`43lHJL-QE)1oXM(f@rk8k>;p;L>*A^1zGYD{o
zd|`C%(>tmM$StFpZqvH;M+=smQ8^pExNl`V<Epo>7d4uiyDX3JOdlk1DVf@kiM*Bm
zpZr>vV>_!xa+Uor-ZAxnrcJTf(Pk-QvXtX~ytCF={PDW0Y5W_Twu5?M?#fQ1PthZ0
znUb+xnyDvMbFOYnAHR1(LK5^5{7uiVHIDO4<>S~PBTrA)ihCv@$2vRi#5{jjpf5C<
z!(~fPwfEiC>jAcaWugMnRo3F3*C%-eHQX2hK~n8`uuC+<s};bx#!FOll}-++!S4VZ
zH9wSpGY9JIBkG3;{TgNZVkXzHh8uCO?Y>%e`MpU@N|Jq4cBr5ArhbX`*ze+Lzj(ek
zheK1!HiQguJg=NV`dx}c#louHRw2enQ>1C<>$e|hvTBX*P6RKHd%}5l#Ynj3334LG
z>%1<3<Ufj_v+WbZui0)Ug6j&U^risZ=k6l#9)6@4fmAbNezie<cRv)SukQ_Q3mpm^
z>MP#zK-L&kzUbu;za349rs<lMyvK7jcZt<VM7P$Y>(NXHC?gz6slFG#u49hI*#5qW
zUt%$`0qc{Ell59g%m@y+iZ$xu0;g=BBe@=DMs#vl8)9DrXyj`+$SS%Hsd9qf8W72t
ziH<H0xE)C%O3;a)hhNIg5+9#JW9&&4oT|wrrC+Sx?Op{@63(cO`*ss_s}cFbZF4gU
z0g4Y}w{aaM*R5^e({$xqH%{jVGxYwYoaWRNy2G<Zw7)#iLOM%mC-PH;?GKOTC~K7f
z_ym3Vx`KxaAw*oB5FY*k#L%e>t^~2_*ZayaS5VC}jwagry1qA;7NuXDTh_O31=4}!
z9y)zDXdkZ!C4B$<hHhNV8Y$UZ7*cBrtPkD-CXE!;kQ1l!?sG%_MO_~O(rMQEz9v``
zB?N7ZSD?2R9ak=ACk9Jq8X#6lT$mKoeTf{Lc*l{WrP+%!v^e%Pzi{@2{Pl(XYSwKP
zAj@Q`$J>w-u19A_u-I$~Pwd>POOH2h+d=~J=d<o-Mb$$7p|OhJ0r`4D|D?h*rwvZo
zTN&y|{6S!0YTq240||SM7TC|Dm=S#(@mB3JOTtsDCs*V?gBVTqoks4{PX(|2AvG{2
z20*#B$ghc2I)Hl`!olBOm#)A(AI*}%pG|tUg$n#qtlin!gKIF~WfRyp296mum1ebw
zd}xlKqeb0ao7e;m0Mu|G4EKKNeGR-dXt#7_i56J5GxRcD*ZG(mB(+iC;)N2hd9xg#
zI7Tu3sw7oLr!2F=>RauT>t(cqk;paQacXI*^q=#@K_v2#Zmk~eOCq2#nB^x66)VWf
zYE?RzZA`v;TIqv9gu!FOHO~h#aC&@muqI^)IDNSJE5D?^8icdKea4s}Lp1`CutCr9
zZzhDMYQdeq^^l1+waY&)p!8vOhn1d!=~fNto()mY5YQ%o=o1*oNJ|$D01I1O9>`H{
zcd~gZ!Z5Q8jmA)`nLi?=K)6nx@GbnW0^hc8^3O>WNad(qNTD&Ann<diC2?&<R9POj
zp1rA{cs}G=e}B~h)aXVML~CLxgw0MjsuVON(#3dasV6{&cj9VhT-i{dausSNf3W7w
zPCfU|fk*B&FJiy(vD3?C9{cmjWkq6#qFB4XI^M%N1$?hC`L^C2s(tOk<lhUI<Brqy
z<ThM^n{Zxd+bu9470}49)ExY=nDm|mawKr{_xi(pU>1nOjjT!$@naY*gjj}DDS65j
zcE$`MYYkX#Uuw4;HphT7g>;RBo}0_Pjaz@e7%TA$mE*?vF|?AI3D8ow&HAY#cR)?C
zshE#d5xjZ#-A{4Vf;s`{fd@jZQe+XipbG}86XsB~U$<#5v>cwU%KF(vYfKe?Egmb7
z(^6!VW1AF1vIpxOuej8&UfWE*H!;a)(WaA%4lE04r!ubm&B`pVedJ@6L%Ay~#4zqx
ztiI$4z*WwcoxU33-ABP2fvW_gLa7z3J-B++0a&$i7e|@-=ih6GlWgeWSbpmBDEbH!
zY<;^v_-9wDV5)4?&Y#N?bn#@Do3rD$B5j$4`@y&oV@E({Y>n1qt+0g|3~L>ZWP73Y
zkk@x!4SIeF^&L;7sZU01R5T-JlsgLJk`w~-M1m=QMK~Tgpz&abH1nbkZtpwNfyqAp
z8$RDr<c!upbDe}yk1Vlf;7&!DhYIOv9V`aKM@NaG!xihj&;lEuGgiUvv&m)A`-qRp
zfc$UTlX1Q2{Uz|&bu`+r6hO)ILYg@hr&}GCTx2_Y!0~>jM!#o8D9ShI$UcD1@v)EY
zS~}N!=9Bl>nz^g2If%-S0Rcv2HR$tKoC=Ur%!=uvuW5T(iOwGt1MC<|4zbz?LCMae
zxBX*Y8V6ik0C<<>C8WfDH3mD;j>l;&9vN*YAIfgBQW<jacOF`kFL6VM<`}N9BJCW#
zuhyY0&<?9w{qc6*Fa)+s>%48Qf=if`gF@y`ZMH3QZ}d*Z`$BL(q5Kk3Cj$>$a>GxX
z*T*ZOxYx~`LB{sjQ{8*+proIo+i8+e$aHWf#TVgJBx7_l8Jscbx1r{8uSM`U=Pmz~
zv^}Ty-%jq#CY~j}ZJksp&l7he^X~%xsTW9TXL}C~wGJ|APiDh^Vf8;>>osY;V*2_j
zw^7;X=%|XWvf3XI?x*0A8C?hMl|Pixa#VqNDMiqko4G@m;U0jDhV3@>e46L^$$=1$
zj{w}((c236Oo8x=u1O6*L|kFvjd0U0Nh)BX$hpP)^YVPtt8V`YKw8c1-9XW7xG!hA
zSY3y{nc((OOtqJg&*d#N*siv`S&{~d`Ej?^@0{}`Hd6u}^tY3F9E&g~L1a{6F)A_b
zNrBEvxagveSSaIv<o7!wn$`q_=XMv23@ofdP=fH3Ze`PHf{RRvjg(J%F67n1DrSON
zgtD%k`~#^X@Em4lW<V4y1t>?j==*4ei*q&HMw0vBZO9X158`yl=yJxvh1J6k_&So@
z*Yj<zFN@)88|93q6$5b&#G!RtOyWnB@h=CCJdJ3_aJjkvk~AV<o<BYq<1b+643)EH
zBAd)-Ua-l}NSUx^;2I^+KHXY(?pJ>33MuI~3g8|YKr(i(%q(J@_omtrjyi73S;gHv
z9Z8)$jaX#Lp|)iLB7W$FEx+BtXR>sIt3P!Rv=|-$IOEcSy6q+yQ4Yw>EVcgh&ul;{
zT=D{IXXDrV>rcG_S^6wKT1+G3!WK&dbV@`!B$vX6^z6LDjjcnqsppjeK|yF~<Siqb
zmeDYh4gfF}eqf`(YM>$b$_rYF<i7lV=L=GJeL`2dvqbY$g9sOrWVjK^51jk_^e`2I
zgc|<QhB>E^c6mS!VB8q=rU?yld)oST_JSu2Bd8Lg20FD1s8pl!g?wRrJCXwaHKz9s
zHK{ld4-|}Mie;fCF1Uc+fTaI-*QPa~m3|xazr&TGAg@X|P$49|vB}iVS^@$BwP5}O
z8Y`~x%w-OE60r<$(ZLJS7MR@2j$mL#2x>j}jE|l<E<Eh|_x)|p%X4SmrWQE)=0htW
zUn4-ZUD}_Z%yIGX8v=F2xr3?PcQ8CRs2VyQx+7NInjC)!hrv*}%@nN0r#nu7R%ocH
zJz!`PaasnH7&eMt>tsrXaZ;`lgi^rZ-lo>{UqM@dC8A`9MOkYfQBVYgG_V;0X{6P#
z?f%GpHBOPlG0bm@^w<bVa2IWxLxt~H^@Zb@wQpgPt{Jv(|0%a2(<E-U4t_BNIH|#Y
zh2Wf=t)LyQ@;taGjq#a-i*d4!5J^n!?%8AUiIxK)mlxLm5-wq_nA5y?Ge*y%I$iTi
zDAa)OL(S77#E&VXqv%3v^}`Jt@-y=`OIaPT(aV?)V%gW~P+DJ{wv$Gy0GsL$t+pQ|
zf^zS08C8SNn*pse>((aq-4BUh^xe}esu>Flqm<55-Yj)OiX#VX-4{0_B^-JS3Hr+<
z5+r?Fo6-i#tTdH2fzL>9Pu-9NHZq|Z^b_LEW@nZX0x%<pYlvs!*$fHZ&odgk56|7t
zp;^lO_}R4*?cqCqYV(Wgd*qLkH9f^MAm%#zqiUl_Eu{R*jV&u>+^~<=Uf^;!3Ec*d
z(>4eL-K22Q#_nC64C&3oN~LzJ5hMRLA~?8Tc?o2UU(Whq3b10IkKWZ;X1zKDxeo!4
zlb?9fh&rW62XMm)Dl#}zyJKEc?|_IuqBD?+tzFVMOjiq1z!q!&^u{<oi%vBhf9Ndf
zw|XJ#uyP4={22vS@C$n=m!g(BU`z}jg4va0@>IY7f#dH0v0GR>)P2?J`B=@T!Fc{R
zgp03SLH~^UynvcAo2l;CG}TJoQm*<Ht(lM}6oQv;dg14cMkx&x)ZNl@4U~@L<TRYw
zJG+@Fz>Jpn$lAOCACB7I_Y=yIOEjTXs-01j)&S)`LwE{Asc2`R?r7FA+E>&F>%60Y
zw+(0^KQ>i`B&gC0<q~+Et%0W@naaiv%dEz9?AoZ$Q0a~6hzV|_ne|jHKjsENR%ZhP
zgBegghN@k6!888Dgt~U$97>Y7B36S93QyH~8K_qvkXk~(Y9L49awdo+SaNin_W|Ss
zc;*zK)wseIOO2H%d1F{v0wI^pNdQm7l$_%bdK&l=yv`e$*NlkxsMDt#{CAH&GXBux
zi>qHu;<kU2N^cXa4kqXVH(W7&b9UzQ5-pj_hIEsZY2N?K1MRy?@F@Mr_ixRcg7r!G
zT*AA`YgC+D178F9D<05Z<FDK6m)WB`P}BMRJ_E2Frr_CINlYQ`6Ie&b9{J}Jzj;@D
zP4A{62KlUlEvL_Mkd<DS7l5V;*IlP-J<#<OCqBnSR@eAwfOKKd7%ORHUuL!Cn*!Q=
zXHDLto)x&QS!~h;uGMPIJ@NsGU;=$i3bt<Q-cPBb@;e&@b2r_;(JO2RJroGFS+Sd?
zzzSK9uHnVz%_h_d0L1A$uCLrpo9bTA%s%w#@@!EMtXO8{>`oC(eq45r({^-bzKf$-
zXj>d!rOrb&8<neHRdNkP>qYkabTZSR2dg|JY};wx2EXW~vO}2gDcryf!Le8~v;G0%
z`iN7{q)f#_X00PIyoteT)5aiWjo`^TbP$t{e5$8}!E_Awh^f{1!6`v`H1cojpwr2b
z8Wsx=PN+39zoojBtnAc<*`{4-I-HA3MuxiZHZ~U4`ypPo=+FVKrS!o(l^_$j>%XBt
z_(f56?wK+TK|3D`=mNJV#7(O-Op2e!5Dzd4c);<d_pxU2a_{Hs*A>9O+J-p;C4CmH
zW|+!uENy4UjtMf-VzPYiG;LSR+f8{8FB7@#X{07nikp41Wa8Ls03&ShLFS<(M-vm&
zqRx0WFQ6=N@xJj&LJcMPJehDzo6K5-tl}dFcRtzP^3RMbA1A-jNWK*Ndw<N^H(9=F
znN}Z{MJI`eZ_If%_>MbV`lgBca)s@2)0Q&C2PdxM(#XcY*yDct_eE=|<{d6@MeV$_
z3-qoMJt}(+gP;g8Nim%^kMb?xd{HhvuzvI2iX<AF761a|2oF!zo(g;KgC8)GEl1=X
z#B>vRul&=cW_O|RMsD@n>3Wz9>;|aIJXP0CM2_J!2_K-jDErk!Mn=YS>%~2h)>XMp
zLKc<_GUtOIcn&+>#5H!wnXd)Ny<dj+)Rz|1{c+wHPsl`FUy@DXOCSx<o`xL2&g1z`
zay2e}#$o_EJYT~ZYlDp5KwQP9_IN?lrbg_6Szr3itmpxGUM5b?12~&M;8e~(EN4@;
zC12`o{={Wt-P3Q^f?}DtJ4NJj(awdKmc8JQK4$6855i}`aGeqMZ$ntB>IwSiKYcB~
zY^t~(h=@?{OL%6XDtWAUO)Ac=O>ymSrH>D8kLvUB`)($173Y$(`{uYgZ?OH38}mu|
zwI>YoZn6~`eNFOIyl(_$h{4Upn#}}yOuYg3#g~BLp+L$ypYIW{z8J`~!#`Q~vdODU
zxh5Wlb9e}Q&NH?0G!qJN%;@2TJGS1BcC^ZUzEk+ch~(i|%X*lNkpH?#o#%P*jbv~6
z(34HCOCmdx<gKh~LSp{kkeTLlS{nshyszb{<!JacD}rYT#>*ra6_hjIAY2Ddc&zt*
zCM2&1Y%D0}na|*U)OSFs8xA}ieqVl6u6zY##Rw<@w$W*P1>79YgvN_^{B3mezhAf#
zUjKmZ#X%s77JQb7EDV3bu-Z43;puUY=bKu7_B|tnIn_`2gaNfped0*QaS{!NgGr*U
z2gcRK5eWDo72!pp+kbU(d_Vg_05WI=g9Q63U4F6^BlmZJp{UuC@kr3qy>;7tuPB%d
z%RxH!iPT@Gu}N?hBzyG*FF?Ve$p}}8w{MT8hs(_$tVatzLpF#$tSASm3zmE%%OvCc
zFV%uV=2jl}nzC`cHVyyZa){8B%|*^**WiB8HaAI)X?{1fJKpP#3>uHf1FG>8XPK`$
zC-t4RAt*4>R#3PL^1$hrA)9W&XZk(pXbBiKm;CAq2tDnLKOZ~~wogjs(pRoO1A^=N
zYbl1L{1ZRIY1lg5sOJaR{f-rO^VI|SKzqS!VDn4lk|-s(Riw?K(W2@s>#HB3&YEba
zt}?~av9WkN`&a;O-H2Z^hm@~|fV!xAiQT+3B6u2Zp%^N}W&QP9{a)_3W^x8b{Xr!!
zeE!6Tb-iGFX;5Re*JhuDMFeIVLjdYv^pR2%_^_RHc#aY$1%NOy9zAU(rGtB}d*P-4
zF%+6B7F}aozUSG_Hbb;(Kvw_^Kiuc^<`9f21SZJzx`eeGsqX4@Pn<B`#&0Dw1o!b?
zCh?j;llqm!8p|_-ZS~fqp9@7jYU0^i8Ze;_XJW7kY-;vnzu%DjVJNBxm&IV>V`W?c
zxF?XI7H!}9l+5#J8hqomZt)FQP+?E^mK#`qgVf$C@N~Pi#^8xZpfv?kZAM%rv|)%7
zOV<>{P#WDrO!<We1_usUu-fTE@=zJFV2TAsUZ_Djmk6H@5$bjI^iwmp<Wg3g4!bLX
zF?JdDfdS4jF->HFV|&H7?c+<uWvtDrO#y9HW>)nWz<`FOj{*tuFq|0HKF8sjIc-kL
zMI%cs)LJd!(*pRb`Yg|pGdRwc?fNDZSi3|K#4mV>S@nK_u7z*MM|OV`?xtmRM%k%<
z4C#bOrQT@;+<Z65X@D&1EsYkPn+@5-lcA5r&ZJ!*sgX81%MAJ6zxLaEDJsZRb!Yg=
zI}%mH2)n&c4Qw0Vt<GMRSt5Z2mzfPTOFm6xH%4oS&>u#uJC4J!dNUWT*Z378uxnR2
z?!<W3#MP8Te1w{c%5tnM#5>%2*)l)1LtXr<*DIL=nLuo6y7k^HaJt$Nf8C{@nGd?G
zmyQJ6yKVr_OR!`F;siFH^V%rZ+AeLsO`E~|pdA15Bd~6I;u(E1;8wAbF$nkB@X0IU
z6q-s(*d)_n#lz@qt?h$|Wr!#PMR&SbP<=uae~u#tr5&20Tw(bq>3jRFAlG6e*LB#Y
zBMX^k{kt$IBL|#WQrB4_Dn|d(p#mh_bwjie_`Ha`P1Es!|75VG?op?rxE7>Qf~`OY
z(KWp$E&meI*%9Nvm-<oiuBe?-^u(YF1kb44!IpvGt@{7-i-D-OG%B5xPeb~?ycuu1
zNN#YF;MptlHf%h0%Qk~$K@E3%$mM&2VA>lX$~q=GP=V?9x=8c`x@Hl)+)U!!oRQ~4
zy0jn;DbZrNr^$(TAiAZ}TJWDpRAG5uxik91K=raf2z9c2C;UJ0q+YD4(aUm3rJo%`
zc?5{gW(Iz8sJacgEcfXWqe5JVMlO|?$8nIdk&=~t3Vfzn3I`QL2XHs=38G{ay3d(3
zAV0S~0JssZASo8;{f6KtQN$gQ;!N9qQ7-7w7fJ9KZS^*7-e(X47H_0Qh2LPv!bTJD
zb;q%!hDJuUMudmI%#_3;&C@JL@z&*@yx1pL9ae3CDiz?<lOnO;ZzS*=W`Q-d_n?H?
z?Vk36kR85Up-Qe2#6o7aA$S8H-9gx043F0DqPYX^Az*N8D)dLbvBW~grBH7N>fJ!f
zibP}ug?eluZ$}xqOV`lY)TB6>qgG%#jjcQkRtl1mYbcW1`FJRDm;EM58~vH7>Q@yh
z|L2laqwv^JNNX`yIAq|#C7fQ{r9j?{JE+j;<0W`!*-O&?pF37Ma)p{cbpHj39(5_8
z&dcin(-@LuTGI%bZlC{L)hH-YhBBad55N6i{_-jfh{eC0e1J+HDvbH-<bSOmc(mF7
k|Am6tGl2{?P-lgiq0@b(*DkGPTYw@Ap00i_>zopr0F)<B5&!@I

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/03-branch-picker.png b/collab-electron/docs/screenshots/scm/03-branch-picker.png
new file mode 100644
index 0000000000000000000000000000000000000000..6fbfb4034b221cce4979618e185b2dbc6b13fd37
GIT binary patch
literal 52741
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
Mg~O{Ct6sbRUva_@bpQYW

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/04-sync-remotes.png b/collab-electron/docs/screenshots/scm/04-sync-remotes.png
new file mode 100644
index 0000000000000000000000000000000000000000..a51fe6a47370569479b0200ffbd77ab0ed1b2dba
GIT binary patch
literal 47392
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
F`Y+_e*o6Q9

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/05-merge-conflicts.png b/collab-electron/docs/screenshots/scm/05-merge-conflicts.png
new file mode 100644
index 0000000000000000000000000000000000000000..9328be784ddc5bcd3098294f519feee384bc55f8
GIT binary patch
literal 48475
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

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/06-history.png b/collab-electron/docs/screenshots/scm/06-history.png
new file mode 100644
index 0000000000000000000000000000000000000000..25e99a2f6cc5c8f120a6e85e1d6785105391e2ea
GIT binary patch
literal 62066
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

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/07-interactive-rebase.png b/collab-electron/docs/screenshots/scm/07-interactive-rebase.png
new file mode 100644
index 0000000000000000000000000000000000000000..a418e9ee05457276ba0702876881cabcb3ff07c1
GIT binary patch
literal 61141
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

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/08-stash.png b/collab-electron/docs/screenshots/scm/08-stash.png
new file mode 100644
index 0000000000000000000000000000000000000000..196d8cefd96dbbac0bc26b2dc70d9c33329ab85c
GIT binary patch
literal 54744
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
Z!@zuwwkcjd6kqvALrs_PROOQY{{af~gbx4!

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/09-viewer-diff.png b/collab-electron/docs/screenshots/scm/09-viewer-diff.png
new file mode 100644
index 0000000000000000000000000000000000000000..6a468af958a1307cb2b1620fb8a942cdea54e24e
GIT binary patch
literal 72286
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

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/10-settings-git.png b/collab-electron/docs/screenshots/scm/10-settings-git.png
new file mode 100644
index 0000000000000000000000000000000000000000..fdbcb280d14089e13e262e0bf149a000f157bb6b
GIT binary patch
literal 52855
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
YZ+d>=JPCM+znNvUZ8!Dd)_-02AFmXN>;M1&

literal 0
HcmV?d00001

diff --git a/collab-electron/docs/screenshots/scm/QA_RESULTS.md b/collab-electron/docs/screenshots/scm/QA_RESULTS.md
new file mode 100644
index 00000000..a6cdde89
--- /dev/null
+++ b/collab-electron/docs/screenshots/scm/QA_RESULTS.md
@@ -0,0 +1,34 @@
+# SCM QA results
+
+Run date: 2026-06-01  
+Branch: `dev` (PR #44)
+
+## Automated (fixture + backend)
+
+| Area | Result | Notes |
+|------|--------|-------|
+| Fixture setup (`setup-all.sh`) | **PASS** | merge-conflict, submodule, rebase-todo, dirty-worktree |
+| `gitStatus` / `gitRepoState` | **PASS** | clean, merging, interactive-rebase states |
+| Stage / unstage / commit | **PASS** | temp repo in `git-source-control.fixture.test.ts` |
+| Branches / tags / remotes / stash | **PASS** | dirty-worktree fixture |
+| Merge conflict detection | **PASS** | unmerged `base.txt` in merge-conflict |
+| Rebase todo parse | **PASS** | Falls back to `git-rebase-todo.backup` when paused at `break` |
+| Submodule / worktree list | **PASS** | submodule fixture |
+| `gitLog` / `gitDiff` | **PASS** | dirty-worktree |
+| `npm run build` (collab-electron) | **PASS** | electron-vite production build |
+| Dark screenshots 01–10 | **PASS** | `bun scripts/capture-scm-screenshots.mjs` |
+
+Test command:
+
+```bash
+./fixtures/git/setup-all.sh
+cd collab-electron && bun test src/main/git-source-control.fixture.test.ts
+```
+
+## Manual only (Electron UI)
+
+Per [SCM_TEST_MATRIX.md](../../SCM_TEST_MATRIX.md): context menus, real push/pull, clone flow, GPG sign commit, LFS badge, graph replay, partial hunk staging in live app. Screenshots use component harness + git bridge, not full Electron shell.
+
+## Fix applied during QA
+
+- `gitRebaseTodoList`: read `git-rebase-todo.backup` when primary todo is empty (interactive rebase paused at `break`).
diff --git a/collab-electron/docs/screenshots/scm/README.md b/collab-electron/docs/screenshots/scm/README.md
new file mode 100644
index 00000000..9b227ca8
--- /dev/null
+++ b/collab-electron/docs/screenshots/scm/README.md
@@ -0,0 +1,30 @@
+# SCM screenshots
+
+PNG captures of the Source Control UI (Phase 0–2) for PR #44 review. Rendered with real `@collab/components` styles, dark theme, and live `git` data from `fixtures/git/`.
+
+## Regenerating
+
+From the repository root:
+
+```bash
+./fixtures/git/setup-all.sh
+cd collab-electron
+bun scripts/capture-scm-screenshots.mjs
+```
+
+Requires Bun, Chromium (installed automatically via Playwright on first run), and `git` on `PATH`.
+
+## Files
+
+| File | What it shows |
+|------|----------------|
+| `01-scm-overview.png` | Full SCM panel: branch header, sync bar, commit box, staged/unstaged/untracked changes (`fixtures/git/dirty-worktree`) |
+| `02-commit-box.png` | Commit message area with sample text, Amend, Commit / Commit & Push / Commit & Sync |
+| `03-branch-picker.png` | Branch picker dropdown with local branches and tags |
+| `04-sync-remotes.png` | **Manage Remotes** modal (origin + backup from dirty-worktree fixture) |
+| `05-merge-conflicts.png` | Merge-in-progress banner and conflicted `base.txt` (`fixtures/git/merge-conflict`) |
+| `06-history.png` | History section expanded with commit list and selected commit file list |
+| `07-interactive-rebase.png` | Interactive rebase todo list with actions (`fixtures/git/rebase-todo`) |
+| `08-stash.png` | Stashes section expanded with saved stashes |
+| `09-viewer-diff.png` | Viewer-style Monaco side-by-side diff for `base.txt` during merge |
+| `10-settings-git.png` | Settings → Git read-only config (`user.name`, `user.email`, etc.) |
diff --git a/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.css b/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.css
new file mode 100644
index 00000000..4b1151a9
--- /dev/null
+++ b/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.css
@@ -0,0 +1,33 @@
+.diff-editor-root {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
+}
+
+.diff-editor-hunks {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  padding: 6px 8px;
+  border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+}
+
+.diff-editor-hunk-btn {
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 4px;
+  border: 1px solid var(--border);
+  background: transparent;
+  color: var(--foreground);
+  cursor: pointer;
+}
+
+.diff-editor-hunk-btn:hover {
+  background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.diff-editor-container {
+  flex: 1;
+  min-height: 0;
+}
diff --git a/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.tsx b/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.tsx
new file mode 100644
index 00000000..5398c3b5
--- /dev/null
+++ b/collab-electron/packages/components/src/DiffEditorView/DiffEditorView.tsx
@@ -0,0 +1,106 @@
+import { useEffect, useRef } from "react";
+import * as monaco from "monaco-editor";
+import editorWorker from "monaco-editor/esm/vs/editor/editor.worker?worker";
+import "./DiffEditorView.css";
+
+self.MonacoEnvironment = {
+  getWorker() {
+    return new editorWorker();
+  },
+};
+
+function languageFromPath(filePath: string): string {
+  const ext = filePath.slice(filePath.lastIndexOf(".") + 1).toLowerCase();
+  const map: Record<string, string> = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    json: "json",
+    py: "python",
+    md: "markdown",
+    css: "css",
+    html: "html",
+    yaml: "yaml",
+    yml: "yaml",
+    sh: "shell",
+  };
+  return map[ext] ?? "plaintext";
+}
+
+export interface DiffEditorViewProps {
+  filePath: string;
+  original: string;
+  modified: string;
+  readOnly?: boolean;
+  theme?: "light" | "dark";
+  onStageHunk?: (patch: string) => void;
+  hunks?: Array<{ index: number; header: string; patch: string }>;
+}
+
+export function DiffEditorView({
+  filePath,
+  original,
+  modified,
+  readOnly = true,
+  theme = "dark",
+  onStageHunk,
+  hunks,
+}: DiffEditorViewProps) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const editorRef = useRef<monaco.editor.IStandaloneDiffEditor | null>(null);
+
+  useEffect(() => {
+    if (!containerRef.current) return;
+
+    const lang = languageFromPath(filePath);
+    const originalModel = monaco.editor.createModel(
+      original,
+      lang,
+      monaco.Uri.parse(`git-diff-original://${filePath}`),
+    );
+    const modifiedModel = monaco.editor.createModel(
+      modified,
+      lang,
+      monaco.Uri.parse(`git-diff-modified://${filePath}`),
+    );
+
+    const diffEditor = monaco.editor.createDiffEditor(containerRef.current, {
+      readOnly,
+      renderSideBySide: true,
+      automaticLayout: true,
+      theme: theme === "dark" ? "vs-dark" : "vs",
+      originalEditable: false,
+    });
+    diffEditor.setModel({ original: originalModel, modified: modifiedModel });
+    editorRef.current = diffEditor;
+
+    return () => {
+      diffEditor.dispose();
+      originalModel.dispose();
+      modifiedModel.dispose();
+      editorRef.current = null;
+    };
+  }, [filePath, original, modified, readOnly, theme]);
+
+  return (
+    <div className="diff-editor-root">
+      {hunks && hunks.length > 0 && onStageHunk && (
+        <div className="diff-editor-hunks">
+          {hunks.map((hunk) => (
+            <button
+              key={hunk.index}
+              type="button"
+              className="diff-editor-hunk-btn"
+              onClick={() => onStageHunk(hunk.patch)}
+              title="Stage this hunk"
+            >
+              Stage hunk {hunk.index + 1}
+            </button>
+          ))}
+        </div>
+      )}
+      <div ref={containerRef} className="diff-editor-container" />
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/DiffEditorView/index.ts b/collab-electron/packages/components/src/DiffEditorView/index.ts
new file mode 100644
index 00000000..4994d35e
--- /dev/null
+++ b/collab-electron/packages/components/src/DiffEditorView/index.ts
@@ -0,0 +1,2 @@
+export { DiffEditorView } from "./DiffEditorView";
+export type { DiffEditorViewProps } from "./DiffEditorView";
diff --git a/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx b/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
index 73559068..01a9bb18 100644
--- a/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
+++ b/collab-electron/packages/components/src/SourceControl/BranchPicker.tsx
@@ -10,28 +10,41 @@ import {
 	Plus,
 	Trash,
 	Check,
+	Tag,
 } from '@phosphor-icons/react';
-import type { GitBranch as GitBranchType } from '@collab/shared/git-types';
+import type {
+	GitBranch as GitBranchType,
+	GitTag,
+} from '@collab/shared/git-types';
 
 interface BranchPickerProps {
+	workspacePath: string;
 	currentBranch: string;
 	onSwitch: (branch: string) => Promise<void>;
 	onCreate: (name: string) => Promise<void>;
 	onDelete: (name: string) => Promise<void>;
+	onMerge?: (branch: string) => Promise<void>;
+	onRebase?: (branch: string) => Promise<void>;
+	onInteractiveRebase?: () => void;
 	onError: (msg: string) => void;
 }
 
 export function BranchPicker({
+	workspacePath,
 	currentBranch,
 	onSwitch,
 	onCreate,
 	onDelete,
+	onMerge,
+	onRebase,
+	onInteractiveRebase,
 	onError,
 }: BranchPickerProps) {
 	const [open, setOpen] = useState(false);
 	const [branches, setBranches] = useState<GitBranchType[]>(
 		[],
 	);
+	const [tags, setTags] = useState<GitTag[]>([]);
 	const [filter, setFilter] = useState('');
 	const [creating, setCreating] = useState(false);
 	const [newName, setNewName] = useState('');
@@ -41,12 +54,17 @@ export function BranchPicker({
 
 	const loadBranches = useCallback(async () => {
 		try {
-			const result = await window.api.gitBranches();
-			setBranches(result);
+			const [branchList, tagList] = await Promise.all([
+				window.api.gitBranches(workspacePath),
+				window.api.gitTags(workspacePath),
+			]);
+			setBranches(branchList);
+			setTags(tagList);
 		} catch {
 			setBranches([]);
+			setTags([]);
 		}
-	}, []);
+	}, [workspacePath]);
 
 	useEffect(() => {
 		if (open) {
@@ -59,7 +77,6 @@ export function BranchPicker({
 		}
 	}, [open, loadBranches]);
 
-	// Close on outside click
 	useEffect(() => {
 		if (!open) return;
 		const handler = (e: MouseEvent) => {
@@ -80,7 +97,6 @@ export function BranchPicker({
 			);
 	}, [open]);
 
-	// Close on Escape
 	useEffect(() => {
 		if (!open) return;
 		const handler = (e: KeyboardEvent) => {
@@ -92,11 +108,19 @@ export function BranchPicker({
 	}, [open]);
 
 	const handleSwitch = useCallback(
-		async (branch: string) => {
-			if (branch === currentBranch) return;
+		async (ref: string, isTag?: boolean) => {
+			if (ref === currentBranch) return;
+			if (
+				isTag &&
+				!window.confirm(
+					`Checkout tag "${ref}"? This puts you in detached HEAD state.`,
+				)
+			) {
+				return;
+			}
 			setLoading(true);
 			try {
-				await onSwitch(branch);
+				await onSwitch(ref);
 				setOpen(false);
 			} catch (err) {
 				onError(
@@ -130,6 +154,17 @@ export function BranchPicker({
 
 	const handleDelete = useCallback(
 		async (name: string) => {
+			if (name === currentBranch) {
+				onError('Cannot delete the current branch');
+				return;
+			}
+			if (
+				!window.confirm(
+					`Delete branch "${name}"?`,
+				)
+			) {
+				return;
+			}
 			setLoading(true);
 			try {
 				await onDelete(name);
@@ -144,22 +179,22 @@ export function BranchPicker({
 				setLoading(false);
 			}
 		},
-		[onDelete, onError, loadBranches],
+		[currentBranch, onDelete, onError, loadBranches],
 	);
 
+	const q = filter.toLowerCase();
 	const localBranches = branches.filter(
 		(b) =>
 			!b.isRemote &&
-			b.name
-				.toLowerCase()
-				.includes(filter.toLowerCase()),
+			b.name.toLowerCase().includes(q),
 	);
 	const remoteBranches = branches.filter(
 		(b) =>
 			b.isRemote &&
-			b.name
-				.toLowerCase()
-				.includes(filter.toLowerCase()),
+			b.name.toLowerCase().includes(q),
+	);
+	const filteredTags = tags.filter((t) =>
+		t.name.toLowerCase().includes(q),
 	);
 
 	return (
@@ -266,9 +301,104 @@ export function BranchPicker({
 								))}
 							</div>
 						)}
+
+						{filteredTags.length > 0 && (
+							<div className="scm-branch-group">
+								<div className="scm-branch-group-label">
+									Tags
+								</div>
+								{filteredTags.map((t) => (
+									<div
+										key={t.name}
+										className="scm-branch-item tag"
+										onClick={() =>
+											handleSwitch(
+												t.name,
+												true,
+											)
+										}
+									>
+										<Tag
+											size={12}
+											weight="bold"
+										/>
+										<span className="scm-branch-item-name">
+											{t.name}
+										</span>
+									</div>
+								))}
+							</div>
+						)}
 					</div>
 
 					<div className="scm-branch-footer">
+						{onMerge && (
+							<button
+								type="button"
+								className="scm-branch-item"
+								onClick={async () => {
+									const branch = localBranches.find(
+										(b) => !b.current,
+									)?.name;
+									if (!branch) return;
+									const name = window.prompt(
+										'Merge branch into current:',
+										branch,
+									);
+									if (name) {
+										try {
+											await onMerge(name);
+										} catch (err) {
+											onError(
+												err instanceof Error
+													? err.message
+													: 'Merge failed',
+											);
+										}
+									}
+								}}
+							>
+								Merge branch…
+							</button>
+						)}
+						{onRebase && (
+							<button
+								type="button"
+								className="scm-branch-item"
+								onClick={async () => {
+									const branch = localBranches.find(
+										(b) => !b.current,
+									)?.name;
+									if (!branch) return;
+									const name = window.prompt(
+										'Rebase current onto:',
+										branch,
+									);
+									if (name) {
+										try {
+											await onRebase(name);
+										} catch (err) {
+											onError(
+												err instanceof Error
+													? err.message
+													: 'Rebase failed',
+											);
+										}
+									}
+								}}
+							>
+								Rebase onto…
+							</button>
+						)}
+						{onInteractiveRebase && (
+							<button
+								type="button"
+								className="scm-branch-item"
+								onClick={onInteractiveRebase}
+							>
+								Interactive rebase…
+							</button>
+						)}
 						{creating ? (
 							<div className="scm-branch-create-input">
 								<input
@@ -312,6 +442,12 @@ export function BranchPicker({
 							</button>
 						)}
 					</div>
+
+					{loading && (
+						<div className="scm-branch-loading">
+							Working...
+						</div>
+					)}
 				</div>
 			)}
 		</div>
diff --git a/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx b/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
index 23930893..725e8cd3 100644
--- a/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
+++ b/collab-electron/packages/components/src/SourceControl/ChangeSectionHeader.tsx
@@ -3,13 +3,16 @@ import {
 	CaretDown,
 	Plus,
 	Minus,
+	Trash,
 } from '@phosphor-icons/react';
 
 interface ChangeSectionHeaderProps {
 	title: string;
 	count: number;
-	actionIcon: 'stage' | 'unstage';
-	onAction: () => void;
+	actionIcon?: 'stage' | 'unstage';
+	onAction?: () => void;
+	secondaryActionIcon?: 'discard';
+	onSecondaryAction?: () => void;
 	children: React.ReactNode;
 }
 
@@ -18,15 +21,26 @@ export function ChangeSectionHeader({
 	count,
 	actionIcon,
 	onAction,
+	secondaryActionIcon,
+	onSecondaryAction,
 	children,
 }: ChangeSectionHeaderProps) {
 	const [collapsed, setCollapsed] = useState(false);
 
 	if (count === 0) return null;
 
-	const ActionIcon = actionIcon === 'stage' ? Plus : Minus;
+	const ActionIcon =
+		actionIcon === 'stage'
+			? Plus
+			: actionIcon === 'unstage'
+				? Minus
+				: null;
 	const actionTitle =
-		actionIcon === 'stage' ? 'Stage All' : 'Unstage All';
+		actionIcon === 'stage'
+			? 'Stage All'
+			: actionIcon === 'unstage'
+				? 'Unstage All'
+				: '';
 
 	return (
 		<>
@@ -41,17 +55,33 @@ export function ChangeSectionHeader({
 				</span>
 				<span>{title}</span>
 				<span className="scm-section-count">{count}</span>
-				<button
-					type="button"
-					className="scm-section-action"
-					title={actionTitle}
-					onClick={(e) => {
-						e.stopPropagation();
-						onAction();
-					}}
-				>
-					<ActionIcon size={14} />
-				</button>
+				{secondaryActionIcon === 'discard' &&
+					onSecondaryAction && (
+						<button
+							type="button"
+							className="scm-section-action discard"
+							title="Discard All Changes"
+							onClick={(e) => {
+								e.stopPropagation();
+								onSecondaryAction();
+							}}
+						>
+							<Trash size={14} />
+						</button>
+					)}
+				{ActionIcon && onAction && (
+					<button
+						type="button"
+						className="scm-section-action"
+						title={actionTitle}
+						onClick={(e) => {
+							e.stopPropagation();
+							onAction();
+						}}
+					>
+						<ActionIcon size={14} />
+					</button>
+				)}
 			</div>
 			{!collapsed && children}
 		</>
diff --git a/collab-electron/packages/components/src/SourceControl/CloneRepositoryModal.tsx b/collab-electron/packages/components/src/SourceControl/CloneRepositoryModal.tsx
new file mode 100644
index 00000000..6a1d0531
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/CloneRepositoryModal.tsx
@@ -0,0 +1,103 @@
+import { useState } from "react";
+import { X } from "@phosphor-icons/react";
+
+interface CloneRepositoryModalProps {
+  open: boolean;
+  onClose: () => void;
+  onCloned: (path: string) => void;
+  onError: (msg: string) => void;
+}
+
+export function CloneRepositoryModal({
+  open,
+  onClose,
+  onCloned,
+  onError,
+}: CloneRepositoryModalProps) {
+  const [url, setUrl] = useState("");
+  const [parentDir, setParentDir] = useState("");
+  const [branch, setBranch] = useState("");
+  const [cloning, setCloning] = useState(false);
+
+  if (!open) return null;
+
+  const handlePickParent = async () => {
+    const picked = await window.api.openFolder();
+    if (picked) setParentDir(picked);
+  };
+
+  const handleClone = async () => {
+    if (!url.trim() || !parentDir.trim()) {
+      onError("URL and parent folder are required");
+      return;
+    }
+    setCloning(true);
+    try {
+      const result = await window.api.gitClone(
+        url.trim(),
+        parentDir.trim(),
+        branch.trim() ? { branch: branch.trim() } : undefined,
+      );
+      onCloned(result.path);
+      onClose();
+      setUrl("");
+      setBranch("");
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Clone failed");
+    } finally {
+      setCloning(false);
+    }
+  };
+
+  return (
+    <div className="scm-modal-overlay" onClick={onClose}>
+      <div className="scm-modal" onClick={(e) => e.stopPropagation()}>
+        <div className="scm-modal-header">
+          <h3>Clone Repository</h3>
+          <button type="button" className="scm-modal-close" onClick={onClose}>
+            <X size={16} />
+          </button>
+        </div>
+        <div className="scm-modal-body scm-clone-form">
+          <label>
+            Repository URL
+            <input
+              value={url}
+              onChange={(e) => setUrl(e.target.value)}
+              placeholder="https://github.com/org/repo.git"
+            />
+          </label>
+          <label>
+            Parent directory
+            <div className="scm-clone-parent">
+              <input
+                value={parentDir}
+                onChange={(e) => setParentDir(e.target.value)}
+                placeholder="/path/to/parent"
+              />
+              <button type="button" onClick={() => void handlePickParent()}>
+                Browse…
+              </button>
+            </div>
+          </label>
+          <label>
+            Branch (optional)
+            <input
+              value={branch}
+              onChange={(e) => setBranch(e.target.value)}
+              placeholder="main"
+            />
+          </label>
+          <button
+            type="button"
+            className="scm-init-button"
+            disabled={cloning}
+            onClick={() => void handleClone()}
+          >
+            {cloning ? "Cloning…" : "Clone"}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
index cb787f49..f2d859ea 100644
--- a/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
+++ b/collab-electron/packages/components/src/SourceControl/CommitBox.tsx
@@ -3,6 +3,8 @@ import {
 	Check,
 	Sparkle,
 	CircleNotch,
+	ArrowUp,
+	ArrowsClockwise,
 } from '@phosphor-icons/react';
 
 interface CommitBoxProps {
@@ -12,7 +14,16 @@ interface CommitBoxProps {
 	canGenerate: boolean;
 	agentName?: string;
 	hasAnyChanges: boolean;
+	hasCommits: boolean;
+	hasMergeConflicts: boolean;
+	amend: boolean;
+	onAmendChange: (amend: boolean) => void;
+	signCommit: boolean;
+	onSignCommitChange: (sign: boolean) => void;
+	showSignOption?: boolean;
 	onCommit: () => void;
+	onCommitAndPush: () => void;
+	onCommitAndSync: () => void;
 	onGenerateMessage: () => void;
 	committing: boolean;
 	generating: boolean;
@@ -21,17 +32,29 @@ interface CommitBoxProps {
 export function CommitBox({
 	message,
 	onMessageChange,
-	hasStagedChanges,
+	hasStagedChanges: _hasStagedChanges,
 	canGenerate,
 	agentName,
 	hasAnyChanges,
+	hasCommits,
+	hasMergeConflicts,
+	amend,
+	onAmendChange,
+	signCommit,
+	onSignCommitChange,
+	showSignOption,
 	onCommit,
+	onCommitAndPush,
+	onCommitAndSync,
 	onGenerateMessage,
 	committing,
 	generating,
 }: CommitBoxProps) {
 	const canCommit =
-		hasAnyChanges && message.trim().length > 0 && !committing;
+		hasAnyChanges &&
+		message.trim().length > 0 &&
+		!committing &&
+		!hasMergeConflicts;
 
 	const handleKeyDown = useCallback(
 		(e: React.KeyboardEvent) => {
@@ -62,14 +85,43 @@ export function CommitBox({
 		<div className="scm-commit-box">
 			<textarea
 				className="scm-commit-textarea"
-				placeholder="Commit message..."
+				placeholder={
+					hasMergeConflicts
+						? 'Resolve merge conflicts before committing'
+						: 'Commit message...'
+				}
 				value={message}
 				onChange={(e) =>
 					onMessageChange(e.target.value)
 				}
 				onKeyDown={handleKeyDown}
 				rows={3}
+				disabled={hasMergeConflicts}
 			/>
+			<label className="scm-commit-amend">
+				<input
+					type="checkbox"
+					checked={amend}
+					disabled={!hasCommits || hasMergeConflicts}
+					onChange={(e) =>
+						onAmendChange(e.target.checked)
+					}
+				/>
+				<span>Amend</span>
+			</label>
+			{showSignOption && (
+				<label className="scm-commit-amend scm-sign-row">
+					<input
+						type="checkbox"
+						checked={signCommit}
+						disabled={hasMergeConflicts}
+						onChange={(e) =>
+							onSignCommitChange(e.target.checked)
+						}
+					/>
+					<span>Sign commit</span>
+				</label>
+			)}
 			<div className="scm-commit-actions">
 				<button
 					type="button"
@@ -90,6 +142,26 @@ export function CommitBox({
 						{committing ? 'Committing...' : 'Commit'}
 					</span>
 				</button>
+				<button
+					type="button"
+					className="scm-commit-button secondary"
+					disabled={!canCommit}
+					onClick={onCommitAndPush}
+					title="Commit and push"
+				>
+					<ArrowUp size={14} weight="bold" />
+					<span>Commit &amp; Push</span>
+				</button>
+				<button
+					type="button"
+					className="scm-commit-button secondary"
+					disabled={!canCommit}
+					onClick={onCommitAndSync}
+					title="Commit, pull, and push"
+				>
+					<ArrowsClockwise size={14} weight="bold" />
+					<span>Commit &amp; Sync</span>
+				</button>
 				<button
 					type="button"
 					className={`scm-ai-button${generating ? ' generating' : ''}`}
diff --git a/collab-electron/packages/components/src/SourceControl/CompareBranchModal.tsx b/collab-electron/packages/components/src/SourceControl/CompareBranchModal.tsx
new file mode 100644
index 00000000..4a53b305
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/CompareBranchModal.tsx
@@ -0,0 +1,69 @@
+import { useEffect, useState } from "react";
+import { X } from "@phosphor-icons/react";
+import type { GitBranch } from "@collab/shared/git-types";
+
+interface CompareBranchModalProps {
+  workspacePath: string;
+  relativePath: string;
+  open: boolean;
+  onClose: () => void;
+}
+
+export function CompareBranchModal({
+  workspacePath,
+  relativePath,
+  open,
+  onClose,
+}: CompareBranchModalProps) {
+  const [branches, setBranches] = useState<GitBranch[]>([]);
+
+  useEffect(() => {
+    if (!open) return;
+    window.api
+      .gitBranches(workspacePath)
+      .then((list) =>
+        setBranches(list.filter((b) => !b.isRemote && !b.current)),
+      )
+      .catch(() => setBranches([]));
+  }, [open, workspacePath]);
+
+  if (!open) return null;
+
+  const compare = (branchName: string) => {
+    window.api.openGitDiff({
+      workspacePath,
+      relativePath,
+      left: { ref: branchName, label: branchName },
+      right: { ref: "working", label: "Working Tree" },
+    });
+    onClose();
+  };
+
+  return (
+    <div className="scm-modal-overlay" onClick={onClose}>
+      <div className="scm-modal scm-modal-narrow" onClick={(e) => e.stopPropagation()}>
+        <div className="scm-modal-header">
+          <h3>Compare with Branch</h3>
+          <button type="button" className="scm-modal-close" onClick={onClose}>
+            <X size={16} />
+          </button>
+        </div>
+        <div className="scm-modal-body scm-branch-list">
+          {branches.length === 0 && (
+            <span className="scm-empty-inline">No other branches</span>
+          )}
+          {branches.map((b) => (
+            <button
+              key={b.name}
+              type="button"
+              className="scm-branch-pick"
+              onClick={() => compare(b.name)}
+            >
+              {b.name}
+            </button>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/DiffView.tsx b/collab-electron/packages/components/src/SourceControl/DiffView.tsx
index 1b818ef8..31da26e7 100644
--- a/collab-electron/packages/components/src/SourceControl/DiffView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/DiffView.tsx
@@ -6,6 +6,7 @@ import React, {
 import { X, ArrowsOutSimple } from '@phosphor-icons/react';
 
 interface DiffViewProps {
+	workspacePath: string;
 	filePath: string;
 	relativePath: string;
 	cached: boolean;
@@ -44,6 +45,7 @@ function parseDiff(raw: string): DiffLine[] {
 }
 
 export function DiffView({
+	workspacePath,
 	filePath,
 	relativePath,
 	cached,
@@ -56,7 +58,7 @@ export function DiffView({
 	useEffect(() => {
 		setLoading(true);
 		window.api
-			.gitDiff(relativePath, cached)
+			.gitDiff(workspacePath, relativePath, cached)
 			.then((result) => {
 				setDiff(result);
 				setLoading(false);
@@ -65,12 +67,12 @@ export function DiffView({
 				setDiff('');
 				setLoading(false);
 			});
-	}, [relativePath, cached]);
+	}, [workspacePath, relativePath, cached]);
 
 	if (loading) {
 		return (
 			<div className="scm-diff-container">
-				<div className="scm-diff-header">
+				<div className="scm-diff-toolbar">
 					<span className="scm-diff-title">
 						Loading...
 					</span>
@@ -82,7 +84,7 @@ export function DiffView({
 	if (!diff) {
 		return (
 			<div className="scm-diff-container">
-				<div className="scm-diff-header">
+				<div className="scm-diff-toolbar">
 					<span className="scm-diff-title">
 						{relativePath}
 					</span>
@@ -105,11 +107,11 @@ export function DiffView({
 
 	return (
 		<div className="scm-diff-container">
-			<div className="scm-diff-header">
+			<div className="scm-diff-toolbar">
 				<span className="scm-diff-title">
 					{relativePath}
 				</span>
-				<div className="scm-diff-header-actions">
+				<div className="scm-diff-toolbar-actions">
 					<button
 						type="button"
 						className="scm-diff-action"
diff --git a/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx b/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
index 201d76af..d9cae9b8 100644
--- a/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
+++ b/collab-electron/packages/components/src/SourceControl/FileChangeRow.tsx
@@ -11,11 +11,13 @@ interface FileChangeRowProps {
 	filename: string;
 	dir: string;
 	status: GitChangeStatus;
-	section: 'staged' | 'unstaged' | 'untracked';
+	section: 'staged' | 'unstaged' | 'untracked' | 'merge';
+	lfs?: boolean;
 	onStage?: () => void;
 	onUnstage?: () => void;
 	onDiscard?: () => void;
 	onClick: () => void;
+	onContextMenu?: (e: React.MouseEvent) => void;
 }
 
 export function FileChangeRow({
@@ -27,6 +29,8 @@ export function FileChangeRow({
 	onUnstage,
 	onDiscard,
 	onClick,
+	onContextMenu,
+	lfs,
 }: FileChangeRowProps) {
 	const [confirming, setConfirming] = useState(false);
 	const confirmTimer = useRef<ReturnType<typeof setTimeout>>();
@@ -53,7 +57,11 @@ export function FileChangeRow({
 	const IconComponent = iconDef.icon;
 
 	return (
-		<div className="scm-file-row" onClick={onClick}>
+		<div
+			className="scm-file-row"
+			onClick={onClick}
+			onContextMenu={onContextMenu}
+		>
 			<span className="scm-file-icon">
 				<IconComponent
 					size={14}
@@ -121,6 +129,11 @@ export function FileChangeRow({
 					</>
 				)}
 			</span>
+			{lfs && (
+				<span className="scm-file-badge badge-M" title="Git LFS">
+					LFS
+				</span>
+			)}
 			<span
 				className={`scm-file-badge badge-${status}`}
 			>
diff --git a/collab-electron/packages/components/src/SourceControl/HistoryPanel.tsx b/collab-electron/packages/components/src/SourceControl/HistoryPanel.tsx
new file mode 100644
index 00000000..c29916de
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/HistoryPanel.tsx
@@ -0,0 +1,158 @@
+import { useCallback, useEffect, useState } from "react";
+import { CaretDown, CaretRight, Graph } from "@phosphor-icons/react";
+import type { GitLogEntry, GitLogFileChange } from "@collab/shared/git-types";
+interface HistoryPanelProps {
+  workspacePath: string;
+  expanded: boolean;
+  onToggle: () => void;
+  onRefresh: () => void;
+  onError: (msg: string) => void;
+}
+
+export function HistoryPanel({
+  workspacePath,
+  expanded,
+  onToggle,
+  onRefresh,
+  onError,
+}: HistoryPanelProps) {
+  const [commits, setCommits] = useState<GitLogEntry[]>([]);
+  const [selected, setSelected] = useState<string | null>(null);
+  const [files, setFiles] = useState<GitLogFileChange[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const list = await window.api.gitLog(workspacePath, {
+        maxCount: 30,
+      });
+      setCommits(list);
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Failed to load history");
+    } finally {
+      setLoading(false);
+    }
+  }, [workspacePath, onError]);
+
+  useEffect(() => {
+    if (expanded) void load();
+  }, [expanded, load]);
+
+  const selectCommit = async (entry: GitLogEntry) => {
+    setSelected(entry.hash);
+    try {
+      const f = await window.api.gitLogFiles(workspacePath, entry.hash);
+      setFiles(f);
+    } catch {
+      setFiles([]);
+    }
+  };
+
+  const menuFor = async (entry: GitLogEntry) => {
+    const choice = await window.api.showContextMenu([
+      { id: "view", label: "View Changes" },
+      { id: "revert", label: "Revert" },
+      { id: "cherry-pick", label: "Cherry Pick" },
+      { id: "reset-soft", label: "Reset (soft) to here" },
+      { id: "reset-mixed", label: "Reset (mixed) to here" },
+      { id: "reset-hard", label: "Reset (hard) to here" },
+      { id: "open-graph", label: "Open Graph" },
+    ]);
+    if (!choice) return;
+    try {
+      switch (choice) {
+        case "view":
+          if (files[0]) {
+            window.api.openGitDiff({
+              workspacePath,
+              relativePath: files[0].path,
+              left: { ref: `${entry.hash}^`, label: "Parent" },
+              right: { ref: entry.hash, label: entry.shortHash },
+            });
+          }
+          break;
+        case "revert":
+          await window.api.gitRevertCommit(workspacePath, entry.hash);
+          break;
+        case "cherry-pick":
+          await window.api.gitCherryPick(workspacePath, entry.hash);
+          break;
+        case "reset-soft":
+          await window.api.gitReset(workspacePath, "soft", entry.hash);
+          break;
+        case "reset-mixed":
+          await window.api.gitReset(workspacePath, "mixed", entry.hash);
+          break;
+        case "reset-hard":
+          if (
+            window.confirm(
+              "Hard reset will discard all uncommitted changes. Continue?",
+            )
+          ) {
+            await window.api.gitReset(workspacePath, "hard", entry.hash);
+          }
+          break;
+        case "open-graph":
+          window.api.createGraphTile(workspacePath);
+          void window.api.startReplay({ workspacePath });
+          break;
+      }
+      onRefresh();
+      if (expanded) await load();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Operation failed");
+    }
+  };
+
+  return (
+    <div className="scm-history">
+      <button
+        type="button"
+        className="scm-history-toggle"
+        onClick={onToggle}
+      >
+        {expanded ? (
+          <CaretDown size={12} weight="bold" />
+        ) : (
+          <CaretRight size={12} weight="bold" />
+        )}
+        <Graph size={14} />
+        <span>History</span>
+        {loading && <span className="scm-history-loading">…</span>}
+      </button>
+      {expanded && (
+        <div className="scm-history-list">
+          {commits.map((c) => (
+            <div key={c.hash} className="scm-history-entry">
+              <button
+                type="button"
+                className={`scm-history-row${selected === c.hash ? " selected" : ""}`}
+                onClick={() => void selectCommit(c)}
+                onContextMenu={(e) => {
+                  e.preventDefault();
+                  void menuFor(c);
+                }}
+              >
+                <span className="scm-history-hash">{c.shortHash}</span>
+                <span className="scm-history-subject">{c.subject}</span>
+              </button>
+              {selected === c.hash && files.length > 0 && (
+                <ul className="scm-history-files">
+                  {files.map((f) => (
+                    <li key={f.path}>
+                      <span className="scm-history-file-status">
+                        {f.status}
+                      </span>
+                      {f.path}
+                    </li>
+                  ))}
+                </ul>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/InteractiveRebasePanel.tsx b/collab-electron/packages/components/src/SourceControl/InteractiveRebasePanel.tsx
new file mode 100644
index 00000000..3f78fea9
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/InteractiveRebasePanel.tsx
@@ -0,0 +1,163 @@
+import { useCallback, useEffect, useState } from "react";
+import type { GitRebaseAction, GitRebaseTodoItem } from "@collab/shared/git-types";
+
+const ACTIONS: GitRebaseAction[] = [
+  "pick",
+  "reword",
+  "edit",
+  "squash",
+  "fixup",
+  "drop",
+];
+
+interface InteractiveRebasePanelProps {
+  workspacePath: string;
+  onRefresh: () => void;
+  onError: (msg: string) => void;
+}
+
+export function InteractiveRebasePanel({
+  workspacePath,
+  onRefresh,
+  onError,
+}: InteractiveRebasePanelProps) {
+  const [items, setItems] = useState<GitRebaseTodoItem[]>([]);
+  const [busy, setBusy] = useState(false);
+
+  const load = useCallback(async () => {
+    try {
+      const list = await window.api.gitRebaseTodoList(workspacePath);
+      setItems(list);
+    } catch (err) {
+      onError(
+        err instanceof Error ? err.message : "Failed to load rebase todo",
+      );
+    }
+  }, [workspacePath, onError]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const save = async (next: GitRebaseTodoItem[]) => {
+    setItems(next);
+    try {
+      await window.api.gitRebaseTodoWrite(workspacePath, next);
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Failed to save todo");
+    }
+  };
+
+  const move = (index: number, dir: -1 | 1) => {
+    const j = index + dir;
+    if (j < 0 || j >= items.length) return;
+    const next = [...items];
+    [next[index], next[j]] = [next[j]!, next[index]!];
+    void save(next);
+  };
+
+  const setAction = (index: number, action: GitRebaseAction) => {
+    const next = items.map((item, i) =>
+      i === index ? { ...item, action } : item,
+    );
+    void save(next);
+  };
+
+  const handleContinue = async () => {
+    setBusy(true);
+    try {
+      await window.api.gitRebaseContinue(workspacePath);
+      onRefresh();
+      await load();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Continue failed");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleAbort = async () => {
+    if (
+      !window.confirm("Abort interactive rebase?")
+    ) {
+      return;
+    }
+    setBusy(true);
+    try {
+      await window.api.gitRebaseAbort(workspacePath);
+      onRefresh();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Abort failed");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  if (items.length === 0) {
+    return (
+      <div className="scm-rebase-panel scm-empty-inline">
+        No rebase todo loaded
+      </div>
+    );
+  }
+
+  return (
+    <div className="scm-rebase-panel">
+      <div className="scm-rebase-toolbar">
+        <button
+          type="button"
+          disabled={busy}
+          onClick={() => void handleContinue()}
+        >
+          Continue
+        </button>
+        <button
+          type="button"
+          className="danger"
+          disabled={busy}
+          onClick={() => void handleAbort()}
+        >
+          Abort
+        </button>
+      </div>
+      <ul className="scm-rebase-list">
+        {items.map((item, index) => (
+          <li key={`${item.hash}-${index}`} className="scm-rebase-item">
+            <div className="scm-rebase-order">
+              <button
+                type="button"
+                title="Move up"
+                disabled={index === 0}
+                onClick={() => move(index, -1)}
+              >
+                ↑
+              </button>
+              <button
+                type="button"
+                title="Move down"
+                disabled={index === items.length - 1}
+                onClick={() => move(index, 1)}
+              >
+                ↓
+              </button>
+            </div>
+            <select
+              value={item.action}
+              onChange={(e) =>
+                setAction(index, e.target.value as GitRebaseAction)
+              }
+            >
+              {ACTIONS.map((a) => (
+                <option key={a} value={a}>
+                  {a}
+                </option>
+              ))}
+            </select>
+            <span className="scm-rebase-hash">{item.hash.slice(0, 7)}</span>
+            <span className="scm-rebase-subject">{item.subject}</span>
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/MergeBanner.tsx b/collab-electron/packages/components/src/SourceControl/MergeBanner.tsx
new file mode 100644
index 00000000..dcc508a9
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/MergeBanner.tsx
@@ -0,0 +1,69 @@
+import type { GitRepoState } from "@collab/shared/git-types";
+import { repoStateLabel } from "./scmContextMenu";
+
+interface MergeBannerProps {
+  repoState: GitRepoState;
+  onContinue: () => void;
+  onAbort: () => void;
+  onSkip?: () => void;
+  busy?: boolean;
+}
+
+export function MergeBanner({
+  repoState,
+  onContinue,
+  onAbort,
+  onSkip,
+  busy,
+}: MergeBannerProps) {
+  if (repoState === "clean") return null;
+
+  const label = repoStateLabel(repoState);
+  const showSkip =
+    onSkip &&
+    (repoState === "rebasing" ||
+      repoState === "interactive-rebase" ||
+      repoState === "cherry-picking");
+
+  return (
+    <div className="scm-merge-banner">
+      <span className="scm-merge-banner-text">{label}</span>
+      <div className="scm-merge-banner-actions">
+        <button
+          type="button"
+          className="scm-merge-banner-btn"
+          disabled={busy}
+          onClick={onContinue}
+        >
+          Continue
+        </button>
+        {showSkip && (
+          <button
+            type="button"
+            className="scm-merge-banner-btn"
+            disabled={busy}
+            onClick={onSkip}
+          >
+            Skip
+          </button>
+        )}
+        <button
+          type="button"
+          className="scm-merge-banner-btn danger"
+          disabled={busy}
+          onClick={() => {
+            if (
+              window.confirm(
+                "Abort the current operation? Uncommitted changes may be lost.",
+              )
+            ) {
+              onAbort();
+            }
+          }}
+        >
+          Abort
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/RemoteManagerModal.tsx b/collab-electron/packages/components/src/SourceControl/RemoteManagerModal.tsx
new file mode 100644
index 00000000..cd7fc942
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/RemoteManagerModal.tsx
@@ -0,0 +1,136 @@
+import { useCallback, useEffect, useState } from "react";
+import { X } from "@phosphor-icons/react";
+import type { GitRemote } from "@collab/shared/git-types";
+
+interface RemoteManagerModalProps {
+  workspacePath: string;
+  open: boolean;
+  onClose: () => void;
+  onChanged: () => void;
+  onError: (msg: string) => void;
+}
+
+export function RemoteManagerModal({
+  workspacePath,
+  open,
+  onClose,
+  onChanged,
+  onError,
+}: RemoteManagerModalProps) {
+  const [remotes, setRemotes] = useState<GitRemote[]>([]);
+  const [newName, setNewName] = useState("");
+  const [newUrl, setNewUrl] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  const load = useCallback(async () => {
+    const list = await window.api.gitRemotes(workspacePath);
+    setRemotes(list);
+  }, [workspacePath]);
+
+  useEffect(() => {
+    if (open) void load();
+  }, [open, load]);
+
+  if (!open) return null;
+
+  const handleAdd = async () => {
+    if (!newName.trim() || !newUrl.trim()) return;
+    setBusy(true);
+    try {
+      await window.api.gitRemoteAdd(
+        workspacePath,
+        newName.trim(),
+        newUrl.trim(),
+      );
+      setNewName("");
+      setNewUrl("");
+      await load();
+      onChanged();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Failed to add remote");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleRemove = async (name: string) => {
+    if (!window.confirm(`Remove remote "${name}"?`)) return;
+    setBusy(true);
+    try {
+      await window.api.gitRemoteRemove(workspacePath, name);
+      await load();
+      onChanged();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Failed to remove remote");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="scm-modal-overlay" onClick={onClose}>
+      <div
+        className="scm-modal"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="scm-modal-header">
+          <h3>Manage Remotes</h3>
+          <button type="button" className="scm-modal-close" onClick={onClose}>
+            <X size={16} />
+          </button>
+        </div>
+        <div className="scm-modal-body">
+          <table className="scm-remote-table">
+            <thead>
+              <tr>
+                <th>Name</th>
+                <th>Fetch URL</th>
+                <th>Push URL</th>
+                <th />
+              </tr>
+            </thead>
+            <tbody>
+              {remotes.map((r) => (
+                <tr key={r.name}>
+                  <td>{r.name}</td>
+                  <td className="scm-remote-url">{r.fetchUrl}</td>
+                  <td className="scm-remote-url">{r.pushUrl || r.fetchUrl}</td>
+                  <td>
+                    <button
+                      type="button"
+                      className="scm-modal-link danger"
+                      disabled={busy}
+                      onClick={() => void handleRemove(r.name)}
+                    >
+                      Remove
+                    </button>
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+          <div className="scm-remote-add">
+            <input
+              placeholder="Name"
+              value={newName}
+              onChange={(e) => setNewName(e.target.value)}
+            />
+            <input
+              placeholder="URL"
+              value={newUrl}
+              onChange={(e) => setNewUrl(e.target.value)}
+              className="scm-remote-add-url"
+            />
+            <button
+              type="button"
+              disabled={busy}
+              onClick={() => void handleAdd()}
+            >
+              Add
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControl.css b/collab-electron/packages/components/src/SourceControl/SourceControl.css
index f149b920..d44ec0ba 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControl.css
+++ b/collab-electron/packages/components/src/SourceControl/SourceControl.css
@@ -1,9 +1,18 @@
-/* Source Control panel */
+/* Source Control panel — tokens align with @collab/theme and nav chrome */
 .scm-container {
+	--scm-added: var(--item-type-md, oklch(76.8% 0.233 130.85));
+	--scm-modified: var(--link, rgb(37, 99, 235));
+	--scm-renamed: var(--item-type-concept, oklch(54.6% 0.245 262.881));
+	--scm-untracked: var(--item-type-bookmark, oklch(70.5% 0.213 47.604));
+	--scm-warning: var(--item-type-bookmark, oklch(70.5% 0.213 47.604));
 	display: flex;
 	flex-direction: column;
 	height: 100%;
 	overflow: hidden;
+	font-family: var(--font-sans);
+	font-size: 13px;
+	line-height: 1.5;
+	color: var(--foreground);
 }
 
 /* Header with branch info */
@@ -19,7 +28,7 @@
 }
 
 .scm-branch-name {
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	font-weight: 600;
 	color: var(--foreground);
 	white-space: nowrap;
@@ -70,10 +79,10 @@
 	padding: 8px;
 	font-size: 12px;
 	font-family: inherit;
-	background: color-mix(in srgb, var(--foreground) 5%, transparent);
+	background: color-mix(in srgb, var(--input, var(--foreground)) 100%, transparent);
 	color: var(--foreground);
-	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
-	border-radius: 6px;
+	border: 1px solid var(--border);
+	border-radius: var(--radius-sm, 6px);
 	outline: none;
 }
 
@@ -152,7 +161,7 @@
 
 .scm-success {
 	font-size: 11px;
-	color: #4ade80;
+	color: var(--scm-added);
 	padding: 0 12px 4px;
 }
 
@@ -193,7 +202,7 @@
 }
 
 .scm-section-count {
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	font-size: 10px;
 	font-weight: 500;
 	color: var(--muted-foreground);
@@ -276,18 +285,18 @@
 	justify-content: center;
 	width: 16px;
 	height: 16px;
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	font-size: 10px;
 	font-weight: 700;
 	border-radius: 3px;
 	flex-shrink: 0;
 }
 
-.scm-file-badge.badge-M { color: #5c9bcf; }
-.scm-file-badge.badge-A { color: #4ade80; }
+.scm-file-badge.badge-M { color: var(--scm-modified); }
+.scm-file-badge.badge-A { color: var(--scm-added); }
 .scm-file-badge.badge-D { color: var(--destructive); }
-.scm-file-badge.badge-R { color: #a78bfa; }
-.scm-file-badge.badge-U { color: #f59e0b; }
+.scm-file-badge.badge-R { color: var(--scm-renamed); }
+.scm-file-badge.badge-U { color: var(--scm-untracked); }
 .scm-file-badge.badge-\\? { color: var(--muted-foreground); }
 
 .scm-file-actions {
@@ -335,13 +344,18 @@
 	flex-direction: column;
 	align-items: center;
 	justify-content: center;
-	padding: 32px 16px;
+	padding: 38px 19px;
 	text-align: center;
 	color: var(--muted-foreground);
-	font-size: 12px;
+	font-size: 0.85rem;
 	gap: 4px;
 }
 
+.scm-empty p {
+	margin: 0;
+	opacity: 0.85;
+}
+
 .scm-empty-icon {
 	opacity: 0.4;
 	margin-bottom: 8px;
@@ -397,7 +411,7 @@
 }
 
 .scm-sync-badge {
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	font-size: 10px;
 	font-weight: 700;
 	min-width: 14px;
@@ -434,7 +448,7 @@
 	background: var(--background);
 	border: 1px solid var(--border);
 	border-radius: 8px;
-	box-shadow: 0 4px 16px rgba(0, 0, 0, 0.15);
+	box-shadow: 0 4px 16px color-mix(in srgb, var(--foreground) 12%, transparent);
 	z-index: 100;
 	overflow: hidden;
 	display: flex;
@@ -587,9 +601,9 @@
 
 .scm-stash-input {
 	flex: 1;
-	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
-	background: color-mix(in srgb, var(--foreground) 5%, transparent);
-	border-radius: 4px;
+	border: 1px solid var(--border);
+	background: color-mix(in srgb, var(--input, var(--foreground)) 100%, transparent);
+	border-radius: var(--radius-sm, 4px);
 	padding: 4px 8px;
 	font-size: 11px;
 	color: var(--foreground);
@@ -616,7 +630,7 @@
 	min-height: 120px;
 }
 
-.scm-diff-header {
+.scm-diff-toolbar {
 	display: flex;
 	align-items: center;
 	gap: 6px;
@@ -628,7 +642,7 @@
 .scm-diff-title {
 	font-size: 11px;
 	font-weight: 600;
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	color: var(--foreground);
 	flex: 1;
 	overflow: hidden;
@@ -636,7 +650,7 @@
 	white-space: nowrap;
 }
 
-.scm-diff-header-actions {
+.scm-diff-toolbar-actions {
 	display: flex;
 	gap: 2px;
 }
@@ -676,7 +690,7 @@
 .scm-diff-content {
 	flex: 1;
 	overflow: auto;
-	font-family: 'IBM Plex Mono', monospace;
+	font-family: var(--font-mono), 'IBM Plex Mono', monospace;
 	font-size: 11px;
 	line-height: 1.5;
 }
@@ -690,27 +704,27 @@
 	display: inline;
 }
 
-.scm-diff-add {
-	background: color-mix(in srgb, #4ade80 15%, transparent);
-	color: #4ade80;
+.scm-diff-line.scm-diff-add {
+	background: color-mix(in srgb, var(--scm-added) 15%, transparent);
+	color: var(--scm-added);
 }
 
-.scm-diff-remove {
+.scm-diff-line.scm-diff-remove {
 	background: color-mix(in srgb, var(--destructive) 15%, transparent);
 	color: var(--destructive);
 }
 
-.scm-diff-header {
+.scm-diff-line.scm-diff-header {
 	color: var(--muted-foreground);
 	font-weight: 600;
 }
 
-.scm-diff-meta {
+.scm-diff-line.scm-diff-meta {
 	color: var(--muted-foreground);
 	font-style: italic;
 }
 
-.scm-diff-context {
+.scm-diff-line.scm-diff-context {
 	color: var(--foreground);
 	opacity: 0.6;
 }
@@ -721,3 +735,531 @@
 	color: var(--muted-foreground);
 	text-align: center;
 }
+
+.scm-commit-amend {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	font-size: 11px;
+	color: var(--muted-foreground);
+	cursor: pointer;
+}
+
+.scm-commit-amend input {
+	margin: 0;
+}
+
+.scm-commit-button.secondary {
+	flex: 0 1 auto;
+	background: color-mix(in srgb, var(--foreground) 10%, transparent);
+	color: var(--foreground);
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+}
+
+.scm-commit-hint {
+	font-size: 10px;
+	color: var(--muted-foreground);
+	opacity: 0.85;
+}
+
+.scm-init-button.secondary {
+	margin-top: 6px;
+	background: transparent;
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+}
+
+.scm-init-button {
+	margin-top: 12px;
+	padding: 8px 14px;
+	font-size: 12px;
+	font-weight: 500;
+	cursor: pointer;
+	border: none;
+	border-radius: 6px;
+	background: var(--foreground);
+	color: var(--background);
+}
+
+.scm-init-button:disabled {
+	opacity: 0.5;
+	cursor: default;
+}
+
+.scm-section-action.discard {
+	color: var(--destructive);
+}
+
+.scm-section-action.discard:hover {
+	background: color-mix(in srgb, var(--destructive) 12%, transparent);
+}
+
+.scm-remote-picker {
+	position: relative;
+	margin-right: auto;
+}
+
+.scm-remote-trigger,
+.scm-remote-label {
+	display: flex;
+	align-items: center;
+	gap: 2px;
+	font-size: 11px;
+	color: var(--muted-foreground);
+	background: none;
+	border: none;
+	padding: 2px 6px;
+	cursor: pointer;
+	border-radius: 4px;
+}
+
+.scm-remote-trigger:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.scm-remote-menu {
+	position: absolute;
+	top: 100%;
+	left: 0;
+	z-index: 20;
+	min-width: 100px;
+	margin-top: 2px;
+	padding: 4px;
+	background: var(--background);
+	border: 1px solid color-mix(in srgb, var(--border) 60%, transparent);
+	border-radius: 6px;
+	box-shadow: 0 4px 12px color-mix(in srgb, var(--foreground) 10%, transparent);
+}
+
+.scm-remote-option {
+	display: block;
+	width: 100%;
+	padding: 4px 8px;
+	font-size: 11px;
+	text-align: left;
+	background: none;
+	border: none;
+	border-radius: 4px;
+	cursor: pointer;
+	color: var(--foreground);
+}
+
+.scm-remote-option:hover,
+.scm-remote-option.active {
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.scm-branch-item.tag {
+	gap: 6px;
+}
+
+.scm-branch-loading {
+	padding: 6px 12px;
+	font-size: 11px;
+	color: var(--muted-foreground);
+}
+
+.scm-merge-banner {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 8px;
+	padding: 8px 12px;
+	background: color-mix(in srgb, var(--scm-warning) 15%, transparent);
+	border-bottom: 1px solid color-mix(in srgb, var(--scm-warning) 30%, transparent);
+	font-size: 11px;
+	color: var(--foreground);
+	flex-shrink: 0;
+}
+
+.scm-merge-banner-actions {
+	display: flex;
+	gap: 4px;
+}
+
+.scm-merge-banner-btn {
+	font-size: 11px;
+	padding: 2px 8px;
+	border-radius: 4px;
+	border: 1px solid color-mix(in srgb, var(--foreground) 20%, transparent);
+	background: var(--background);
+	cursor: pointer;
+}
+
+.scm-merge-banner-btn.danger {
+	color: var(--destructive);
+}
+
+.scm-merge-banner-btn.danger:hover:not(:disabled) {
+	background: color-mix(in srgb, var(--destructive) 10%, transparent);
+}
+
+.scm-modal-overlay {
+	position: fixed;
+	inset: 0;
+	z-index: 1000;
+	background: color-mix(in srgb, var(--foreground) 35%, transparent);
+	display: flex;
+	align-items: center;
+	justify-content: center;
+}
+
+.scm-modal {
+	background: var(--background);
+	border-radius: 8px;
+	min-width: 400px;
+	max-width: 90vw;
+	max-height: 80vh;
+	overflow: auto;
+	border: 1px solid var(--border);
+	box-shadow: 0 8px 32px color-mix(in srgb, var(--foreground) 18%, transparent);
+}
+
+.scm-modal-narrow {
+	min-width: 280px;
+}
+
+.scm-modal-header {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	padding: 12px 16px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+}
+
+.scm-modal-header h3 {
+	margin: 0;
+	font-size: 14px;
+	font-weight: 600;
+	color: var(--foreground);
+}
+
+.scm-modal-close {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	background: none;
+	border: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	border-radius: 4px;
+	padding: 2px;
+}
+
+.scm-modal-close:hover {
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.scm-modal-body {
+	padding: 16px;
+}
+
+.scm-modal-body input,
+.scm-modal-body select,
+.scm-clone-form input {
+	width: 100%;
+	box-sizing: border-box;
+	padding: 6px 8px;
+	font-size: 12px;
+	font-family: inherit;
+	color: var(--foreground);
+	background: color-mix(in srgb, var(--input, var(--foreground)) 100%, transparent);
+	border: 1px solid var(--border);
+	border-radius: var(--radius-sm, 6px);
+	outline: none;
+}
+
+.scm-modal-body input:focus,
+.scm-modal-body select:focus,
+.scm-clone-form input:focus {
+	border-color: color-mix(in srgb, var(--foreground) 30%, transparent);
+}
+
+.scm-modal-link {
+	font-size: 11px;
+	background: none;
+	border: none;
+	cursor: pointer;
+	color: var(--link, var(--foreground));
+	text-decoration: underline;
+	padding: 0;
+}
+
+.scm-modal-link.danger {
+	color: var(--destructive);
+	text-decoration: none;
+}
+
+.scm-modal-link.danger:hover {
+	text-decoration: underline;
+}
+
+.scm-remote-add button,
+.scm-clone-parent button,
+.scm-rebase-toolbar button {
+	padding: 5px 10px;
+	font-size: 11px;
+	font-weight: 500;
+	cursor: pointer;
+	border-radius: var(--radius-sm, 6px);
+	border: 1px solid var(--border);
+	background: transparent;
+	color: var(--foreground);
+}
+
+.scm-remote-add button:hover:not(:disabled),
+.scm-clone-parent button:hover:not(:disabled),
+.scm-rebase-toolbar button:hover:not(:disabled) {
+	background: color-mix(in srgb, var(--foreground) 8%, transparent);
+}
+
+.scm-remote-add button:last-child {
+	background: var(--primary);
+	color: var(--primary-foreground);
+	border-color: transparent;
+}
+
+.scm-rebase-toolbar button.danger {
+	color: var(--destructive);
+	border-color: color-mix(in srgb, var(--destructive) 40%, transparent);
+}
+
+.scm-remote-table {
+	width: 100%;
+	font-size: 11px;
+	border-collapse: collapse;
+}
+
+.scm-remote-url {
+	max-width: 180px;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.scm-remote-add {
+	display: flex;
+	gap: 6px;
+	margin-top: 12px;
+}
+
+.scm-remote-add-url {
+	flex: 1;
+}
+
+.scm-clone-form label {
+	display: flex;
+	flex-direction: column;
+	gap: 4px;
+	font-size: 11px;
+	margin-bottom: 10px;
+}
+
+.scm-clone-parent {
+	display: flex;
+	gap: 6px;
+}
+
+.scm-clone-parent input {
+	flex: 1;
+}
+
+.scm-history-toggle {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	width: 100%;
+	padding: 6px 12px;
+	background: none;
+	border: none;
+	font-size: 11px;
+	cursor: pointer;
+	color: var(--muted-foreground);
+}
+
+.scm-history-list {
+	max-height: 200px;
+	overflow-y: auto;
+}
+
+.scm-history-row {
+	display: flex;
+	gap: 8px;
+	width: 100%;
+	padding: 4px 12px 4px 24px;
+	background: none;
+	border: none;
+	text-align: left;
+	font-size: 11px;
+	cursor: pointer;
+}
+
+.scm-history-row.selected {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-history-hash {
+	font-family: var(--font-mono), monospace;
+	color: var(--muted-foreground);
+	flex-shrink: 0;
+}
+
+.scm-history-subject {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	color: var(--foreground);
+}
+
+.scm-history-loading {
+	margin-left: auto;
+	color: var(--muted-foreground);
+}
+
+.scm-history-row:hover {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-history-file-status {
+	display: inline-block;
+	min-width: 1.25em;
+	margin-right: 6px;
+	font-weight: 600;
+	color: var(--muted-foreground);
+}
+
+.scm-history-files {
+	margin: 0 0 8px 32px;
+	padding: 0;
+	font-size: 10px;
+	list-style: none;
+}
+
+.scm-rebase-panel {
+	padding: 8px 12px;
+	border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+}
+
+.scm-rebase-toolbar {
+	display: flex;
+	gap: 6px;
+	margin-bottom: 8px;
+}
+
+.scm-rebase-list {
+	list-style: none;
+	margin: 0;
+	padding: 0;
+}
+
+.scm-rebase-item {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	padding: 4px 0;
+	font-size: 11px;
+}
+
+.scm-rebase-subject {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.scm-rebase-hash {
+	font-family: var(--font-mono), monospace;
+	color: var(--muted-foreground);
+	flex-shrink: 0;
+}
+
+.scm-rebase-order {
+	display: flex;
+	flex-direction: column;
+	gap: 0;
+}
+
+.scm-rebase-order button {
+	padding: 0 4px;
+	font-size: 10px;
+	line-height: 1;
+	border: none;
+	background: none;
+	color: var(--muted-foreground);
+	cursor: pointer;
+}
+
+.scm-rebase-order button:hover:not(:disabled) {
+	color: var(--foreground);
+}
+
+.scm-rebase-item select {
+	font-size: 11px;
+	padding: 2px 4px;
+	border: 1px solid var(--border);
+	border-radius: var(--radius-sm, 4px);
+	background: var(--background);
+	color: var(--foreground);
+}
+
+.scm-branch-pick {
+	display: block;
+	width: 100%;
+	padding: 6px 10px;
+	text-align: left;
+	font-size: 12px;
+	background: none;
+	border: none;
+	border-radius: var(--radius-sm, 4px);
+	cursor: pointer;
+	color: var(--foreground);
+}
+
+.scm-branch-pick:hover {
+	background: color-mix(in srgb, var(--foreground) 6%, transparent);
+}
+
+.scm-remote-table th {
+	text-align: left;
+	font-weight: 600;
+	color: var(--muted-foreground);
+	padding: 4px 8px 8px 0;
+}
+
+.scm-remote-table td {
+	padding: 6px 8px 6px 0;
+	vertical-align: top;
+	color: var(--foreground);
+}
+
+.scm-empty-inline {
+	padding: 8px 12px;
+	font-size: 11px;
+	color: var(--muted-foreground);
+}
+
+.scm-submodule-row,
+.scm-worktree-row {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	padding: 4px 12px 4px 24px;
+	font-size: 11px;
+}
+
+.scm-manage-remotes {
+	font-size: 10px;
+	margin-left: 4px;
+	background: none;
+	border: none;
+	cursor: pointer;
+	color: var(--muted-foreground);
+	text-decoration: underline;
+}
+
+.scm-sign-row {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	font-size: 11px;
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
index 5d7295d8..2325e024 100644
--- a/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SourceControlView.tsx
@@ -9,13 +9,32 @@ import {
 	ArrowsClockwise,
 	CheckCircle,
 } from '@phosphor-icons/react';
-import type { GitStatusResult } from '@collab/shared/git-types';
+import type {
+	GitFileChange,
+	GitStatusResult,
+} from '@collab/shared/git-types';
 import { CommitBox } from './CommitBox';
 import { ChangeSectionHeader } from './ChangeSectionHeader';
 import { FileChangeRow } from './FileChangeRow';
 import { SyncBar } from './SyncBar';
 import { BranchPicker } from './BranchPicker';
-import { DiffView } from './DiffView';
+import { StashSection } from './StashSection';
+import { MergeBanner } from './MergeBanner';
+import { RemoteManagerModal } from './RemoteManagerModal';
+import { CloneRepositoryModal } from './CloneRepositoryModal';
+import { CompareBranchModal } from './CompareBranchModal';
+import { HistoryPanel } from './HistoryPanel';
+import { InteractiveRebasePanel } from './InteractiveRebasePanel';
+import { SubmodulesSection } from './SubmodulesSection';
+import { WorktreesSection } from './WorktreesSection';
+import {
+	showScmContextMenu,
+	type ScmContextTarget,
+} from './scmContextMenu';
+import {
+	openScmFileDiff,
+	openMergeConflictDiff,
+} from './scmOpenDiff';
 
 interface SourceControlViewProps {
 	workspacePath: string;
@@ -33,6 +52,7 @@ export function SourceControlView({
 	const [status, setStatus] =
 		useState<GitStatusResult | null>(null);
 	const [commitMessage, setCommitMessage] = useState('');
+	const [amend, setAmend] = useState(false);
 	const [committing, setCommitting] = useState(false);
 	const [generating, setGenerating] = useState(false);
 	const [canGenerate, setCanGenerate] = useState(false);
@@ -42,20 +62,26 @@ export function SourceControlView({
 		null,
 	);
 	const [hasUpstream, setHasUpstream] = useState(false);
-	const [diffFile, setDiffFile] = useState<{
-		filePath: string;
-		absPath: string;
-		relativePath: string;
-		cached: boolean;
-	} | null>(null);
+	const [initializing, setInitializing] = useState(false);
+	const [selectedRemote, setSelectedRemote] = useState('origin');
+	const [signCommit, setSignCommit] = useState(false);
+	const [showSignOption, setShowSignOption] = useState(false);
+	const [remoteModalOpen, setRemoteModalOpen] = useState(false);
+	const [cloneModalOpen, setCloneModalOpen] = useState(false);
+	const [compareFile, setCompareFile] = useState<string | null>(
+		null,
+	);
+	const [historyExpanded, setHistoryExpanded] = useState(false);
+	const [repoBusy, setRepoBusy] = useState(false);
 	const refreshTimer = useRef<ReturnType<typeof setTimeout>>();
 
 	const refresh = useCallback(async () => {
+		if (!workspacePath) return;
 		try {
-			const result = await window.api.gitStatus();
+			const result = await window.api.gitStatus(workspacePath);
 			setStatus(result);
 			window.api
-				.gitHasUpstream()
+				.gitHasUpstream(workspacePath)
 				.then(setHasUpstream)
 				.catch(() => setHasUpstream(false));
 		} catch (err) {
@@ -66,12 +92,14 @@ export function SourceControlView({
 				staged: [],
 				unstaged: [],
 				untracked: [],
+				merge: [],
 				isGitRepo: false,
+				hasCommits: false,
+				repoState: 'clean',
 			});
 		}
-	}, []);
+	}, [workspacePath]);
 
-	// Initial load
 	useEffect(() => {
 		refresh();
 		window.api
@@ -81,9 +109,16 @@ export function SourceControlView({
 				setAgentName(result.agent);
 			})
 			.catch(() => {});
+		window.api
+			.gitGpgSignEnabled(workspacePath)
+			.then(setShowSignOption)
+			.catch(() => setShowSignOption(false));
+		window.api
+			.gitConfigDisplay(workspacePath)
+			.then((cfg) => setSignCommit(cfg.gpgSign))
+			.catch(() => {});
 	}, [workspacePath, refresh]);
 
-	// Auto-refresh on file changes (debounced)
 	useEffect(() => {
 		if (!isActive) return;
 		return window.api.onFsChanged(() => {
@@ -92,7 +127,6 @@ export function SourceControlView({
 		});
 	}, [isActive, refresh]);
 
-	// Cleanup timer
 	useEffect(() => {
 		return () => clearTimeout(refreshTimer.current);
 	}, []);
@@ -100,7 +134,7 @@ export function SourceControlView({
 	const handleStage = useCallback(
 		async (paths: string[]) => {
 			try {
-				await window.api.gitStage(paths);
+				await window.api.gitStage(workspacePath, paths);
 				await refresh();
 			} catch (err) {
 				setError(
@@ -110,13 +144,13 @@ export function SourceControlView({
 				);
 			}
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
 	const handleUnstage = useCallback(
 		async (paths: string[]) => {
 			try {
-				await window.api.gitUnstage(paths);
+				await window.api.gitUnstage(workspacePath, paths);
 				await refresh();
 			} catch (err) {
 				setError(
@@ -126,12 +160,12 @@ export function SourceControlView({
 				);
 			}
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
 	const handleStageAll = useCallback(async () => {
 		try {
-			await window.api.gitStageAll();
+			await window.api.gitStageAll(workspacePath);
 			await refresh();
 		} catch (err) {
 			setError(
@@ -140,11 +174,11 @@ export function SourceControlView({
 					: 'Failed to stage all',
 			);
 		}
-	}, [refresh]);
+	}, [workspacePath, refresh]);
 
 	const handleUnstageAll = useCallback(async () => {
 		try {
-			await window.api.gitUnstageAll();
+			await window.api.gitUnstageAll(workspacePath);
 			await refresh();
 		} catch (err) {
 			setError(
@@ -153,12 +187,12 @@ export function SourceControlView({
 					: 'Failed to unstage all',
 			);
 		}
-	}, [refresh]);
+	}, [workspacePath, refresh]);
 
 	const handleDiscard = useCallback(
 		async (paths: string[]) => {
 			try {
-				await window.api.gitDiscard(paths);
+				await window.api.gitDiscard(workspacePath, paths);
 				await refresh();
 			} catch (err) {
 				setError(
@@ -168,45 +202,133 @@ export function SourceControlView({
 				);
 			}
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
-	const handleCommit = useCallback(async () => {
-		if (!commitMessage.trim()) return;
-		setCommitting(true);
-		setError(null);
-		setSuccess(null);
+	const handleDiscardAll = useCallback(async () => {
+		const ok = window.confirm(
+			'Discard all changes in the working tree? This cannot be undone.',
+		);
+		if (!ok) return;
 		try {
-			// Auto-stage all if nothing is staged (VS Code behavior)
-			if (!status || status.staged.length === 0) {
-				await window.api.gitStageAll();
+			await window.api.gitDiscardAll(workspacePath);
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Failed to discard all',
+			);
+		}
+	}, [workspacePath, refresh]);
+
+	const performCommit = useCallback(
+		async (options?: { amend?: boolean }) => {
+			if (!commitMessage.trim()) return;
+			setCommitting(true);
+			setError(null);
+			setSuccess(null);
+			try {
+				if (
+					!options?.amend &&
+					(!status || status.staged.length === 0)
+				) {
+					await window.api.gitStageAll(workspacePath);
+				}
+				const result = await window.api.gitCommit(
+					workspacePath,
+					commitMessage,
+					{
+						...options,
+						sign: signCommit || undefined,
+					},
+				);
+				setCommitMessage('');
+				setAmend(false);
+				setSuccess(
+					`Committed ${result.hash.slice(0, 7)}`,
+				);
+				setTimeout(() => setSuccess(null), 3000);
+				await refresh();
+				return true;
+			} catch (err) {
+				setError(
+					err instanceof Error
+						? err.message
+						: 'Commit failed',
+				);
+				return false;
+			} finally {
+				setCommitting(false);
 			}
-			const result = await window.api.gitCommit(
-				commitMessage,
+		},
+		[commitMessage, workspacePath, refresh, status, signCommit],
+	);
+
+	const handleCommit = useCallback(async () => {
+		await performCommit(amend ? { amend: true } : undefined);
+	}, [performCommit, amend]);
+
+	const handleCommitAndPush = useCallback(async () => {
+		const ok = await performCommit(
+			amend ? { amend: true } : undefined,
+		);
+		if (!ok) return;
+		try {
+			await window.api.gitPush(
+				workspacePath,
+				selectedRemote || undefined,
 			);
-			setCommitMessage('');
-			setSuccess(
-				`Committed ${result.hash.slice(0, 7)}`,
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Push failed',
 			);
-			setTimeout(() => setSuccess(null), 3000);
+		}
+	}, [
+		performCommit,
+		amend,
+		workspacePath,
+		refresh,
+		selectedRemote,
+	]);
+
+	const handleCommitAndSync = useCallback(async () => {
+		const ok = await performCommit(
+			amend ? { amend: true } : undefined,
+		);
+		if (!ok) return;
+		try {
+			const remote = selectedRemote || undefined;
+			await window.api.gitFetch(workspacePath, remote);
+			await window.api.gitPull(workspacePath, remote);
+			await window.api.gitPush(workspacePath, remote);
 			await refresh();
 		} catch (err) {
 			setError(
 				err instanceof Error
 					? err.message
-					: 'Commit failed',
+					: 'Sync failed',
 			);
-		} finally {
-			setCommitting(false);
 		}
-	}, [commitMessage, refresh]);
+	}, [
+		performCommit,
+		amend,
+		workspacePath,
+		refresh,
+		selectedRemote,
+	]);
 
 	const handleGenerateMessage = useCallback(async () => {
 		setGenerating(true);
 		setError(null);
 		try {
 			const result =
-				await window.api.gitGenerateCommitMessage();
+				await window.api.gitGenerateCommitMessage(
+					workspacePath,
+				);
 			setCommitMessage(result.message);
 		} catch (err) {
 			setError(
@@ -217,80 +339,251 @@ export function SourceControlView({
 		} finally {
 			setGenerating(false);
 		}
-	}, []);
+	}, [workspacePath]);
 
-	// Push / Pull / Sync handlers
-	const handlePush = useCallback(async () => {
-		await window.api.gitPush();
-		await refresh();
-	}, [refresh]);
-
-	const handlePull = useCallback(async () => {
-		await window.api.gitPull();
-		await refresh();
-	}, [refresh]);
-
-	const handleSync = useCallback(async () => {
-		await window.api.gitFetch();
-		await window.api.gitPull();
-		await window.api.gitPush();
-		await refresh();
-	}, [refresh]);
-
-	const handlePublish = useCallback(async () => {
-		const remotes = await window.api.gitRemotes();
-		const remote = remotes[0]?.name ?? 'origin';
-		const branch = status?.branch ?? 'main';
-		await window.api.gitPushSetUpstream(
-			remote,
-			branch,
-		);
-		await refresh();
-	}, [status?.branch, refresh]);
+	const handleInitRepo = useCallback(async () => {
+		setInitializing(true);
+		setError(null);
+		try {
+			await window.api.gitInit(workspacePath);
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error
+					? err.message
+					: 'Failed to initialize repository',
+			);
+		} finally {
+			setInitializing(false);
+		}
+	}, [workspacePath, refresh]);
+
+	const handlePush = useCallback(
+		async (remote?: string) => {
+			await window.api.gitPush(workspacePath, remote);
+			await refresh();
+		},
+		[workspacePath, refresh],
+	);
+
+	const handlePull = useCallback(
+		async (remote?: string) => {
+			await window.api.gitPull(workspacePath, remote);
+			await refresh();
+		},
+		[workspacePath, refresh],
+	);
+
+	const handleSync = useCallback(
+		async (remote?: string) => {
+			await window.api.gitFetch(workspacePath, remote);
+			await window.api.gitPull(workspacePath, remote);
+			await window.api.gitPush(workspacePath, remote);
+			await refresh();
+		},
+		[workspacePath, refresh],
+	);
+
+	const handlePublish = useCallback(
+		async (remote: string) => {
+			const branch = status?.branch ?? 'main';
+			await window.api.gitPushSetUpstream(
+				workspacePath,
+				remote,
+				branch,
+			);
+			await refresh();
+		},
+		[workspacePath, status?.branch, refresh],
+	);
 
-	// Branch handlers
 	const handleBranchSwitch = useCallback(
 		async (branch: string) => {
-			await window.api.gitCheckout(branch);
+			await window.api.gitCheckout(workspacePath, branch);
 			await refresh();
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
 	const handleBranchCreate = useCallback(
 		async (name: string) => {
-			await window.api.gitCreateBranch(name);
+			await window.api.gitCreateBranch(workspacePath, name);
 			await refresh();
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
 	const handleBranchDelete = useCallback(
 		async (name: string) => {
-			await window.api.gitDeleteBranch(name);
+			await window.api.gitDeleteBranch(workspacePath, name);
 			await refresh();
 		},
-		[refresh],
+		[workspacePath, refresh],
 	);
 
-	// Diff handler
 	const handleFileClick = useCallback(
-		(
-			absPath: string,
-			relativePath: string,
-			cached: boolean,
+		(relativePath: string, cached: boolean) => {
+			openScmFileDiff(workspacePath, relativePath, cached);
+		},
+		[workspacePath],
+	);
+
+	const handleRepoContinue = useCallback(async () => {
+		setRepoBusy(true);
+		try {
+			const state = status?.repoState;
+			if (state === 'merging') {
+				await window.api.gitMergeContinue(workspacePath);
+			} else if (state === 'cherry-picking') {
+				await window.api.gitCherryPickContinue(workspacePath);
+			} else if (state === 'reverting') {
+				await window.api.gitRevertContinue(workspacePath);
+			} else {
+				await window.api.gitRebaseContinue(workspacePath);
+			}
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error ? err.message : 'Continue failed',
+			);
+		} finally {
+			setRepoBusy(false);
+		}
+	}, [workspacePath, status?.repoState, refresh]);
+
+	const handleRepoAbort = useCallback(async () => {
+		setRepoBusy(true);
+		try {
+			const state = status?.repoState;
+			if (state === 'merging') {
+				await window.api.gitMergeAbort(workspacePath);
+			} else if (state === 'cherry-picking') {
+				await window.api.gitCherryPickAbort(workspacePath);
+			} else if (state === 'reverting') {
+				await window.api.gitRevertAbort(workspacePath);
+			} else {
+				await window.api.gitRebaseAbort(workspacePath);
+			}
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error ? err.message : 'Abort failed',
+			);
+		} finally {
+			setRepoBusy(false);
+		}
+	}, [workspacePath, status?.repoState, refresh]);
+
+	const handleRepoSkip = useCallback(async () => {
+		setRepoBusy(true);
+		try {
+			await window.api.gitRebaseSkip(workspacePath);
+			await refresh();
+		} catch (err) {
+			setError(
+				err instanceof Error ? err.message : 'Skip failed',
+			);
+		} finally {
+			setRepoBusy(false);
+		}
+	}, [workspacePath, refresh]);
+
+	const handleFileContext = useCallback(
+		async (
+			e: React.MouseEvent,
+			file: GitFileChange,
+			section: string,
+			cached?: boolean,
 		) => {
-			setDiffFile({
-				filePath: absPath,
-				absPath,
-				relativePath,
+			e.preventDefault();
+			const target: ScmContextTarget = {
+				kind: 'file',
+				section,
+				path: file.path,
+				absPath: file.absPath,
 				cached,
-			});
+			};
+			const choice = await showScmContextMenu(target);
+			if (!choice) return;
+			try {
+				switch (choice) {
+					case 'open-changes':
+						if (section === 'merge') {
+							openMergeConflictDiff(
+								workspacePath,
+								file.path,
+							);
+						} else {
+							openScmFileDiff(
+								workspacePath,
+								file.path,
+								!!cached,
+							);
+						}
+						break;
+					case 'open-file':
+						onSelectFile(file.absPath);
+						break;
+					case 'stage':
+						await handleStage([file.path]);
+						break;
+					case 'unstage':
+						await handleUnstage([file.path]);
+						break;
+					case 'discard':
+						await handleDiscard([file.path]);
+						break;
+					case 'accept-current':
+						await window.api.gitCheckoutOurs(workspacePath, [
+							file.path,
+						]);
+						await refresh();
+						break;
+					case 'accept-incoming':
+						await window.api.gitCheckoutTheirs(workspacePath, [
+							file.path,
+						]);
+						await refresh();
+						break;
+					case 'mark-resolved':
+						await window.api.gitAdd(workspacePath, [
+							file.path,
+						]);
+						await refresh();
+						break;
+					case 'compare-branch':
+						setCompareFile(file.path);
+						break;
+					case 'copy-path':
+						void navigator.clipboard.writeText(file.path);
+						break;
+					case 'reveal':
+						window.api.revealInFinder(file.absPath);
+						break;
+				}
+			} catch (err) {
+				setError(
+					err instanceof Error
+						? err.message
+						: 'Action failed',
+				);
+			}
 		},
-		[],
+		[
+			workspacePath,
+			onSelectFile,
+			handleStage,
+			handleUnstage,
+			handleDiscard,
+			refresh,
+		],
 	);
 
-	// Not a git repo
+	const openGitignore = useCallback(() => {
+		const path = `${workspacePath}/.gitignore`;
+		onSelectFile(path);
+	}, [workspacePath, onSelectFile]);
+
 	if (status && !status.isGitRepo) {
 		return (
 			<div className="scm-container">
@@ -302,15 +595,39 @@ export function SourceControlView({
 						className="scm-empty-icon"
 					/>
 					<span>
-						This workspace is not a git
-						repository.
+						This workspace is not a git repository.
 					</span>
+					<button
+						type="button"
+						className="scm-init-button"
+						disabled={initializing}
+						onClick={handleInitRepo}
+					>
+						{initializing
+							? 'Initializing...'
+							: 'Initialize Repository'}
+					</button>
+					<button
+						type="button"
+						className="scm-init-button secondary"
+						onClick={() => setCloneModalOpen(true)}
+					>
+						Clone Repository
+					</button>
 				</div>
+				<CloneRepositoryModal
+					open={cloneModalOpen}
+					onClose={() => setCloneModalOpen(false)}
+					onCloned={() => void refresh()}
+					onError={setError}
+				/>
+				{error && (
+					<div className="scm-error">{error}</div>
+				)}
 			</div>
 		);
 	}
 
-	// Loading
 	if (!status) {
 		return (
 			<div className="scm-container">
@@ -322,16 +639,22 @@ export function SourceControlView({
 		);
 	}
 
+	const hasMergeConflicts =
+		status.merge.length > 0 || status.repoState === 'merging';
+	const showRebasePanel =
+		status.repoState === 'interactive-rebase';
 	const hasStagedChanges = status.staged.length > 0;
 	const hasAnyChanges =
 		status.staged.length +
 			status.unstaged.length +
-			status.untracked.length >
+			status.untracked.length +
+			status.merge.length >
 		0;
 	const totalChanges =
 		status.staged.length +
 		status.unstaged.length +
-		status.untracked.length;
+		status.untracked.length +
+		status.merge.length;
 
 	function dirOf(filePath: string): string {
 		const lastSlash = filePath.lastIndexOf('/');
@@ -351,13 +674,53 @@ export function SourceControlView({
 		<div className="scm-container">
 			{leadingContent}
 
-			{/* Branch header */}
 			<div className="scm-header">
 				<BranchPicker
+					workspacePath={workspacePath}
 					currentBranch={status.branch}
 					onSwitch={handleBranchSwitch}
 					onCreate={handleBranchCreate}
 					onDelete={handleBranchDelete}
+					onMerge={async (branch) => {
+						await window.api.gitMerge(
+							workspacePath,
+							branch,
+						);
+						await refresh();
+					}}
+					onRebase={async (onto) => {
+						await window.api.gitRebase(
+							workspacePath,
+							onto,
+						);
+						await refresh();
+					}}
+					onInteractiveRebase={() => {
+						const count = window.prompt(
+							'Interactive rebase: number of commits (HEAD~n):',
+							'5',
+						);
+						if (!count) return;
+						const n = parseInt(count, 10);
+						if (!n || n < 1) {
+							setError('Invalid commit count');
+							return;
+						}
+						void window.api
+							.gitRebaseStartInteractive(
+								workspacePath,
+								null,
+								n,
+							)
+							.then(refresh)
+							.catch((err) =>
+								setError(
+									err instanceof Error
+										? err.message
+										: 'Rebase failed',
+								),
+							);
+					}}
 					onError={setError}
 				/>
 				<button
@@ -370,12 +733,15 @@ export function SourceControlView({
 				</button>
 			</div>
 
-			{/* Sync bar */}
 			<SyncBar
+				workspacePath={workspacePath}
 				ahead={status.ahead}
 				behind={status.behind}
 				hasUpstream={hasUpstream}
 				branch={status.branch}
+				selectedRemote={selectedRemote}
+				onRemoteChange={setSelectedRemote}
+				onManageRemotes={() => setRemoteModalOpen(true)}
 				onPush={handlePush}
 				onPull={handlePull}
 				onSync={handleSync}
@@ -383,7 +749,14 @@ export function SourceControlView({
 				onError={setError}
 			/>
 
-			{/* Commit box */}
+			<MergeBanner
+				repoState={status.repoState}
+				onContinue={handleRepoContinue}
+				onAbort={handleRepoAbort}
+				onSkip={handleRepoSkip}
+				busy={repoBusy}
+			/>
+
 			<CommitBox
 				message={commitMessage}
 				onMessageChange={setCommitMessage}
@@ -391,13 +764,21 @@ export function SourceControlView({
 				canGenerate={canGenerate}
 				agentName={agentName}
 				hasAnyChanges={hasAnyChanges}
+				hasCommits={status.hasCommits}
+				hasMergeConflicts={hasMergeConflicts}
+				amend={amend}
+				onAmendChange={setAmend}
+				signCommit={signCommit}
+				onSignCommitChange={setSignCommit}
+				showSignOption={showSignOption}
 				onCommit={handleCommit}
+				onCommitAndPush={handleCommitAndPush}
+				onCommitAndSync={handleCommitAndSync}
 				onGenerateMessage={handleGenerateMessage}
 				committing={committing}
 				generating={generating}
 			/>
 
-			{/* Status messages */}
 			{error && (
 				<div className="scm-error">{error}</div>
 			)}
@@ -415,9 +796,43 @@ export function SourceControlView({
 				</div>
 			)}
 
-			{/* File list */}
-			<div className="scm-file-list">
-				{totalChanges === 0 && (
+			<div
+				className="scm-file-list"
+				onContextMenu={async (e) => {
+					if (
+						(e.target as HTMLElement).closest(
+							'.scm-file-row',
+						)
+					) {
+						return;
+					}
+					e.preventDefault();
+					const choice = await showScmContextMenu({
+						kind: 'header',
+					});
+					if (choice === 'refresh') await refresh();
+					if (choice === 'pull')
+						await handlePull(selectedRemote);
+					if (choice === 'push')
+						await handlePush(selectedRemote);
+					if (choice === 'fetch')
+						await window.api.gitFetch(
+							workspacePath,
+							selectedRemote,
+						);
+					if (choice === 'view-history')
+						setHistoryExpanded(true);
+					if (choice === 'open-gitignore') openGitignore();
+				}}
+			>
+				{showRebasePanel && (
+					<InteractiveRebasePanel
+						workspacePath={workspacePath}
+						onRefresh={refresh}
+						onError={setError}
+					/>
+				)}
+				{!showRebasePanel && totalChanges === 0 && (
 					<div className="scm-empty">
 						<CheckCircle
 							size={32}
@@ -430,7 +845,40 @@ export function SourceControlView({
 					</div>
 				)}
 
-				{/* Staged changes */}
+				{!showRebasePanel && (
+				<ChangeSectionHeader
+					title="Merge Changes"
+					count={status.merge.length}
+				>
+					{status.merge.map((file) => (
+						<FileChangeRow
+							key={`merge-${file.path}`}
+							filename={nameOf(file.path)}
+							dir={dirOf(file.path)}
+							status={file.status}
+							section="merge"
+							onStage={() =>
+								handleStage([file.path])
+							}
+							onClick={() =>
+								openMergeConflictDiff(
+									workspacePath,
+									file.path,
+								)
+							}
+							onContextMenu={(e) =>
+								void handleFileContext(
+									e,
+									file,
+									'merge',
+								)
+							}
+						/>
+					))}
+				</ChangeSectionHeader>
+				)}
+
+				{!showRebasePanel && (
 				<ChangeSectionHeader
 					title="Staged Changes"
 					count={status.staged.length}
@@ -444,6 +892,7 @@ export function SourceControlView({
 							dir={dirOf(file.path)}
 							status={file.status}
 							section="staged"
+							lfs={file.lfs}
 							onUnstage={() =>
 								handleUnstage([file.path])
 							}
@@ -451,17 +900,22 @@ export function SourceControlView({
 								handleDiscard([file.path])
 							}
 							onClick={() =>
-								handleFileClick(
-									file.absPath,
-									file.path,
+								handleFileClick(file.path, true)
+							}
+							onContextMenu={(e) =>
+								void handleFileContext(
+									e,
+									file,
+									'staged',
 									true,
 								)
 							}
 						/>
 					))}
 				</ChangeSectionHeader>
+				)}
 
-				{/* Changes (unstaged + untracked combined) */}
+				{!showRebasePanel && (
 				<ChangeSectionHeader
 					title="Changes"
 					count={
@@ -469,16 +923,9 @@ export function SourceControlView({
 						status.untracked.length
 					}
 					actionIcon="stage"
-					onAction={() =>
-						handleStage([
-							...status.unstaged.map(
-								(f) => f.path,
-							),
-							...status.untracked.map(
-								(f) => f.path,
-							),
-						])
-					}
+					onAction={handleStageAll}
+					secondaryActionIcon="discard"
+					onSecondaryAction={handleDiscardAll}
 				>
 					{status.unstaged.map((file) => (
 						<FileChangeRow
@@ -494,10 +941,13 @@ export function SourceControlView({
 								handleDiscard([file.path])
 							}
 							onClick={() =>
-								handleFileClick(
-									file.absPath,
-									file.path,
-									false,
+								handleFileClick(file.path, false)
+							}
+							onContextMenu={(e) =>
+								void handleFileContext(
+									e,
+									file,
+									'unstaged',
 								)
 							}
 						/>
@@ -515,21 +965,59 @@ export function SourceControlView({
 							onClick={() =>
 								onSelectFile(file.absPath)
 							}
+							onContextMenu={(e) =>
+								void handleFileContext(
+									e,
+									file,
+									'untracked',
+								)
+							}
 						/>
 					))}
 				</ChangeSectionHeader>
-			</div>
+				)}
 
-			{/* Diff viewer */}
-			{diffFile && (
-				<DiffView
-					filePath={diffFile.absPath}
-					relativePath={diffFile.relativePath}
-					cached={diffFile.cached}
-					onClose={() => setDiffFile(null)}
-					onOpenFile={onSelectFile}
+				<SubmodulesSection
+					workspacePath={workspacePath}
+					onRefresh={refresh}
+					onError={setError}
 				/>
-			)}
+				<WorktreesSection
+					workspacePath={workspacePath}
+					onError={setError}
+				/>
+
+				<HistoryPanel
+					workspacePath={workspacePath}
+					expanded={historyExpanded}
+					onToggle={() =>
+						setHistoryExpanded((v) => !v)
+					}
+					onRefresh={refresh}
+					onError={setError}
+				/>
+
+				<StashSection
+					workspacePath={workspacePath}
+					isActive={isActive ?? false}
+					onRefresh={refresh}
+					onError={setError}
+				/>
+			</div>
+
+			<RemoteManagerModal
+				workspacePath={workspacePath}
+				open={remoteModalOpen}
+				onClose={() => setRemoteModalOpen(false)}
+				onChanged={refresh}
+				onError={setError}
+			/>
+			<CompareBranchModal
+				workspacePath={workspacePath}
+				relativePath={compareFile ?? ''}
+				open={!!compareFile}
+				onClose={() => setCompareFile(null)}
+			/>
 		</div>
 	);
 }
diff --git a/collab-electron/packages/components/src/SourceControl/StashSection.tsx b/collab-electron/packages/components/src/SourceControl/StashSection.tsx
index cbec5c38..004feb74 100644
--- a/collab-electron/packages/components/src/SourceControl/StashSection.tsx
+++ b/collab-electron/packages/components/src/SourceControl/StashSection.tsx
@@ -14,12 +14,14 @@ import {
 import type { GitStash } from '@collab/shared/git-types';
 
 interface StashSectionProps {
+	workspacePath: string;
 	isActive: boolean;
 	onRefresh: () => void;
 	onError: (msg: string) => void;
 }
 
 export function StashSection({
+	workspacePath,
 	isActive,
 	onRefresh,
 	onError,
@@ -32,12 +34,13 @@ export function StashSection({
 
 	const loadStashes = useCallback(async () => {
 		try {
-			const list = await window.api.gitStashList();
+			const list =
+				await window.api.gitStashList(workspacePath);
 			setStashes(list);
 		} catch {
 			setStashes([]);
 		}
-	}, []);
+	}, [workspacePath]);
 
 	useEffect(() => {
 		if (isActive) loadStashes();
@@ -46,6 +49,7 @@ export function StashSection({
 	const handleSave = useCallback(async () => {
 		try {
 			await window.api.gitStashSave(
+				workspacePath,
 				stashMessage.trim() || undefined,
 			);
 			setStashInput(false);
@@ -59,12 +63,21 @@ export function StashSection({
 					: 'Stash failed',
 			);
 		}
-	}, [stashMessage, loadStashes, onRefresh, onError]);
+	}, [
+		workspacePath,
+		stashMessage,
+		loadStashes,
+		onRefresh,
+		onError,
+	]);
 
 	const handlePop = useCallback(
 		async (index: number) => {
 			try {
-				await window.api.gitStashPop(index);
+				await window.api.gitStashPop(
+					workspacePath,
+					index,
+				);
 				await loadStashes();
 				onRefresh();
 			} catch (err) {
@@ -75,13 +88,16 @@ export function StashSection({
 				);
 			}
 		},
-		[loadStashes, onRefresh, onError],
+		[workspacePath, loadStashes, onRefresh, onError],
 	);
 
 	const handleApply = useCallback(
 		async (index: number) => {
 			try {
-				await window.api.gitStashApply(index);
+				await window.api.gitStashApply(
+					workspacePath,
+					index,
+				);
 				await loadStashes();
 				onRefresh();
 			} catch (err) {
@@ -92,13 +108,16 @@ export function StashSection({
 				);
 			}
 		},
-		[loadStashes, onRefresh, onError],
+		[workspacePath, loadStashes, onRefresh, onError],
 	);
 
 	const handleDrop = useCallback(
 		async (index: number) => {
 			try {
-				await window.api.gitStashDrop(index);
+				await window.api.gitStashDrop(
+					workspacePath,
+					index,
+				);
 				await loadStashes();
 			} catch (err) {
 				onError(
@@ -108,7 +127,7 @@ export function StashSection({
 				);
 			}
 		},
-		[loadStashes, onError],
+		[workspacePath, loadStashes, onError],
 	);
 
 	return (
diff --git a/collab-electron/packages/components/src/SourceControl/SubmodulesSection.tsx b/collab-electron/packages/components/src/SourceControl/SubmodulesSection.tsx
new file mode 100644
index 00000000..98cd1a7a
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/SubmodulesSection.tsx
@@ -0,0 +1,59 @@
+import { useCallback, useEffect, useState } from "react";
+import type { GitSubmodule } from "@collab/shared/git-types";
+import { ChangeSectionHeader } from "./ChangeSectionHeader";
+
+interface SubmodulesSectionProps {
+  workspacePath: string;
+  onRefresh: () => void;
+  onError: (msg: string) => void;
+}
+
+export function SubmodulesSection({
+  workspacePath,
+  onRefresh,
+  onError,
+}: SubmodulesSectionProps) {
+  const [subs, setSubs] = useState<GitSubmodule[]>([]);
+
+  const load = useCallback(async () => {
+    try {
+      const list = await window.api.gitSubmoduleStatus(workspacePath);
+      setSubs(list);
+    } catch {
+      setSubs([]);
+    }
+  }, [workspacePath]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  if (subs.length === 0) return null;
+
+  const update = async (init?: boolean) => {
+    try {
+      await window.api.gitSubmoduleUpdate(workspacePath, init, true);
+      onRefresh();
+      await load();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Submodule update failed");
+    }
+  };
+
+  return (
+    <ChangeSectionHeader title="Submodules" count={subs.length}>
+      {subs.map((s) => (
+        <div key={s.path} className="scm-submodule-row">
+          <span className="scm-submodule-path">
+            {s.path}
+            {s.dirty && <span className="scm-file-badge badge-M">dirty</span>}
+          </span>
+          <span className="scm-submodule-commit">{s.commit.slice(0, 7)}</span>
+          <button type="button" onClick={() => void update(true)}>
+            Update
+          </button>
+        </div>
+      ))}
+    </ChangeSectionHeader>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/SyncBar.tsx b/collab-electron/packages/components/src/SourceControl/SyncBar.tsx
index 1810cd1d..b2820371 100644
--- a/collab-electron/packages/components/src/SourceControl/SyncBar.tsx
+++ b/collab-electron/packages/components/src/SourceControl/SyncBar.tsx
@@ -1,29 +1,43 @@
-import React, { useCallback, useState } from 'react';
+import React, {
+	useCallback,
+	useEffect,
+	useState,
+} from 'react';
 import {
 	ArrowUp,
 	ArrowDown,
 	ArrowsClockwise,
 	CloudArrowUp,
 	CircleNotch,
+	CaretDown,
 } from '@phosphor-icons/react';
+import type { GitRemote } from '@collab/shared/git-types';
 
 interface SyncBarProps {
+	workspacePath: string;
 	ahead: number;
 	behind: number;
 	hasUpstream: boolean;
 	branch: string;
-	onPush: () => Promise<void>;
-	onPull: () => Promise<void>;
-	onSync: () => Promise<void>;
-	onPublish: () => Promise<void>;
+	selectedRemote: string;
+	onRemoteChange: (name: string) => void;
+	onManageRemotes?: () => void;
+	onPush: (remote?: string) => Promise<void>;
+	onPull: (remote?: string) => Promise<void>;
+	onSync: (remote?: string) => Promise<void>;
+	onPublish: (remote: string) => Promise<void>;
 	onError: (msg: string) => void;
 }
 
 export function SyncBar({
+	workspacePath,
 	ahead,
 	behind,
 	hasUpstream,
 	branch,
+	selectedRemote,
+	onRemoteChange,
+	onManageRemotes,
 	onPush,
 	onPull,
 	onSync,
@@ -34,8 +48,26 @@ export function SyncBar({
 	const [pulling, setPulling] = useState(false);
 	const [syncing, setSyncing] = useState(false);
 	const [publishing, setPublishing] = useState(false);
+	const [remotes, setRemotes] = useState<GitRemote[]>([]);
+	const [remoteMenuOpen, setRemoteMenuOpen] = useState(false);
+
+	useEffect(() => {
+		window.api
+			.gitRemotes(workspacePath)
+			.then((list) => {
+				setRemotes(list);
+				if (list.length > 0) {
+					const names = list.map((r) => r.name);
+					if (!names.includes(selectedRemote)) {
+						onRemoteChange(list[0]!.name);
+					}
+				}
+			})
+			.catch(() => setRemotes([]));
+	}, [workspacePath, selectedRemote, onRemoteChange]);
 
 	const busy = pushing || pulling || syncing || publishing;
+	const remote = selectedRemote || remotes[0]?.name;
 
 	const wrap = useCallback(
 		(
@@ -60,14 +92,66 @@ export function SyncBar({
 		[busy, onError],
 	);
 
+	const remotePicker =
+		remotes.length > 1 ? (
+			<div className="scm-remote-picker">
+				<button
+					type="button"
+					className="scm-remote-trigger"
+					onClick={() =>
+						setRemoteMenuOpen((o) => !o)
+					}
+					title="Select remote"
+				>
+					<span>{remote}</span>
+					<CaretDown size={10} weight="bold" />
+				</button>
+				{remoteMenuOpen && (
+					<div className="scm-remote-menu">
+						{remotes.map((r) => (
+							<button
+								key={r.name}
+								type="button"
+								className={`scm-remote-option${r.name === remote ? ' active' : ''}`}
+								onClick={() => {
+									onRemoteChange(r.name);
+									setRemoteMenuOpen(false);
+								}}
+							>
+								{r.name}
+							</button>
+						))}
+					</div>
+				)}
+			</div>
+		) : remotes.length === 1 ? (
+			<span className="scm-remote-label">
+				{remotes[0]!.name}
+			</span>
+		) : null;
+
+	const manageRemotes = onManageRemotes ? (
+		<button
+			type="button"
+			className="scm-manage-remotes"
+			onClick={onManageRemotes}
+		>
+			Manage…
+		</button>
+	) : null;
+
 	if (!hasUpstream) {
 		return (
 			<div className="scm-sync-bar">
+				{remotePicker}
+				{manageRemotes}
 				<button
 					type="button"
 					className="scm-sync-button publish"
 					disabled={busy}
-					onClick={wrap(setPublishing, onPublish)}
+					onClick={wrap(setPublishing, () =>
+						onPublish(remote || 'origin'),
+					)}
 					title={`Publish branch "${branch}" to remote`}
 				>
 					{publishing ? (
@@ -86,11 +170,15 @@ export function SyncBar({
 
 	return (
 		<div className="scm-sync-bar">
+			{remotePicker}
+			{manageRemotes}
 			<button
 				type="button"
 				className="scm-sync-button"
 				disabled={busy || ahead === 0}
-				onClick={wrap(setPushing, onPush)}
+				onClick={wrap(setPushing, () =>
+					onPush(remote),
+				)}
 				title={`Push ${ahead} commit${ahead !== 1 ? 's' : ''}`}
 			>
 				{pushing ? (
@@ -111,7 +199,9 @@ export function SyncBar({
 				type="button"
 				className="scm-sync-button"
 				disabled={busy || behind === 0}
-				onClick={wrap(setPulling, onPull)}
+				onClick={wrap(setPulling, () =>
+					onPull(remote),
+				)}
 				title={`Pull ${behind} commit${behind !== 1 ? 's' : ''}`}
 			>
 				{pulling ? (
@@ -132,7 +222,9 @@ export function SyncBar({
 				type="button"
 				className="scm-sync-button"
 				disabled={busy}
-				onClick={wrap(setSyncing, onSync)}
+				onClick={wrap(setSyncing, () =>
+					onSync(remote),
+				)}
 				title="Fetch, pull, then push"
 			>
 				{syncing ? (
diff --git a/collab-electron/packages/components/src/SourceControl/WorktreesSection.tsx b/collab-electron/packages/components/src/SourceControl/WorktreesSection.tsx
new file mode 100644
index 00000000..1c99796d
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/WorktreesSection.tsx
@@ -0,0 +1,65 @@
+import { useCallback, useEffect, useState } from "react";
+import type { GitWorktree } from "@collab/shared/git-types";
+import { ChangeSectionHeader } from "./ChangeSectionHeader";
+
+interface WorktreesSectionProps {
+  workspacePath: string;
+  onError: (msg: string) => void;
+}
+
+export function WorktreesSection({
+  workspacePath,
+  onError,
+}: WorktreesSectionProps) {
+  const [trees, setTrees] = useState<GitWorktree[]>([]);
+
+  const load = useCallback(async () => {
+    try {
+      const list = await window.api.gitWorktreeList(workspacePath);
+      setTrees(list);
+    } catch {
+      setTrees([]);
+    }
+  }, [workspacePath]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  if (trees.length <= 1) return null;
+
+  const addWorktree = async () => {
+    const wtPath = await window.api.openFolder();
+    if (!wtPath) return;
+    const branch = window.prompt("Branch name for worktree:");
+    if (!branch?.trim()) return;
+    try {
+      await window.api.gitWorktreeAdd(
+        workspacePath,
+        wtPath,
+        branch.trim(),
+      );
+      await load();
+    } catch (err) {
+      onError(err instanceof Error ? err.message : "Failed to add worktree");
+    }
+  };
+
+  return (
+    <ChangeSectionHeader title="Worktrees" count={trees.length}>
+      <button
+        type="button"
+        className="scm-worktree-add"
+        onClick={() => void addWorktree()}
+      >
+        Add worktree…
+      </button>
+      {trees.map((w) => (
+        <div key={w.path} className="scm-worktree-row">
+          <span className="scm-worktree-branch">{w.branch || "(detached)"}</span>
+          <span className="scm-worktree-path">{w.path}</span>
+        </div>
+      ))}
+    </ChangeSectionHeader>
+  );
+}
diff --git a/collab-electron/packages/components/src/SourceControl/scmContextMenu.ts b/collab-electron/packages/components/src/SourceControl/scmContextMenu.ts
new file mode 100644
index 00000000..31b35b21
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/scmContextMenu.ts
@@ -0,0 +1,96 @@
+import type { GitRepoState } from "@collab/shared/git-types";
+
+export type ScmContextTarget =
+  | { kind: "file"; section: string; path: string; absPath: string; cached?: boolean }
+  | { kind: "stash"; index: number; message: string }
+  | { kind: "section"; section: string }
+  | { kind: "header" };
+
+export async function showScmContextMenu(
+  target: ScmContextTarget,
+): Promise<string | null> {
+  const items = buildScmContextMenuItems(target);
+  if (items.length === 0) return null;
+  return window.api.showContextMenu(items);
+}
+
+export function buildScmContextMenuItems(
+  target: ScmContextTarget,
+): Array<{ id: string; label: string; enabled?: boolean }> {
+  if (target.kind === "file") {
+    const isMerge = target.section === "merge";
+    const items = [
+      { id: "open-changes", label: "Open Changes" },
+      { id: "open-file", label: "Open File" },
+    ];
+    if (target.section === "staged") {
+      items.push({ id: "unstage", label: "Unstage" });
+    } else if (target.section !== "merge") {
+      items.push({ id: "stage", label: "Stage" });
+    }
+    if (isMerge) {
+      items.push(
+        { id: "accept-current", label: "Accept Current" },
+        { id: "accept-incoming", label: "Accept Incoming" },
+        { id: "mark-resolved", label: "Mark Resolved" },
+      );
+    } else if (target.section !== "untracked") {
+      items.push({ id: "discard", label: "Discard Changes" });
+    }
+    items.push(
+      { id: "compare-branch", label: "Compare with Branch…" },
+      { id: "copy-path", label: "Copy Path" },
+      { id: "reveal", label: "Reveal in Finder" },
+    );
+    return items;
+  }
+
+  if (target.kind === "stash") {
+    return [
+      { id: "stash-pop", label: "Pop" },
+      { id: "stash-apply", label: "Apply" },
+      { id: "stash-drop", label: "Drop" },
+      { id: "copy-message", label: "Copy Message" },
+    ];
+  }
+
+  if (target.kind === "section") {
+    if (target.section === "staged") {
+      return [{ id: "unstage-all", label: "Unstage All" }];
+    }
+    if (target.section === "changes") {
+      return [
+        { id: "stage-all", label: "Stage All" },
+        { id: "discard-all", label: "Discard All" },
+        { id: "stash-all", label: "Stash All" },
+      ];
+    }
+    return [];
+  }
+
+  return [
+    { id: "refresh", label: "Refresh" },
+    { id: "pull", label: "Pull" },
+    { id: "push", label: "Push" },
+    { id: "fetch", label: "Fetch" },
+    { id: "view-history", label: "View History" },
+    { id: "open-gitignore", label: "Open .gitignore" },
+  ];
+}
+
+export function repoStateLabel(state: GitRepoState): string {
+  switch (state) {
+    case "merging":
+      return "Merge in progress";
+    case "rebasing":
+      return "Rebase in progress";
+    case "interactive-rebase":
+      return "Interactive rebase in progress";
+    case "cherry-picking":
+      return "Cherry-pick in progress";
+    case "reverting":
+      return "Revert in progress";
+    default:
+      return "";
+  }
+}
diff --git a/collab-electron/packages/components/src/SourceControl/scmOpenDiff.ts b/collab-electron/packages/components/src/SourceControl/scmOpenDiff.ts
new file mode 100644
index 00000000..de28a227
--- /dev/null
+++ b/collab-electron/packages/components/src/SourceControl/scmOpenDiff.ts
@@ -0,0 +1,30 @@
+import type { GitDiffOpenParams } from "@collab/shared/git-types";
+
+export function openScmFileDiff(
+  workspacePath: string,
+  relativePath: string,
+  cached: boolean,
+): void {
+  const params: GitDiffOpenParams = {
+    workspacePath,
+    relativePath,
+    left: { ref: "HEAD", label: "HEAD" },
+    right: cached
+      ? { ref: "index", label: "Index" }
+      : { ref: "working", label: "Working Tree" },
+  };
+  window.api.openGitDiff(params);
+}
+
+export function openMergeConflictDiff(
+  workspacePath: string,
+  relativePath: string,
+): void {
+  window.api.openGitDiff({
+    workspacePath,
+    relativePath,
+    left: { ref: ":1:", label: "Base" },
+    right: { ref: "working", label: "Working Tree" },
+    conflictStage: 1,
+  });
+}
diff --git a/collab-electron/packages/shared/src/git-types.ts b/collab-electron/packages/shared/src/git-types.ts
index 9bb6f4ad..09821cfa 100644
--- a/collab-electron/packages/shared/src/git-types.ts
+++ b/collab-electron/packages/shared/src/git-types.ts
@@ -1,10 +1,19 @@
 export type GitChangeStatus = "M" | "A" | "D" | "R" | "U" | "?";
 
+export type GitRepoState =
+  | "clean"
+  | "merging"
+  | "rebasing"
+  | "interactive-rebase"
+  | "cherry-picking"
+  | "reverting";
+
 export interface GitFileChange {
   path: string;
   absPath: string;
   status: GitChangeStatus;
   oldPath?: string;
+  lfs?: boolean;
 }
 
 export interface GitStatusResult {
@@ -15,7 +24,14 @@ export interface GitStatusResult {
   staged: GitFileChange[];
   unstaged: GitFileChange[];
   untracked: GitFileChange[];
+  merge: GitFileChange[];
   isGitRepo: boolean;
+  hasCommits: boolean;
+  repoState: GitRepoState;
+}
+
+export interface GitTag {
+  name: string;
 }
 
 export interface GitBranch {
@@ -36,3 +52,86 @@ export interface GitStash {
   message: string;
   date: string;
 }
+
+export interface GitDiffRef {
+  ref: string;
+  label: string;
+}
+
+export interface GitDiffOpenParams {
+  workspacePath: string;
+  relativePath: string;
+  title?: string;
+  left: GitDiffRef;
+  right: GitDiffRef;
+  /** Conflict stage for 3-way: 1=base, 2=ours, 3=theirs */
+  conflictStage?: 1 | 2 | 3;
+}
+
+export interface GitLogEntry {
+  hash: string;
+  shortHash: string;
+  subject: string;
+  author: string;
+  date: string;
+  parents: string[];
+}
+
+export interface GitLogFileChange {
+  path: string;
+  status: string;
+}
+
+export type GitRebaseAction =
+  | "pick"
+  | "reword"
+  | "edit"
+  | "squash"
+  | "fixup"
+  | "drop";
+
+export interface GitRebaseTodoItem {
+  action: GitRebaseAction;
+  hash: string;
+  subject: string;
+  /** Original line text for round-trip */
+  raw?: string;
+}
+
+export interface GitSubmodule {
+  path: string;
+  url: string;
+  branch?: string;
+  commit: string;
+  dirty: boolean;
+}
+
+export interface GitWorktree {
+  path: string;
+  branch: string;
+  head: string;
+  bare: boolean;
+  locked: boolean;
+}
+
+export interface GitDiffHunk {
+  index: number;
+  header: string;
+  patch: string;
+}
+
+export interface GitConfigDisplay {
+  userName: string;
+  userEmail: string;
+  credentialHelper: string;
+  gpgSign: boolean;
+}
+
+export interface GitCloneOptions {
+  branch?: string;
+  depth?: number;
+}
+
+export interface GitCloneResult {
+  path: string;
+}
diff --git a/collab-electron/packages/shared/src/window-api.d.ts b/collab-electron/packages/shared/src/window-api.d.ts
index 6d480c8c..6bafa2f8 100644
--- a/collab-electron/packages/shared/src/window-api.d.ts
+++ b/collab-electron/packages/shared/src/window-api.d.ts
@@ -5,10 +5,21 @@ import type {
 } from "./types";
 import type { ReplayMessage } from "./replay-types";
 import type {
+  GitCloneOptions,
+  GitCloneResult,
+  GitConfigDisplay,
+  GitDiffHunk,
+  GitDiffOpenParams,
+  GitLogEntry,
+  GitLogFileChange,
+  GitRebaseTodoItem,
   GitStatusResult,
   GitBranch,
   GitRemote,
   GitStash,
+  GitSubmodule,
+  GitTag,
+  GitWorktree,
 } from "./git-types";
 
 type Unsubscribe = () => void;
@@ -346,6 +357,10 @@ export interface CollabApi {
     cb: (newPath: string) => void,
   ) => Unsubscribe;
 
+  onGitDiffOpen: (
+    cb: (params: GitDiffOpenParams) => void,
+  ) => Unsubscribe;
+
   // Auto-updater
   updateGetStatus: () => Promise<UpdateState>;
   updateCheck: () => Promise<UpdateState>;
@@ -374,62 +389,241 @@ export interface CollabApi {
   forwardPinch: (deltaY: number) => void;
 
   // Git source control
-  gitStatus: () => Promise<GitStatusResult>;
-  gitStage: (paths: string[]) => Promise<void>;
-  gitUnstage: (paths: string[]) => Promise<void>;
-  gitStageAll: () => Promise<void>;
-  gitUnstageAll: () => Promise<void>;
-  gitDiscard: (paths: string[]) => Promise<void>;
-  gitDiscardAll: () => Promise<void>;
-  gitCommit: (message: string) => Promise<{ hash: string }>;
+  gitStatus: (workspacePath: string) => Promise<GitStatusResult>;
+  gitStage: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<void>;
+  gitUnstage: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<void>;
+  gitStageAll: (workspacePath: string) => Promise<void>;
+  gitUnstageAll: (workspacePath: string) => Promise<void>;
+  gitDiscard: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<void>;
+  gitDiscardAll: (workspacePath: string) => Promise<void>;
+  gitCommit: (
+    workspacePath: string,
+    message: string,
+    options?: { amend?: boolean; sign?: boolean },
+  ) => Promise<{ hash: string }>;
   gitDiff: (
+    workspacePath: string,
     filePath: string,
     cached: boolean,
   ) => Promise<string>;
-  gitGenerateCommitMessage: () => Promise<{
+  gitGenerateCommitMessage: (
+    workspacePath: string,
+  ) => Promise<{
     message: string;
     model: string;
   }>;
+  gitInit: (workspacePath: string) => Promise<void>;
   aiValidateKey: (
     key: string,
   ) => Promise<{ valid: boolean }>;
+  aiHasKey: () => Promise<boolean>;
   aiCanGenerate: () => Promise<{
     available: boolean;
     agent?: string;
   }>;
 
   // Push / Pull / Fetch
-  gitPush: () => Promise<void>;
+  gitPush: (
+    workspacePath: string,
+    remote?: string,
+  ) => Promise<void>;
   gitPushSetUpstream: (
+    workspacePath: string,
     remote: string,
     branch: string,
   ) => Promise<void>;
-  gitPull: () => Promise<void>;
-  gitFetch: () => Promise<void>;
-  gitRemotes: () => Promise<GitRemote[]>;
-  gitHasUpstream: () => Promise<boolean>;
+  gitPull: (
+    workspacePath: string,
+    remote?: string,
+  ) => Promise<void>;
+  gitFetch: (
+    workspacePath: string,
+    remote?: string,
+  ) => Promise<void>;
+  gitRemotes: (workspacePath: string) => Promise<GitRemote[]>;
+  gitHasUpstream: (workspacePath: string) => Promise<boolean>;
 
   // Branch operations
-  gitBranches: () => Promise<GitBranch[]>;
-  gitCheckout: (branch: string) => Promise<void>;
+  gitBranches: (workspacePath: string) => Promise<GitBranch[]>;
+  gitTags: (workspacePath: string) => Promise<GitTag[]>;
+  gitCheckout: (
+    workspacePath: string,
+    branch: string,
+  ) => Promise<void>;
   gitCreateBranch: (
+    workspacePath: string,
     name: string,
     startPoint?: string,
   ) => Promise<void>;
-  gitDeleteBranch: (name: string) => Promise<void>;
+  gitDeleteBranch: (
+    workspacePath: string,
+    name: string,
+  ) => Promise<void>;
 
   // Stash operations
-  gitStashSave: (message?: string) => Promise<void>;
-  gitStashList: () => Promise<GitStash[]>;
-  gitStashPop: (index: number) => Promise<void>;
-  gitStashApply: (index: number) => Promise<void>;
-  gitStashDrop: (index: number) => Promise<void>;
+  gitStashSave: (
+    workspacePath: string,
+    message?: string,
+  ) => Promise<void>;
+  gitStashList: (workspacePath: string) => Promise<GitStash[]>;
+  gitStashPop: (
+    workspacePath: string,
+    index: number,
+  ) => Promise<void>;
+  gitStashApply: (
+    workspacePath: string,
+    index: number,
+  ) => Promise<void>;
+  gitStashDrop: (
+    workspacePath: string,
+    index: number,
+  ) => Promise<void>;
 
   // Show file at ref (for diff viewer)
   gitShowFile: (
+    workspacePath: string,
+    ref: string,
+    filePath: string,
+  ) => Promise<string>;
+  gitReadBlob: (
+    workspacePath: string,
     ref: string,
     filePath: string,
   ) => Promise<string>;
+  gitDiffRefs: (
+    workspacePath: string,
+    leftRef: string,
+    rightRef: string,
+    filePath: string,
+  ) => Promise<string>;
+  openGitDiff: (params: GitDiffOpenParams) => void;
+  gitClone: (
+    url: string,
+    parentDir: string,
+    options?: GitCloneOptions,
+  ) => Promise<GitCloneResult>;
+  gitRemoteAdd: (
+    workspacePath: string,
+    name: string,
+    url: string,
+  ) => Promise<void>;
+  gitRemoteRemove: (
+    workspacePath: string,
+    name: string,
+  ) => Promise<void>;
+  gitRemoteRename: (
+    workspacePath: string,
+    oldName: string,
+    newName: string,
+  ) => Promise<void>;
+  gitRemoteSetUrl: (
+    workspacePath: string,
+    name: string,
+    url: string,
+    push?: boolean,
+  ) => Promise<void>;
+  gitCheckoutOurs: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<void>;
+  gitCheckoutTheirs: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<void>;
+  gitAdd: (workspacePath: string, paths: string[]) => Promise<void>;
+  gitMergeAbort: (workspacePath?: string) => Promise<void>;
+  gitMergeContinue: (workspacePath?: string) => Promise<void>;
+  gitCherryPickAbort: (workspacePath?: string) => Promise<void>;
+  gitCherryPickContinue: (workspacePath?: string) => Promise<void>;
+  gitRevertAbort: (workspacePath?: string) => Promise<void>;
+  gitRevertContinue: (workspacePath?: string) => Promise<void>;
+  gitLog: (
+    workspacePath?: string,
+    options?: { maxCount?: number; ref?: string },
+  ) => Promise<GitLogEntry[]>;
+  gitLogFiles: (
+    workspacePath: string,
+    hash: string,
+  ) => Promise<GitLogFileChange[]>;
+  gitRevertCommit: (
+    workspacePath: string,
+    hash: string,
+  ) => Promise<void>;
+  gitCherryPick: (
+    workspacePath: string,
+    hash: string,
+  ) => Promise<void>;
+  gitReset: (
+    workspacePath: string,
+    mode: "soft" | "mixed" | "hard",
+    ref: string,
+  ) => Promise<void>;
+  gitMerge: (workspacePath: string, branch: string) => Promise<void>;
+  gitRebase: (workspacePath: string, onto: string) => Promise<void>;
+  gitRebaseContinue: (workspacePath?: string) => Promise<void>;
+  gitRebaseAbort: (workspacePath?: string) => Promise<void>;
+  gitRebaseSkip: (workspacePath?: string) => Promise<void>;
+  gitRebaseTodoList: (
+    workspacePath?: string,
+  ) => Promise<GitRebaseTodoItem[]>;
+  gitRebaseTodoWrite: (
+    workspacePath: string,
+    items: GitRebaseTodoItem[],
+  ) => Promise<void>;
+  gitRebaseStartInteractive: (
+    workspacePath: string,
+    onto: string | null,
+    count: number,
+  ) => Promise<void>;
+  gitSubmoduleStatus: (
+    workspacePath?: string,
+  ) => Promise<GitSubmodule[]>;
+  gitSubmoduleUpdate: (
+    workspacePath?: string,
+    init?: boolean,
+    recursive?: boolean,
+  ) => Promise<void>;
+  gitWorktreeList: (workspacePath?: string) => Promise<GitWorktree[]>;
+  gitWorktreeAdd: (
+    workspacePath: string,
+    wtPath: string,
+    branch: string,
+  ) => Promise<void>;
+  gitWorktreeRemove: (
+    workspacePath: string,
+    wtPath: string,
+  ) => Promise<void>;
+  gitDiffHunks: (
+    workspacePath: string,
+    filePath: string,
+    cached?: boolean,
+  ) => Promise<GitDiffHunk[]>;
+  gitApplyCached: (
+    workspacePath: string,
+    patch: string,
+  ) => Promise<void>;
+  gitApplyWorking: (
+    workspacePath: string,
+    patch: string,
+    reverse?: boolean,
+  ) => Promise<void>;
+  gitCheckIgnore: (
+    workspacePath: string,
+    paths: string[],
+  ) => Promise<string[]>;
+  gitConfigDisplay: (
+    workspacePath?: string,
+  ) => Promise<GitConfigDisplay>;
+  gitGpgSignEnabled: (workspacePath?: string) => Promise<boolean>;
 }
 
 declare global {
diff --git a/collab-electron/scripts/capture-scm-screenshots.mjs b/collab-electron/scripts/capture-scm-screenshots.mjs
new file mode 100644
index 00000000..352171eb
--- /dev/null
+++ b/collab-electron/scripts/capture-scm-screenshots.mjs
@@ -0,0 +1,299 @@
+#!/usr/bin/env bun
+/**
+ * Capture SCM UI screenshots for docs/PR review.
+ * Usage: bun scripts/capture-scm-screenshots.mjs
+ */
+import { spawn } from "node:child_process";
+import { mkdir, access } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const COLLAB_ELECTRON = resolve(__dirname, "..");
+const REPO_ROOT = resolve(COLLAB_ELECTRON, "..");
+const FIXTURES = join(REPO_ROOT, "fixtures/git");
+const OUT_DIR = join(COLLAB_ELECTRON, "docs/screenshots/scm");
+const BRIDGE_PORT = 9876;
+const VITE_PORT = 5199;
+const HARNESS_URL = `http://127.0.0.1:${VITE_PORT}`;
+
+const workspaces = {
+  worktree: join(FIXTURES, "dirty-worktree"),
+  mergeConflict: join(FIXTURES, "merge-conflict"),
+  rebaseTodo: join(FIXTURES, "rebase-todo"),
+};
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      cwd: opts.cwd ?? COLLAB_ELECTRON,
+      env: { ...process.env, ...opts.env },
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolvePromise();
+      else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}`));
+    });
+  });
+}
+
+function spawnBg(cmd, args, opts = {}) {
+  const child = spawn(cmd, args, {
+    stdio: opts.stdio ?? "ignore",
+    cwd: opts.cwd ?? COLLAB_ELECTRON,
+    env: { ...process.env, ...opts.env },
+    detached: false,
+  });
+  child.on("error", (err) => {
+    console.error(`Failed to start ${cmd}:`, err.message);
+  });
+  return child;
+}
+
+async function waitForUrl(url, timeoutMs = 60_000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {
+      /* retry */
+    }
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  throw new Error(`Timed out waiting for ${url}`);
+}
+
+async function ensurePlaywright() {
+  try {
+    await import("playwright");
+  } catch {
+    console.log("Installing playwright…");
+    await run("bun", ["add", "-d", "playwright"], { cwd: COLLAB_ELECTRON });
+    await run("bunx", ["playwright", "install", "chromium"], {
+      cwd: COLLAB_ELECTRON,
+    });
+  }
+}
+
+/** @type {import('playwright').Page} */
+async function openHarness(page, scene, workspace) {
+  const url = `${HARNESS_URL}/?scene=${encodeURIComponent(scene)}&workspace=${encodeURIComponent(workspace)}`;
+  await page.goto(url, { waitUntil: "domcontentloaded" });
+  const readySelector =
+    scene === "settings-git"
+      ? "h2"
+      : scene === "viewer-diff"
+        ? ".diff-editor-root, .viewer-diff-scene"
+        : ".scm-container";
+  await page.waitForSelector(readySelector, { timeout: 30_000 });
+  await page.waitForTimeout(800);
+}
+
+async function freePorts() {
+  for (const port of [VITE_PORT, BRIDGE_PORT]) {
+    try {
+      const { execSync } = await import("node:child_process");
+      const pids = execSync(`lsof -ti:${port} 2>/dev/null || true`, {
+        encoding: "utf8",
+      })
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+      for (const pid of pids) {
+        try {
+          process.kill(Number(pid), "SIGTERM");
+        } catch {
+          /* already gone */
+        }
+      }
+    } catch {
+      /* lsof unavailable */
+    }
+  }
+  await new Promise((r) => setTimeout(r, 300));
+}
+
+async function main() {
+  await freePorts();
+  console.log("Setting up git fixtures…");
+  await run("bash", [join(FIXTURES, "setup-all.sh")], { cwd: REPO_ROOT });
+
+  await mkdir(OUT_DIR, { recursive: true });
+  await ensurePlaywright();
+
+  const bridge = spawnBg("bun", [
+    join(COLLAB_ELECTRON, "scripts/scm-screenshot-git-bridge.mjs"),
+  ], {
+    env: {
+      SCM_SCREENSHOT_GIT_BRIDGE_PORT: String(BRIDGE_PORT),
+    },
+  });
+
+  const vite = spawnBg(
+    "bun",
+    [
+      "x",
+      "vite",
+      "--config",
+      "scripts/scm-screenshot-harness.vite.config.ts",
+    ],
+    {
+      env: {
+        VITE_SCM_GIT_BRIDGE: `http://127.0.0.1:${BRIDGE_PORT}`,
+      },
+    },
+  );
+
+  const cleanup = () => {
+    bridge.kill("SIGTERM");
+    vite.kill("SIGTERM");
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+
+  try {
+    await waitForUrl(`${HARNESS_URL}/`);
+    const { chromium } = await import("playwright");
+
+    const browser = await chromium.launch({ headless: true });
+    const created = [];
+
+    const capture = async (filename, options) => {
+      const outPath = join(OUT_DIR, filename);
+      const page = await browser.newPage({
+        viewport: options.viewport ?? { width: 380, height: 860 },
+        deviceScaleFactor: 2,
+      });
+      try {
+        await openHarness(page, options.scene, options.workspace);
+        if (options.beforeShot) await options.beforeShot(page);
+        if (options.fillCommit) {
+          await page.fill(
+            ".scm-commit-textarea",
+            "Refactor source control panel layout",
+          );
+        }
+        if (options.clip) {
+          const el = page.locator(options.clip).first();
+          await el.waitFor({ state: "visible", timeout: 10_000 });
+          await el.screenshot({ path: outPath });
+        } else {
+          await page.screenshot({ path: outPath, fullPage: false });
+        }
+        await access(outPath);
+        created.push(outPath);
+        console.log(`  ✓ ${filename}`);
+      } catch (err) {
+        console.warn(`  ✗ ${filename}: ${err.message}`);
+      } finally {
+        await page.close();
+      }
+    };
+
+    console.log("Capturing screenshots…");
+
+    await capture("01-scm-overview.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      viewport: { width: 380, height: 900 },
+    });
+
+    await capture("02-commit-box.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      clip: ".scm-commit-box",
+      fillCommit: true,
+      viewport: { width: 380, height: 400 },
+    });
+
+    await capture("03-branch-picker.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      viewport: { width: 380, height: 700 },
+      beforeShot: async (page) => {
+        await page.click(".scm-branch-trigger");
+        await page.waitForSelector(".scm-branch-dropdown", {
+          state: "visible",
+        });
+      },
+    });
+
+    await capture("04-sync-remotes.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      viewport: { width: 380, height: 520 },
+      beforeShot: async (page) => {
+        await page.getByRole("button", { name: "Manage…" }).click();
+        await page.waitForSelector(".scm-modal", { state: "visible" });
+      },
+    });
+
+    await capture("05-merge-conflicts.png", {
+      scene: "scm",
+      workspace: workspaces.mergeConflict,
+      viewport: { width: 380, height: 820 },
+    });
+
+    await capture("06-history.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      viewport: { width: 380, height: 900 },
+      beforeShot: async (page) => {
+        await page.click(".scm-history-toggle");
+        await page.waitForSelector(".scm-history-list", {
+          state: "visible",
+        });
+        await page.locator(".scm-history-row").first().click();
+      },
+    });
+
+    await capture("07-interactive-rebase.png", {
+      scene: "scm",
+      workspace: workspaces.rebaseTodo,
+      viewport: { width: 380, height: 820 },
+    });
+
+    await capture("08-stash.png", {
+      scene: "scm",
+      workspace: workspaces.worktree,
+      viewport: { width: 380, height: 520 },
+      beforeShot: async (page) => {
+        const header = page
+          .locator(".scm-section-header")
+          .filter({ hasText: "Stashes" });
+        await header.click();
+        await page.waitForSelector(".scm-stash-row", { state: "visible" });
+      },
+    });
+
+    await capture("09-viewer-diff.png", {
+      scene: "viewer-diff",
+      workspace: workspaces.mergeConflict,
+      viewport: { width: 960, height: 640 },
+    });
+
+    await capture("10-settings-git.png", {
+      scene: "settings-git",
+      workspace: workspaces.worktree,
+      viewport: { width: 720, height: 520 },
+    });
+
+    await browser.close();
+
+    console.log(`\nCreated ${created.length} image(s) in ${OUT_DIR}`);
+    for (const p of created) console.log(p);
+    return created;
+  } finally {
+    cleanup();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/collab-electron/scripts/scm-screenshot-git-bridge.mjs b/collab-electron/scripts/scm-screenshot-git-bridge.mjs
new file mode 100644
index 00000000..bf95968e
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-git-bridge.mjs
@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+/**
+ * Local HTTP bridge so the SCM screenshot harness can call real git helpers.
+ */
+import { createServer } from "node:http";
+import { URL } from "node:url";
+
+const PORT = Number(process.env.SCM_SCREENSHOT_GIT_BRIDGE_PORT ?? 9876);
+
+const git = await import("../src/main/git-source-control.ts");
+
+const STUBS = {
+  aiCanGenerate: async () => ({ available: false }),
+  aiGenerateCommitMessage: async () => "",
+  onFsChanged: () => () => {},
+  showContextMenu: async () => null,
+  openGitDiff: async () => {},
+  createGraphTile: async () => {},
+  startReplay: async () => {},
+  confirm: () => true,
+  getConfig: async () => ({
+    workspaces: [process.env.SCM_SCREENSHOT_WORKSPACE ?? ""],
+  }),
+};
+
+const HANDLERS = {
+  gitStatus: (cwd) => git.gitStatus(cwd),
+  gitStage: (cwd, paths) => git.gitStage(cwd, paths),
+  gitUnstage: (cwd, paths) => git.gitUnstage(cwd, paths),
+  gitStageAll: (cwd) => git.gitStageAll(cwd),
+  gitUnstageAll: (cwd) => git.gitUnstageAll(cwd),
+  gitDiscard: (cwd, paths) => git.gitDiscard(cwd, paths),
+  gitDiscardAll: (cwd) => git.gitDiscardAll(cwd),
+  gitCommit: (cwd, message, options) => git.gitCommit(cwd, message, options),
+  gitDiff: (cwd, filePath, cached) => git.gitDiff(cwd, filePath, cached),
+  gitInit: (cwd) => git.gitInit(cwd),
+  gitPush: (cwd, remote) => git.gitPush(cwd, remote),
+  gitPushSetUpstream: (cwd, remote, branch) =>
+    git.gitPushSetUpstream(cwd, remote, branch),
+  gitPull: (cwd, remote) => git.gitPull(cwd, remote),
+  gitFetch: (cwd, remote) => git.gitFetch(cwd, remote),
+  gitRemotes: (cwd) => git.gitRemotes(cwd),
+  gitHasUpstream: (cwd) => git.gitHasUpstream(cwd),
+  gitBranches: (cwd) => git.gitBranches(cwd),
+  gitTags: (cwd) => git.gitTags(cwd),
+  gitCheckout: (cwd, branch) => git.gitCheckout(cwd, branch),
+  gitCreateBranch: (cwd, name, startPoint) =>
+    git.gitCreateBranch(cwd, name, startPoint),
+  gitDeleteBranch: (cwd, name) => git.gitDeleteBranch(cwd, name),
+  gitStashSave: (cwd, message) => git.gitStashSave(cwd, message),
+  gitStashList: (cwd) => git.gitStashList(cwd),
+  gitStashPop: (cwd, index) => git.gitStashPop(cwd, index),
+  gitStashApply: (cwd, index) => git.gitStashApply(cwd, index),
+  gitStashDrop: (cwd, index) => git.gitStashDrop(cwd, index),
+  gitShowFile: (cwd, ref, path) => git.gitShowFile(cwd, ref, path),
+  gitReadBlob: (cwd, ref, path) => git.gitReadBlob(cwd, ref, path),
+  gitDiffRefs: (cwd, path, left, right) =>
+    git.gitDiffRefs(cwd, path, left, right),
+  gitRemoteAdd: (cwd, name, url) => git.gitRemoteAdd(cwd, name, url),
+  gitRemoteRemove: (cwd, name) => git.gitRemoteRemove(cwd, name),
+  gitRemoteRename: (cwd, oldName, newName) =>
+    git.gitRemoteRename(cwd, oldName, newName),
+  gitRemoteSetUrl: (cwd, name, url, push) =>
+    git.gitRemoteSetUrl(cwd, name, url, push),
+  gitCheckoutOurs: (cwd, paths) => git.gitCheckoutOurs(cwd, paths),
+  gitCheckoutTheirs: (cwd, paths) => git.gitCheckoutTheirs(cwd, paths),
+  gitAdd: (cwd, paths) => git.gitAdd(cwd, paths),
+  gitMergeAbort: (cwd) => git.gitMergeAbort(cwd),
+  gitMergeContinue: (cwd) => git.gitMergeContinue(cwd),
+  gitCherryPickAbort: (cwd) => git.gitCherryPickAbort(cwd),
+  gitCherryPickContinue: (cwd) => git.gitCherryPickContinue(cwd),
+  gitRevertAbort: (cwd) => git.gitRevertAbort(cwd),
+  gitRevertContinue: (cwd) => git.gitRevertContinue(cwd),
+  gitLog: (cwd, options) => git.gitLog(cwd, options),
+  gitLogFiles: (cwd, hash) => git.gitLogFiles(cwd, hash),
+  gitRevertCommit: (cwd, hash) => git.gitRevertCommit(cwd, hash),
+  gitCherryPick: (cwd, hash) => git.gitCherryPick(cwd, hash),
+  gitReset: (cwd, mode, hash) => git.gitReset(cwd, mode, hash),
+  gitMerge: (cwd, branch) => git.gitMerge(cwd, branch),
+  gitRebase: (cwd, onto) => git.gitRebase(cwd, onto),
+  gitRebaseContinue: (cwd) => git.gitRebaseContinue(cwd),
+  gitRebaseAbort: (cwd) => git.gitRebaseAbort(cwd),
+  gitRebaseSkip: (cwd) => git.gitRebaseSkip(cwd),
+  gitRebaseTodoList: (cwd) => git.gitRebaseTodoList(cwd),
+  gitRebaseTodoWrite: (cwd, items) => git.gitRebaseTodoWrite(cwd, items),
+  gitRebaseStartInteractive: (cwd, onto, count) =>
+    git.gitRebaseStartInteractive(cwd, onto, count),
+  gitSubmoduleStatus: (cwd) => git.gitSubmoduleStatus(cwd),
+  gitSubmoduleUpdate: (cwd, init, recursive) =>
+    git.gitSubmoduleUpdate(cwd, init, recursive),
+  gitWorktreeList: (cwd) => git.gitWorktreeList(cwd),
+  gitConfigDisplay: (cwd) => git.gitConfigDisplay(cwd),
+  gitGpgSignEnabled: (cwd) => git.gitGpgSignEnabled(cwd),
+  gitGenerateCommitMessage: async () => "",
+  gitDiffHunks: (cwd, path, cached) => git.gitDiffHunks(cwd, path, cached),
+  gitCheckIgnore: (cwd, paths) => git.gitCheckIgnore(cwd, paths),
+  gitPathsUsingLfs: (cwd, paths) => git.gitPathsUsingLfs(cwd, paths),
+  gitLfsAvailable: () => git.gitLfsAvailable(),
+};
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () =>
+      resolve(Buffer.concat(chunks).toString("utf8")),
+    );
+    req.on("error", reject);
+  });
+}
+
+const server = createServer(async (req, res) => {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  if (req.method !== "POST" || req.url !== "/rpc") {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+    return;
+  }
+
+  try {
+    const body = JSON.parse(await readBody(req));
+    const { method, args = [] } = body;
+    const handler = HANDLERS[method] ?? STUBS[method];
+    if (!handler) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Unknown method: ${method}` }));
+      return;
+    }
+    const result = await handler(...args);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ result }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: err instanceof Error ? err.message : String(err),
+      }),
+    );
+  }
+});
+
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`SCM git bridge listening on http://127.0.0.1:${PORT}`);
+});
diff --git a/collab-electron/scripts/scm-screenshot-harness.vite.config.ts b/collab-electron/scripts/scm-screenshot-harness.vite.config.ts
new file mode 100644
index 00000000..f08afd7d
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-harness.vite.config.ts
@@ -0,0 +1,26 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { resolve } from "node:path";
+
+const collabElectron = resolve(import.meta.dirname, "..");
+
+export default defineConfig({
+  root: resolve(collabElectron, "scripts/scm-screenshot-harness"),
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@collab/shared": resolve(collabElectron, "packages/shared/src"),
+      "@collab/components": resolve(collabElectron, "packages/components/src"),
+      "@collab/theme": resolve(collabElectron, "packages/theme/src"),
+    },
+  },
+  server: {
+    host: "127.0.0.1",
+    port: 5199,
+    strictPort: true,
+  },
+  build: {
+    outDir: resolve(collabElectron, "scripts/scm-screenshot-harness/dist"),
+    emptyOutDir: true,
+  },
+});
diff --git a/collab-electron/scripts/scm-screenshot-harness/GitSettingsPane.tsx b/collab-electron/scripts/scm-screenshot-harness/GitSettingsPane.tsx
new file mode 100644
index 00000000..cd01c8bd
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-harness/GitSettingsPane.tsx
@@ -0,0 +1,91 @@
+import { useEffect, useState } from "react";
+import { rpc } from "./mock-api";
+
+interface GitConfig {
+  userName: string;
+  userEmail: string;
+  credentialHelper: string;
+  gpgSign: boolean;
+}
+
+/** Mirrors Settings → Git pane for screenshots. */
+export function GitSettingsPane({
+  workspacePath,
+}: {
+  workspacePath: string;
+}) {
+  const [cfg, setCfg] = useState<GitConfig | null>(null);
+
+  useEffect(() => {
+    if (!workspacePath) return;
+    void rpc<GitConfig>("gitConfigDisplay", workspacePath).then(setCfg);
+  }, [workspacePath]);
+
+  return (
+    <div
+      style={{
+        fontFamily: "var(--font-sans)",
+        background: "var(--background)",
+        color: "var(--foreground)",
+        height: "100%",
+      }}
+    >
+      <div style={{ padding: 24 }}>
+        <div style={{ marginBottom: 24 }}>
+          <h2 style={{ fontSize: 16, fontWeight: 600, margin: "0 0 4px" }}>
+            Git
+          </h2>
+          <p
+            style={{
+              fontSize: 14,
+              color: "var(--muted-foreground)",
+              margin: 0,
+              lineHeight: 1.5,
+            }}
+          >
+            Read-only view of your system git configuration. Manage credentials
+            with your OS credential manager or{" "}
+            <code style={{ fontSize: 12 }}>git config</code> in a terminal.
+          </p>
+        </div>
+        {cfg ? (
+          <dl
+            style={{
+              fontSize: 14,
+              fontFamily: "var(--font-mono), 'IBM Plex Mono', monospace",
+            }}
+          >
+            <div style={{ marginBottom: 12 }}>
+              <dt style={{ color: "var(--muted-foreground)", marginBottom: 2 }}>
+                user.name
+              </dt>
+              <dd style={{ margin: 0 }}>{cfg.userName || "—"}</dd>
+            </div>
+            <div style={{ marginBottom: 12 }}>
+              <dt style={{ color: "var(--muted-foreground)", marginBottom: 2 }}>
+                user.email
+              </dt>
+              <dd style={{ margin: 0 }}>{cfg.userEmail || "—"}</dd>
+            </div>
+            <div style={{ marginBottom: 12 }}>
+              <dt style={{ color: "var(--muted-foreground)", marginBottom: 2 }}>
+                credential.helper
+              </dt>
+              <dd style={{ margin: 0 }}>{cfg.credentialHelper || "—"}</dd>
+            </div>
+            <div>
+              <dt style={{ color: "var(--muted-foreground)", marginBottom: 2 }}>
+                commit.gpgsign
+              </dt>
+              <dd style={{ margin: 0 }}>{cfg.gpgSign ? "true" : "false"}</dd>
+            </div>
+          </dl>
+        ) : (
+          <p style={{ fontSize: 14, color: "var(--muted-foreground)" }}>
+            Loading…
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/collab-electron/scripts/scm-screenshot-harness/index.html b/collab-electron/scripts/scm-screenshot-harness/index.html
new file mode 100644
index 00000000..beed1f4a
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-harness/index.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SCM Screenshot Harness</title>
+    <style>
+      html,
+      body,
+      #root {
+        margin: 0;
+        height: 100%;
+        overflow: hidden;
+        background: var(--background);
+        color: var(--foreground);
+        font-family: var(--font-sans);
+      }
+      body[data-scene="settings-git"] #root {
+        width: 720px;
+        height: 520px;
+      }
+      body[data-scene="viewer-diff"] #root {
+        width: 960px;
+        height: 640px;
+      }
+      body[data-scene^="scm"] #root {
+        width: 380px;
+        height: 100%;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/main.tsx"></script>
+  </body>
+</html>
diff --git a/collab-electron/scripts/scm-screenshot-harness/main.tsx b/collab-electron/scripts/scm-screenshot-harness/main.tsx
new file mode 100644
index 00000000..f7f2d331
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-harness/main.tsx
@@ -0,0 +1,132 @@
+import { StrictMode, useEffect, useState } from "react";
+import { createRoot } from "react-dom/client";
+import "@collab/theme/styles.css";
+import "@collab/components/SourceControl/SourceControl.css";
+import { SourceControlView } from "@collab/components/SourceControl";
+import { DiffEditorView } from "@collab/components/DiffEditorView";
+import "@collab/components/DiffEditorView/DiffEditorView.css";
+import { installMockApi, rpc } from "./mock-api";
+import { GitSettingsPane } from "./GitSettingsPane";
+
+document.documentElement.classList.add("dark");
+document.documentElement.setAttribute("data-theme", "dark");
+
+const params = new URLSearchParams(window.location.search);
+const scene = params.get("scene") ?? "scm";
+const workspacePath = params.get("workspace") ?? "";
+document.body.dataset.scene = scene;
+
+if (workspacePath) {
+  installMockApi(workspacePath);
+}
+
+function ScmPanel() {
+  return (
+    <div className="scm-container" style={{ height: "100vh" }}>
+      <SourceControlView
+        workspacePath={workspacePath}
+        isActive
+        onSelectFile={() => {}}
+      />
+    </div>
+  );
+}
+
+function ViewerDiffScene() {
+  const [original, setOriginal] = useState("base\n");
+  const [modified, setModified] = useState("base\n<<<<<<< HEAD\n");
+
+  useEffect(() => {
+    if (!workspacePath) return;
+    void (async () => {
+      try {
+        const left = await rpc<string>(
+          "gitShowFile",
+          workspacePath,
+          "HEAD",
+          "base.txt",
+        );
+        const right = await rpc<string>(
+          "gitDiff",
+          workspacePath,
+          "base.txt",
+          false,
+        );
+        setOriginal(left || "base\n");
+        setModified(right || left);
+      } catch {
+        setOriginal("base\n");
+        setModified(
+          "base\n<<<<<<< HEAD\nmain line\n=======\nfeature line\n>>>>>>> feature\n",
+        );
+      }
+    })();
+  }, []);
+
+  const header = "base.txt (HEAD ↔ Working Tree)";
+
+  return (
+    <div
+      className="viewer-diff-scene"
+      style={{
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        background: "var(--background)",
+        color: "var(--foreground)",
+      }}
+    >
+      <div
+        style={{
+          padding: "8px 12px",
+          fontSize: 12,
+          fontFamily: "IBM Plex Mono, monospace",
+          borderBottom:
+            "1px solid color-mix(in srgb, var(--border) 50%, transparent)",
+        }}
+      >
+        {header}
+      </div>
+      <div style={{ flex: 1, minHeight: 0 }}>
+        <DiffEditorView
+          filePath="base.txt"
+          original={original}
+          modified={modified}
+          theme="dark"
+          readOnly
+        />
+      </div>
+    </div>
+  );
+}
+
+function App() {
+  if (scene === "settings-git") {
+    return <GitSettingsPane workspacePath={workspacePath} />;
+  }
+  if (scene === "viewer-diff") {
+    return <ViewerDiffScene />;
+  }
+  return <ScmPanel />;
+}
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Missing #root");
+
+createRoot(root).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);
+
+// Signal Playwright that async UI (git status) has settled.
+declare global {
+  interface Window {
+    __scmHarnessReady?: boolean;
+  }
+}
+
+window.__scmHarnessReady = false;
+setTimeout(() => {
+  window.__scmHarnessReady = true;
+}, 1200);
diff --git a/collab-electron/scripts/scm-screenshot-harness/mock-api.ts b/collab-electron/scripts/scm-screenshot-harness/mock-api.ts
new file mode 100644
index 00000000..ed8ad6fa
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshot-harness/mock-api.ts
@@ -0,0 +1,114 @@
+const BRIDGE =
+  import.meta.env.VITE_SCM_GIT_BRIDGE ?? "http://127.0.0.1:9876";
+
+export async function rpc<T>(method: string, ...args: unknown[]): Promise<T> {
+  const res = await fetch(`${BRIDGE}/rpc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ method, args }),
+  });
+  const json = (await res.json()) as { result?: T; error?: string };
+  if (!res.ok || json.error) {
+    throw new Error(json.error ?? `RPC ${method} failed`);
+  }
+  return json.result as T;
+}
+
+function bind<T extends (...a: never[]) => unknown>(method: string) {
+  return (...args: Parameters<T>) => rpc(method, ...args);
+}
+
+export function installMockApi(workspacePath: string) {
+  const w = window as Window & { api: Record<string, unknown> };
+  w.api = {
+    gitStatus: (p: string) => rpc("gitStatus", p),
+    gitStage: bind("gitStage"),
+    gitUnstage: bind("gitUnstage"),
+    gitStageAll: (p: string) => rpc("gitStageAll", p),
+    gitUnstageAll: (p: string) => rpc("gitUnstageAll", p),
+    gitDiscard: bind("gitDiscard"),
+    gitDiscardAll: (p: string) => rpc("gitDiscardAll", p),
+    gitCommit: bind("gitCommit"),
+    gitDiff: bind("gitDiff"),
+    gitInit: (p: string) => rpc("gitInit", p),
+    gitPush: bind("gitPush"),
+    gitPushSetUpstream: bind("gitPushSetUpstream"),
+    gitPull: bind("gitPull"),
+    gitFetch: bind("gitFetch"),
+    gitRemotes: (p: string) => rpc("gitRemotes", p),
+    gitHasUpstream: (p: string) => rpc("gitHasUpstream", p),
+    gitBranches: (p: string) => rpc("gitBranches", p),
+    gitTags: (p: string) => rpc("gitTags", p),
+    gitCheckout: bind("gitCheckout"),
+    gitCreateBranch: bind("gitCreateBranch"),
+    gitDeleteBranch: bind("gitDeleteBranch"),
+    gitStashSave: bind("gitStashSave"),
+    gitStashList: (p: string) => rpc("gitStashList", p),
+    gitStashPop: bind("gitStashPop"),
+    gitStashApply: bind("gitStashApply"),
+    gitStashDrop: bind("gitStashDrop"),
+    gitShowFile: bind("gitShowFile"),
+    gitReadBlob: bind("gitReadBlob"),
+    gitDiffRefs: bind("gitDiffRefs"),
+    gitRemoteAdd: bind("gitRemoteAdd"),
+    gitRemoteRemove: bind("gitRemoteRemove"),
+    gitRemoteRename: bind("gitRemoteRename"),
+    gitRemoteSetUrl: bind("gitRemoteSetUrl"),
+    gitCheckoutOurs: bind("gitCheckoutOurs"),
+    gitCheckoutTheirs: bind("gitCheckoutTheirs"),
+    gitAdd: bind("gitAdd"),
+    gitMergeAbort: (p?: string) => rpc("gitMergeAbort", p ?? workspacePath),
+    gitMergeContinue: (p?: string) =>
+      rpc("gitMergeContinue", p ?? workspacePath),
+    gitCherryPickAbort: (p?: string) =>
+      rpc("gitCherryPickAbort", p ?? workspacePath),
+    gitCherryPickContinue: (p?: string) =>
+      rpc("gitCherryPickContinue", p ?? workspacePath),
+    gitRevertAbort: (p?: string) =>
+      rpc("gitRevertAbort", p ?? workspacePath),
+    gitRevertContinue: (p?: string) =>
+      rpc("gitRevertContinue", p ?? workspacePath),
+    gitLog: bind("gitLog"),
+    gitLogFiles: bind("gitLogFiles"),
+    gitRevertCommit: bind("gitRevertCommit"),
+    gitCherryPick: bind("gitCherryPick"),
+    gitReset: bind("gitReset"),
+    gitMerge: bind("gitMerge"),
+    gitRebase: bind("gitRebase"),
+    gitRebaseContinue: (p?: string) =>
+      rpc("gitRebaseContinue", p ?? workspacePath),
+    gitRebaseAbort: (p?: string) =>
+      rpc("gitRebaseAbort", p ?? workspacePath),
+    gitRebaseSkip: (p?: string) =>
+      rpc("gitRebaseSkip", p ?? workspacePath),
+    gitRebaseTodoList: (p?: string) =>
+      rpc("gitRebaseTodoList", p ?? workspacePath),
+    gitRebaseTodoWrite: bind("gitRebaseTodoWrite"),
+    gitRebaseStartInteractive: bind("gitRebaseStartInteractive"),
+    gitSubmoduleStatus: (p?: string) =>
+      rpc("gitSubmoduleStatus", p ?? workspacePath),
+    gitSubmoduleUpdate: bind("gitSubmoduleUpdate"),
+    gitWorktreeList: (p?: string) =>
+      rpc("gitWorktreeList", p ?? workspacePath),
+    gitConfigDisplay: (p?: string) =>
+      rpc("gitConfigDisplay", p ?? workspacePath),
+    gitGpgSignEnabled: (p?: string) =>
+      rpc("gitGpgSignEnabled", p ?? workspacePath),
+    gitGenerateCommitMessage: () => rpc("gitGenerateCommitMessage"),
+    gitDiffHunks: bind("gitDiffHunks"),
+    gitCheckIgnore: bind("gitCheckIgnore"),
+    gitPathsUsingLfs: bind("gitPathsUsingLfs"),
+    gitLfsAvailable: () => rpc("gitLfsAvailable"),
+    aiCanGenerate: () => rpc("aiCanGenerate"),
+    onFsChanged: () => () => {},
+    showContextMenu: () => rpc("showContextMenu"),
+    openGitDiff: () => rpc("openGitDiff"),
+    createGraphTile: () => rpc("createGraphTile"),
+    startReplay: () => rpc("startReplay"),
+    getConfig: () =>
+      rpc("getConfig").then((c: { workspaces?: string[] }) => ({
+        workspaces: [workspacePath],
+      })),
+    confirm: () => true,
+  };
+}
diff --git a/collab-electron/scripts/scm-screenshots/.deps/package.json b/collab-electron/scripts/scm-screenshots/.deps/package.json
new file mode 100644
index 00000000..2c148bd4
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/.deps/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "scm-screenshots-deps",
+  "private": true,
+  "dependencies": {
+    "playwright": "^1.58.0"
+  }
+}
diff --git a/collab-electron/scripts/scm-screenshots/capture.mjs b/collab-electron/scripts/scm-screenshots/capture.mjs
new file mode 100644
index 00000000..2a37c6b3
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/capture.mjs
@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Capture SCM UI screenshots via Playwright + Vite harness (headless).
+ *
+ * Usage (from collab-electron):
+ *   bun scripts/scm-screenshots/collect-data.mjs
+ *   node scripts/scm-screenshots/capture.mjs
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const depsDir = join(scriptDir, ".deps");
+const require = createRequire(import.meta.url);
+
+async function loadChromium() {
+  let playwrightRoot = depsDir;
+  if (!existsSync(join(depsDir, "node_modules/playwright"))) {
+    console.log("Installing playwright in scripts/scm-screenshots/.deps …");
+    execSync("npm install playwright@1.58.0 --omit=dev", {
+      cwd: depsDir,
+      stdio: "inherit",
+      env: process.env,
+    });
+  }
+  const pw = await import(
+    require.resolve("playwright", { paths: [playwrightRoot] }),
+  );
+  const mod = pw.default ?? pw;
+  if (!mod.chromium) {
+    throw new Error("playwright.chromium not found after import");
+  }
+  return mod.chromium;
+}
+
+const harnessDir = join(scriptDir, "harness");
+const outDir = join(scriptDir, "../../docs/screenshots/scm");
+const port = 5199;
+const baseUrl = `http://127.0.0.1:${port}`;
+
+mkdirSync(outDir, { recursive: true });
+mkdirSync(depsDir, { recursive: true });
+
+console.log("Collecting fixture data from git repos …");
+execSync("bun scripts/scm-screenshots/collect-data.mjs", {
+  cwd: join(scriptDir, "../.."),
+  stdio: "inherit",
+});
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      cwd: opts.cwd ?? harnessDir,
+      env: { ...process.env, ...opts.env },
+    });
+    child.on("error", reject);
+    child.on("exit", (code) =>
+      code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`)),
+    );
+  });
+}
+
+async function waitForServer(url, attempts = 80) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {
+      /* retry */
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  throw new Error(`Server not ready: ${url}`);
+}
+
+async function capture(page, filename, options = {}) {
+  const outPath = join(outDir, filename);
+  const root = page.locator("#screenshot-root");
+  await root.waitFor({ state: "visible", timeout: 15000 });
+  if (options.before) await options.before(page);
+  await page.waitForTimeout(options.delay ?? 400);
+  await root.screenshot({ path: outPath, animations: "disabled" });
+  console.log(`  ${filename}`);
+}
+
+const electronRoot = join(scriptDir, "../..");
+const viteBin = join(electronRoot, "node_modules/vite/bin/vite.js");
+const vite = spawn(
+  process.execPath,
+  [viteBin, "--config", join(harnessDir, "vite.config.ts"), "--host", "127.0.0.1"],
+  {
+    cwd: harnessDir,
+    stdio: "inherit",
+    env: { ...process.env, FORCE_COLOR: "0" },
+  },
+);
+
+try {
+  await waitForServer(baseUrl);
+
+  const chromium = await loadChromium();
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 800, height: 960 },
+    deviceScaleFactor: 2,
+    colorScheme: "dark",
+  });
+  const page = await context.newPage();
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-overview.png");
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-commit-box.png", {
+    before: async (p) => {
+      const box = p.locator(".scm-commit-box");
+      await box.scrollIntoViewIfNeeded();
+    },
+  });
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-branch-picker.png", {
+    before: async (p) => {
+      await p.locator(".scm-branch-trigger").click();
+      await p.locator(".scm-branch-dropdown").waitFor({ state: "visible" });
+    },
+    delay: 300,
+  });
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-sync-remote.png", {
+    before: async (p) => {
+      await p.locator(".scm-remote-trigger").click();
+      await p.locator(".scm-remote-menu").waitFor({ state: "visible" });
+    },
+    delay: 300,
+  });
+
+  await page.goto(`${baseUrl}/?scenario=merge-conflict`);
+  await capture(page, "scm-merge-conflict.png");
+
+  await page.goto(`${baseUrl}/?scenario=rebase-todo`);
+  await capture(page, "scm-interactive-rebase.png");
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-history.png", {
+    before: async (p) => {
+      await p.locator(".scm-history-toggle").click();
+      await p.locator(".scm-history-list").waitFor({ state: "visible" });
+    },
+    delay: 300,
+  });
+
+  await page.goto(`${baseUrl}/?scenario=dirty-worktree`);
+  await capture(page, "scm-stash.png", {
+    before: async (p) => {
+      await p.getByText("Stashes", { exact: true }).click();
+      await p
+        .locator(".scm-stash-row, .scm-stash-empty")
+        .first()
+        .waitFor({ state: "visible" });
+    },
+    delay: 300,
+  });
+
+  await page.goto(`${baseUrl}/?scenario=submodule`);
+  await capture(page, "scm-submodules.png");
+
+  await page.goto(`${baseUrl}/?view=monaco-diff`);
+  await capture(page, "scm-monaco-diff.png", { delay: 1200 });
+
+  await page.goto(`${baseUrl}/?view=settings-git`);
+  await capture(page, "scm-settings-git.png");
+
+  await browser.close();
+  console.log(`\nScreenshots saved to ${outDir}`);
+} finally {
+  vite.kill("SIGTERM");
+}
diff --git a/collab-electron/scripts/scm-screenshots/collect-data.mjs b/collab-electron/scripts/scm-screenshots/collect-data.mjs
new file mode 100644
index 00000000..c390a78d
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/collect-data.mjs
@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+/**
+ * Collect real git API payloads from fixtures for the SCM screenshot harness.
+ */
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(scriptDir, "../../..");
+const fixturesRoot = join(repoRoot, "fixtures/git");
+const outDir = join(scriptDir, "harness");
+const outFile = join(outDir, "fixture-data.json");
+
+const {
+  gitStatus,
+  gitBranches,
+  gitTags,
+  gitRemotes,
+  gitStashList,
+  gitLog,
+  gitRebaseTodoList,
+  gitSubmoduleStatus,
+  gitHasUpstream,
+  gitConfigDisplay,
+  gitGpgSignEnabled,
+} = await import("../../src/main/git-source-control.ts");
+
+const scenarios = {
+  "dirty-worktree": join(fixturesRoot, "dirty-worktree"),
+  "merge-conflict": join(fixturesRoot, "merge-conflict"),
+  "rebase-todo": join(fixturesRoot, "rebase-todo"),
+  submodule: join(fixturesRoot, "submodule"),
+};
+
+async function collect(workspacePath) {
+  const [
+    status,
+    branches,
+    tags,
+    remotes,
+    stashes,
+    log,
+    rebaseTodo,
+    submodules,
+    hasUpstream,
+    configDisplay,
+    gpgSignEnabled,
+  ] = await Promise.all([
+    gitStatus(workspacePath),
+    gitBranches(workspacePath),
+    gitTags(workspacePath),
+    gitRemotes(workspacePath),
+    gitStashList(workspacePath),
+    gitLog(workspacePath, { maxCount: 12 }),
+    gitRebaseTodoList(workspacePath).catch(() => []),
+    gitSubmoduleStatus(workspacePath).catch(() => []),
+    gitHasUpstream(workspacePath),
+    gitConfigDisplay(workspacePath),
+    gitGpgSignEnabled(workspacePath),
+  ]);
+
+  return {
+    workspacePath,
+    status,
+    branches,
+    tags,
+    remotes,
+    stashes,
+    log,
+    rebaseTodo,
+    submodules,
+    hasUpstream,
+    configDisplay,
+    gpgSignEnabled,
+    aiCanGenerate: { available: true, agent: "Claude Code" },
+  };
+}
+
+const data = {};
+for (const [name, path] of Object.entries(scenarios)) {
+  data[name] = await collect(path);
+}
+
+data.settingsGit = data["dirty-worktree"].configDisplay;
+
+data.monacoDiff = {
+  filePath: join(fixturesRoot, "dirty-worktree/src/app.ts"),
+  original: 'export function greet() {\n  return "hello";\n}\n',
+  modified:
+    'export function greet() {\n  return "hello";\n}\nconsole.log("debug");\n',
+};
+
+mkdirSync(outDir, { recursive: true });
+writeFileSync(outFile, JSON.stringify(data, null, 2));
+console.log(`Wrote ${outFile}`);
diff --git a/collab-electron/scripts/scm-screenshots/harness/SettingsGitPane.tsx b/collab-electron/scripts/scm-screenshots/harness/SettingsGitPane.tsx
new file mode 100644
index 00000000..0f0bae30
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/SettingsGitPane.tsx
@@ -0,0 +1,42 @@
+/** Minimal read-only Git settings pane for screenshots (matches settings window). */
+export function SettingsGitPane({
+  cfg,
+}: {
+  cfg: {
+    userName: string;
+    userEmail: string;
+    credentialHelper: string;
+    gpgSign: boolean;
+  };
+}) {
+  return (
+    <div className="settings-git-screenshot space-y-6 p-6">
+      <div className="space-y-1">
+        <h2 className="text-base font-semibold">Git</h2>
+        <p className="text-sm text-muted-foreground">
+          Read-only view of your system git configuration. Manage credentials
+          with your OS credential manager or{" "}
+          <code className="text-xs">git config</code> in a terminal.
+        </p>
+      </div>
+      <dl className="space-y-3 text-sm font-mono">
+        <div>
+          <dt className="text-muted-foreground">user.name</dt>
+          <dd>{cfg.userName || "—"}</dd>
+        </div>
+        <div>
+          <dt className="text-muted-foreground">user.email</dt>
+          <dd>{cfg.userEmail || "—"}</dd>
+        </div>
+        <div>
+          <dt className="text-muted-foreground">credential.helper</dt>
+          <dd>{cfg.credentialHelper || "—"}</dd>
+        </div>
+        <div>
+          <dt className="text-muted-foreground">commit.gpgsign</dt>
+          <dd>{cfg.gpgSign ? "true" : "false"}</dd>
+        </div>
+      </dl>
+    </div>
+  );
+}
diff --git a/collab-electron/scripts/scm-screenshots/harness/index.html b/collab-electron/scripts/scm-screenshots/harness/index.html
new file mode 100644
index 00000000..da33b611
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SCM Screenshot Harness</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./main.tsx"></script>
+  </body>
+</html>
diff --git a/collab-electron/scripts/scm-screenshots/harness/main.tsx b/collab-electron/scripts/scm-screenshots/harness/main.tsx
new file mode 100644
index 00000000..60cd2c14
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/main.tsx
@@ -0,0 +1,73 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { initDarkMode } from "@collab/shared/dark-mode";
+import "@collab/shared/styles/Theme.css";
+import { SourceControlView } from "@collab/components/SourceControl";
+import "@collab/components/SourceControl/SourceControl.css";
+import { DiffEditorView } from "@collab/components/DiffEditorView";
+import "@collab/components/DiffEditorView/DiffEditorView.css";
+import "./screenshot.css";
+import fixtureData from "./fixture-data.json";
+import { installMockApi } from "./mock-api";
+import { SettingsGitPane } from "./SettingsGitPane";
+import type { FixtureData } from "./types";
+
+initDarkMode();
+
+const params = new URLSearchParams(window.location.search);
+const view = params.get("view") ?? "scm";
+const scenario = params.get("scenario") ?? "dirty-worktree";
+const data = fixtureData as FixtureData;
+
+function App() {
+  if (view === "settings-git") {
+    const cfg = data.settingsGit as FixtureData["settingsGit"];
+    return (
+      <div
+        id="screenshot-root"
+        className="screenshot-frame settings-frame"
+      >
+        <SettingsGitPane cfg={cfg} />
+      </div>
+    );
+  }
+
+  if (view === "monaco-diff") {
+    const diff = data.monacoDiff;
+    return (
+      <div id="screenshot-root" className="screenshot-frame diff-frame">
+        <div className="diff-header-bar">
+          <span className="diff-title">{diff.filePath.split("/").pop()}</span>
+          <span className="diff-refs">HEAD ↔ Working Tree</span>
+        </div>
+        <DiffEditorView
+          filePath={diff.filePath}
+          original={diff.original}
+          modified={diff.modified}
+          readOnly
+          theme="dark"
+        />
+      </div>
+    );
+  }
+
+  const payload = installMockApi(data, scenario);
+  return (
+    <div id="screenshot-root" className="screenshot-frame scm-frame">
+      <SourceControlView
+        workspacePath={payload.workspacePath}
+        isActive
+        onSelectFile={() => {}}
+      />
+    </div>
+  );
+}
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Missing #root");
+
+createRoot(root).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);
diff --git a/collab-electron/scripts/scm-screenshots/harness/mock-api.ts b/collab-electron/scripts/scm-screenshots/harness/mock-api.ts
new file mode 100644
index 00000000..78676cb3
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/mock-api.ts
@@ -0,0 +1,102 @@
+import type { FixtureData, ScenarioPayload } from "./types";
+
+const noop = () => undefined;
+const noopUnsub = () => noop;
+const asyncVoid = async () => {};
+const asyncNull = async () => null;
+
+function buildMock(payload: ScenarioPayload) {
+  const { status, workspacePath } = payload;
+
+  return {
+    gitStatus: async () => status,
+    gitHasUpstream: async () => payload.hasUpstream,
+    gitBranches: async () => payload.branches,
+    gitTags: async () => payload.tags,
+    gitRemotes: async () => payload.remotes,
+    gitStashList: async () => payload.stashes,
+    gitLog: async () => payload.log,
+    gitLogFiles: async () => [],
+    gitRebaseTodoList: async () => payload.rebaseTodo,
+    gitRebaseTodoWrite: asyncVoid,
+    gitSubmoduleStatus: async () => payload.submodules,
+    gitGpgSignEnabled: async () => payload.gpgSignEnabled,
+    gitConfigDisplay: async () => payload.configDisplay,
+    aiCanGenerate: async () => payload.aiCanGenerate,
+    gitStage: asyncVoid,
+    gitUnstage: asyncVoid,
+    gitStageAll: asyncVoid,
+    gitUnstageAll: asyncVoid,
+    gitDiscard: asyncVoid,
+    gitDiscardAll: asyncVoid,
+    gitCommit: async () => ({ hash: "abc1234" }),
+    gitPush: asyncVoid,
+    gitPull: asyncVoid,
+    gitFetch: asyncVoid,
+    gitInit: asyncVoid,
+    gitCheckout: asyncVoid,
+    gitCreateBranch: asyncVoid,
+    gitDeleteBranch: asyncVoid,
+    gitStashSave: asyncVoid,
+    gitStashPop: asyncVoid,
+    gitStashApply: asyncVoid,
+    gitStashDrop: asyncVoid,
+    gitMergeContinue: asyncVoid,
+    gitMergeAbort: asyncVoid,
+    gitCherryPickContinue: asyncVoid,
+    gitCherryPickAbort: asyncVoid,
+    gitRevertContinue: asyncVoid,
+    gitRevertAbort: asyncVoid,
+    gitRebaseContinue: asyncVoid,
+    gitRebaseAbort: asyncVoid,
+    gitRebaseSkip: asyncVoid,
+    gitCheckoutOurs: asyncVoid,
+    gitCheckoutTheirs: asyncVoid,
+    gitAdd: asyncVoid,
+    gitMerge: asyncVoid,
+    gitRebase: asyncVoid,
+    gitPushSetUpstream: asyncVoid,
+    gitGenerateCommitMessage: async () => ({
+      message: "feat: example commit message",
+      model: "fixture",
+    }),
+    gitSubmoduleUpdate: asyncVoid,
+    gitWorktreeList: async () => [],
+    gitWorktreeAdd: asyncVoid,
+    gitRemoteAdd: asyncVoid,
+    gitRemoteRemove: asyncVoid,
+    gitClone: async () => ({ path: workspacePath }),
+    gitRevertCommit: asyncVoid,
+    gitCherryPick: asyncVoid,
+    gitReset: asyncVoid,
+    gitReadBlob: async (_ws: string, ref: string) =>
+      ref === "HEAD" ? payload.monacoOriginal ?? "" : payload.monacoModified ?? "",
+    gitDiff: async () => "",
+    openGitDiff: noop,
+    openFolder: asyncNull,
+    revealInFinder: noop,
+    showContextMenu: async () => null,
+    createGraphTile: noop,
+    startReplay: noop,
+    onFsChanged: noopUnsub,
+    getConfig: async () => ({ workspaces: [workspacePath] }),
+    confirm: (msg: string) => window.confirm(msg),
+  };
+}
+
+export function installMockApi(
+  allData: FixtureData,
+  scenario: string,
+): ScenarioPayload {
+  const payload = allData[scenario];
+  if (!payload) {
+    throw new Error(`Unknown scenario: ${scenario}`);
+  }
+  (window as unknown as { api: ReturnType<typeof buildMock> }).api =
+    buildMock({
+      ...payload,
+      monacoOriginal: allData.monacoDiff?.original,
+      monacoModified: allData.monacoDiff?.modified,
+    });
+  return payload;
+}
diff --git a/collab-electron/scripts/scm-screenshots/harness/screenshot.css b/collab-electron/scripts/scm-screenshots/harness/screenshot.css
new file mode 100644
index 00000000..21dc34bb
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/screenshot.css
@@ -0,0 +1,73 @@
+html,
+body,
+#root {
+  margin: 0;
+  height: 100%;
+  background: var(--background);
+  color: var(--foreground);
+  font-family: system-ui, -apple-system, sans-serif;
+}
+
+.screenshot-frame {
+  height: 100%;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+
+.scm-frame {
+  width: 360px;
+  height: 920px;
+  border-right: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+}
+
+.scm-frame .scm-container {
+  height: 100%;
+}
+
+.settings-frame {
+  width: 520px;
+  height: 420px;
+}
+
+.settings-git-screenshot .text-muted-foreground {
+  color: var(--muted-foreground);
+}
+
+.settings-git-screenshot .font-semibold {
+  font-weight: 600;
+}
+
+.settings-git-screenshot .font-mono {
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+}
+
+.diff-frame {
+  width: 720px;
+  height: 480px;
+  display: flex;
+  flex-direction: column;
+}
+
+.diff-header-bar {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 8px 12px;
+  font-size: 12px;
+  border-bottom: 1px solid color-mix(in srgb, var(--border) 50%, transparent);
+  flex-shrink: 0;
+}
+
+.diff-title {
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-weight: 600;
+}
+
+.diff-refs {
+  color: var(--muted-foreground);
+}
+
+.diff-frame .diff-editor-host {
+  flex: 1;
+  min-height: 0;
+}
diff --git a/collab-electron/scripts/scm-screenshots/harness/types.ts b/collab-electron/scripts/scm-screenshots/harness/types.ts
new file mode 100644
index 00000000..c3a281a1
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/types.ts
@@ -0,0 +1,41 @@
+import type {
+  GitBranch,
+  GitConfigDisplay,
+  GitLogEntry,
+  GitRebaseTodoItem,
+  GitRemote,
+  GitStash,
+  GitStatusResult,
+  GitSubmodule,
+  GitTag,
+} from "@collab/shared/git-types";
+
+export interface ScenarioPayload {
+  workspacePath: string;
+  status: GitStatusResult;
+  branches: GitBranch[];
+  tags: GitTag[];
+  remotes: GitRemote[];
+  stashes: GitStash[];
+  log: GitLogEntry[];
+  rebaseTodo: GitRebaseTodoItem[];
+  submodules: GitSubmodule[];
+  hasUpstream: boolean;
+  configDisplay: GitConfigDisplay;
+  gpgSignEnabled: boolean;
+  aiCanGenerate: { available: boolean; agent?: string };
+  monacoOriginal?: string;
+  monacoModified?: string;
+}
+
+export interface FixtureData {
+  [key: string]: ScenarioPayload | GitConfigDisplay | MonacoDiffPayload;
+  settingsGit: GitConfigDisplay;
+  monacoDiff: MonacoDiffPayload;
+}
+
+export interface MonacoDiffPayload {
+  filePath: string;
+  original: string;
+  modified: string;
+}
diff --git a/collab-electron/scripts/scm-screenshots/harness/vite.config.ts b/collab-electron/scripts/scm-screenshots/harness/vite.config.ts
new file mode 100644
index 00000000..c2d8e92e
--- /dev/null
+++ b/collab-electron/scripts/scm-screenshots/harness/vite.config.ts
@@ -0,0 +1,25 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { resolve } from "node:path";
+
+const collabElectron = resolve(__dirname, "../../..");
+
+export default defineConfig({
+  root: resolve(__dirname),
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@collab/shared": resolve(collabElectron, "packages/shared/src"),
+      "@collab/theme": resolve(collabElectron, "packages/theme/src"),
+      "@collab/components": resolve(collabElectron, "packages/components/src"),
+    },
+  },
+  build: {
+    outDir: resolve(__dirname, "dist"),
+    emptyOutDir: true,
+  },
+  server: {
+    port: 5199,
+    strictPort: true,
+  },
+});
diff --git a/collab-electron/src/main/ai-commit.ts b/collab-electron/src/main/ai-commit.ts
index 49acca6c..d1a147cb 100644
--- a/collab-electron/src/main/ai-commit.ts
+++ b/collab-electron/src/main/ai-commit.ts
@@ -125,21 +125,17 @@ export async function generateCommitMessageViaCli(
 
   switch (agent) {
     case "claude":
-      result = await runCliAgent("claude", ["-p", fullPrompt], "");
+      result = await runCliAgent("claude", ["-p"], fullPrompt);
       break;
     case "codex":
       result = await runCliAgent(
         "codex",
-        ["--quiet", "--prompt", fullPrompt],
-        "",
+        ["--quiet"],
+        fullPrompt,
       );
       break;
     case "gemini":
-      result = await runCliAgent(
-        "gemini",
-        ["--prompt", fullPrompt],
-        "",
-      );
+      result = await runCliAgent("gemini", [], fullPrompt);
       break;
   }
 
diff --git a/collab-electron/src/main/git-source-control.fixture.test.ts b/collab-electron/src/main/git-source-control.fixture.test.ts
new file mode 100644
index 00000000..d1dc25c5
--- /dev/null
+++ b/collab-electron/src/main/git-source-control.fixture.test.ts
@@ -0,0 +1,210 @@
+/**
+ * Smoke tests for git-source-control against repo-root fixtures.
+ * Run: bun test src/main/git-source-control.fixture.test.ts
+ * Prerequisite: ./fixtures/git/setup-all.sh from repository root.
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../../",
+);
+const FIXTURES = join(REPO_ROOT, "fixtures/git");
+
+const {
+  isGitRepo,
+  gitStatus,
+  gitRepoState,
+  gitStage,
+  gitUnstage,
+  gitCommit,
+  gitBranches,
+  gitTags,
+  gitRemotes,
+  gitStashList,
+  gitLog,
+  gitRebaseTodoList,
+  gitSubmoduleStatus,
+  gitWorktreeList,
+  gitDiff,
+  gitHasUpstream,
+} = await import("./git-source-control.ts");
+
+function fixturePath(name: string): string {
+  const p = join(FIXTURES, name);
+  if (!existsSync(p)) {
+    throw new Error(
+      `Missing fixture ${name}. Run ./fixtures/git/setup-all.sh from repo root.`,
+    );
+  }
+  return p;
+}
+
+describe("fixture repos exist", () => {
+  test("setup-all outputs are present", () => {
+    for (const name of [
+      "dirty-worktree",
+      "merge-conflict",
+      "rebase-todo",
+      "submodule",
+    ]) {
+      expect(isGitRepo(fixturePath(name))).toBe(true);
+    }
+  });
+});
+
+describe("dirty-worktree", () => {
+  const cwd = () => fixturePath("dirty-worktree");
+
+  test("gitStatus: staged, unstaged, untracked, ahead", async () => {
+    const s = await gitStatus(cwd());
+    expect(s.isGitRepo).toBe(true);
+    expect(s.branch).toBe("main");
+    expect(s.ahead).toBe(2);
+    expect(s.staged.some((f) => f.path === "README.md")).toBe(true);
+    expect(s.unstaged.some((f) => f.path === "src/app.ts")).toBe(true);
+    expect(s.untracked.some((f) => f.path === "notes.txt")).toBe(true);
+    expect(s.repoState).toBe("clean");
+  });
+
+  test("gitRepoState: clean", () => {
+    expect(gitRepoState(cwd())).toBe("clean");
+  });
+
+  test("gitBranches includes main and feature/login", async () => {
+    const branches = await gitBranches(cwd());
+    const names = branches.map((b) => b.name);
+    expect(names).toContain("main");
+    expect(names).toContain("feature/login");
+  });
+
+  test("gitTags lists v1.0.0", async () => {
+    const tags = await gitTags(cwd());
+    expect(tags.some((t) => t.name === "v1.0.0")).toBe(true);
+  });
+
+  test("gitRemotes lists origin", async () => {
+    const remotes = await gitRemotes(cwd());
+    expect(remotes.some((r) => r.name === "origin")).toBe(true);
+  });
+
+  test("gitStashList has entries", async () => {
+    const stashes = await gitStashList(cwd());
+    expect(stashes.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("gitHasUpstream on main", async () => {
+    expect(await gitHasUpstream(cwd())).toBe(true);
+  });
+
+  test("gitLog returns commits", async () => {
+    const log = await gitLog(cwd(), { limit: 5 });
+    expect(log.length).toBeGreaterThan(0);
+    expect(log[0]?.hash).toMatch(/^[a-f0-9]{40}$/);
+  });
+
+  test("gitDiff on unstaged file", async () => {
+    const diff = await gitDiff(cwd(), "src/app.ts", false);
+    expect(diff.length).toBeGreaterThan(0);
+  });
+});
+
+describe("merge-conflict", () => {
+  const cwd = () => fixturePath("merge-conflict");
+
+  test("gitRepoState: merging", () => {
+    expect(gitRepoState(cwd())).toBe("merging");
+  });
+
+  test("gitStatus reports unmerged base.txt", async () => {
+    const s = await gitStatus(cwd());
+    expect(s.repoState).toBe("merging");
+    expect(s.merge.some((f) => f.path === "base.txt")).toBe(true);
+  });
+});
+
+describe("rebase-todo", () => {
+  const cwd = () => fixturePath("rebase-todo");
+
+  test("gitRepoState: interactive-rebase", () => {
+    expect(gitRepoState(cwd())).toBe("interactive-rebase");
+  });
+
+  test("gitRebaseTodoList parses todo (backup when paused at break)", async () => {
+    const items = await gitRebaseTodoList(cwd());
+    expect(items.length).toBe(2);
+    expect(items.every((i) => i.action === "pick")).toBe(true);
+    expect(items[0]?.hash).toMatch(/^[a-f0-9]+$/);
+    expect(items.some((i) => i.subject.includes("feature: v3"))).toBe(true);
+  });
+});
+
+describe("submodule", () => {
+  const cwd = () => fixturePath("submodule");
+
+  test("gitSubmoduleStatus lists child", async () => {
+    const subs = await gitSubmoduleStatus(cwd());
+    expect(subs.some((s) => s.path === "child")).toBe(true);
+  });
+
+  test("gitWorktreeList has main worktree", async () => {
+    const trees = await gitWorktreeList(cwd());
+    expect(trees.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe("mutating git ops (temp repo)", () => {
+  let tmp: string;
+
+  async function gitInRepo(args: string[]): Promise<void> {
+    const proc = Bun.spawn(["git", ...args], {
+      cwd: tmp,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const code = await proc.exited;
+    if (code !== 0) {
+      const err = await new Response(proc.stderr).text();
+      throw new Error(err.trim() || `git ${args.join(" ")} failed`);
+    }
+  }
+
+  beforeEach(async () => {
+    tmp = mkdtempSync(join(tmpdir(), "git-scm-smoke-"));
+    await gitInRepo(["init", "-b", "main"]);
+    await gitInRepo(["config", "user.email", "test@example.com"]);
+    await gitInRepo(["config", "user.name", "SCM Smoke"]);
+    const f = join(tmp, "file.txt");
+    await Bun.write(f, "v1\n");
+    await gitInRepo(["add", "file.txt"]);
+    await gitInRepo(["commit", "-m", "initial"]);
+    await Bun.write(f, "v2\n");
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("stage, unstage, commit", async () => {
+    let s = await gitStatus(tmp);
+    expect(s.unstaged.some((f) => f.path === "file.txt")).toBe(true);
+
+    await gitStage(tmp, ["file.txt"]);
+    s = await gitStatus(tmp);
+    expect(s.staged.some((f) => f.path === "file.txt")).toBe(true);
+
+    await gitUnstage(tmp, ["file.txt"]);
+    s = await gitStatus(tmp);
+    expect(s.unstaged.some((f) => f.path === "file.txt")).toBe(true);
+
+    await gitStage(tmp, ["file.txt"]);
+    await gitCommit(tmp, "second commit");
+    s = await gitStatus(tmp);
+    expect(s.staged).toHaveLength(0);
+    expect(s.unstaged).toHaveLength(0);
+  });
+});
diff --git a/collab-electron/src/main/git-source-control.ts b/collab-electron/src/main/git-source-control.ts
index 3acd6c34..65e11d84 100644
--- a/collab-electron/src/main/git-source-control.ts
+++ b/collab-electron/src/main/git-source-control.ts
@@ -1,14 +1,31 @@
 import { execFile } from "node:child_process";
-import { accessSync } from "node:fs";
-import { join } from "node:path";
+import {
+  accessSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, join } from "node:path";
 import { promisify } from "node:util";
 import type {
   GitChangeStatus,
+  GitCloneOptions,
+  GitCloneResult,
+  GitConfigDisplay,
+  GitDiffHunk,
   GitFileChange,
+  GitLogEntry,
+  GitLogFileChange,
+  GitRebaseAction,
+  GitRebaseTodoItem,
+  GitRepoState,
   GitStatusResult,
   GitBranch,
   GitRemote,
   GitStash,
+  GitSubmodule,
+  GitTag,
+  GitWorktree,
 } from "@collab/shared/git-types";
 
 const execFileAsync = promisify(execFile);
@@ -18,11 +35,18 @@ async function git(
   args: string[],
   cwd: string,
 ): Promise<string> {
-  const { stdout } = await execFileAsync("git", args, {
-    cwd,
-    maxBuffer: MAX_BUFFER,
-  });
-  return stdout;
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      maxBuffer: MAX_BUFFER,
+    });
+    return stdout;
+  } catch (err) {
+    const execErr = err as { stderr?: string; message?: string };
+    const msg = (execErr.stderr ?? execErr.message ?? "Git command failed")
+      .trim();
+    throw new Error(msg);
+  }
 }
 
 export function isGitRepo(cwd: string): boolean {
@@ -70,12 +94,23 @@ export async function gitStatus(
       staged: [],
       unstaged: [],
       untracked: [],
+      merge: [],
       isGitRepo: false,
+      hasCommits: false,
+      repoState: "clean",
     };
   }
 
+  let hasCommits = false;
+  try {
+    await git(["rev-parse", "HEAD"], cwd);
+    hasCommits = true;
+  } catch {
+    hasCommits = false;
+  }
+
   const raw = await git(
-    ["status", "--porcelain=v2", "--branch", "-uall"],
+    ["status", "--porcelain=v2", "--branch", "-uall", "-z"],
     cwd,
   );
 
@@ -86,8 +121,9 @@ export async function gitStatus(
   const staged: GitFileChange[] = [];
   const unstaged: GitFileChange[] = [];
   const untracked: GitFileChange[] = [];
+  const merge: GitFileChange[] = [];
 
-  for (const line of raw.split("\n")) {
+  for (const line of raw.split("\0")) {
     if (!line) continue;
 
     // Header lines
@@ -113,12 +149,11 @@ export async function gitStatus(
       });
     }
 
-    // Unmerged
+    // Unmerged (merge conflicts)
     else if (line.startsWith("u ")) {
       const parts = line.split(" ");
-      // u XY sub m1 m2 m3 mW h1 h2 h3 path
       const path = parts.slice(10).join(" ");
-      unstaged.push({
+      merge.push({
         path,
         absPath: join(cwd, path),
         status: "U",
@@ -179,18 +214,53 @@ export async function gitStatus(
     }
   }
 
+  const repoState = gitRepoState(cwd);
+
+  const allPaths = [
+    ...staged,
+    ...unstaged,
+    ...untracked,
+    ...merge,
+  ].map((f) => f.path);
+  const lfsPaths = await gitPathsUsingLfs(cwd, [...new Set(allPaths)]);
+  const withLfs = (files: GitFileChange[]) =>
+    files.map((f) => (lfsPaths.has(f.path) ? { ...f, lfs: true } : f));
+
   return {
     branch,
     upstream,
     ahead,
     behind,
-    staged,
-    unstaged,
-    untracked,
+    staged: withLfs(staged),
+    unstaged: withLfs(unstaged),
+    untracked: withLfs(untracked),
+    merge: withLfs(merge),
     isGitRepo: true,
+    hasCommits,
+    repoState,
   };
 }
 
+export function gitRepoState(cwd: string): GitRepoState {
+  const gitDir = join(cwd, ".git");
+  if (!existsSync(gitDir)) return "clean";
+
+  if (existsSync(join(gitDir, "MERGE_HEAD"))) return "merging";
+  if (existsSync(join(gitDir, "CHERRY_PICK_HEAD"))) return "cherry-picking";
+  if (existsSync(join(gitDir, "REVERT_HEAD"))) return "reverting";
+
+  const rebaseMerge = join(gitDir, "rebase-merge");
+  const rebaseApply = join(gitDir, "rebase-apply");
+  if (existsSync(rebaseMerge) || existsSync(rebaseApply)) {
+    if (existsSync(join(rebaseMerge, "git-rebase-todo"))) {
+      return "interactive-rebase";
+    }
+    return "rebasing";
+  }
+
+  return "clean";
+}
+
 function mapStatus(char: string): GitChangeStatus {
   switch (char) {
     case "M":
@@ -252,17 +322,21 @@ export async function gitDiscard(
 
   // Separate tracked (checkout) vs untracked (clean) files
   const statusRaw = await git(
-    ["status", "--porcelain", "--", ...paths],
+    ["status", "--porcelain", "-z", "--", ...paths],
     cwd,
   );
 
   const untrackedPaths: string[] = [];
   const trackedPaths: string[] = [];
 
-  for (const line of statusRaw.split("\n")) {
-    if (!line) continue;
-    const status = line.slice(0, 2);
-    const filePath = line.slice(3);
+  for (const entry of statusRaw.split("\0")) {
+    if (!entry) continue;
+    const status = entry.slice(0, 2);
+    let filePath = entry.slice(3);
+    const arrow = filePath.indexOf(" -> ");
+    if (arrow !== -1) {
+      filePath = filePath.slice(arrow + 4);
+    }
     if (status === "??") {
       untrackedPaths.push(filePath);
     } else {
@@ -287,12 +361,16 @@ export async function gitDiscardAll(cwd: string): Promise<void> {
 export async function gitCommit(
   cwd: string,
   message: string,
+  options?: { amend?: boolean; sign?: boolean },
 ): Promise<{ hash: string }> {
   assertGitRepo(cwd);
   if (!message.trim()) {
     throw new Error("Commit message cannot be empty");
   }
-  const output = await git(["commit", "-m", message], cwd);
+  const args = ["commit", "-m", message];
+  if (options?.amend) args.push("--amend");
+  if (options?.sign) args.push("-S");
+  const output = await git(args, cwd);
   // Extract short hash from output like "[branch abc1234] message"
   const match = output.match(/\[.+\s+([a-f0-9]+)\]/);
   const hash = match?.[1] ?? "";
@@ -323,9 +401,17 @@ export async function gitDiffCached(cwd: string): Promise<string> {
 
 // -- Push / Pull / Fetch --
 
-export async function gitPush(cwd: string): Promise<void> {
+export async function gitInit(cwd: string): Promise<void> {
+  await git(["init"], cwd);
+}
+
+export async function gitPush(
+  cwd: string,
+  remote?: string,
+): Promise<void> {
   assertGitRepo(cwd);
-  await git(["push"], cwd);
+  if (remote) await git(["push", remote], cwd);
+  else await git(["push"], cwd);
 }
 
 export async function gitPushSetUpstream(
@@ -337,14 +423,22 @@ export async function gitPushSetUpstream(
   await git(["push", "-u", remote, branch], cwd);
 }
 
-export async function gitPull(cwd: string): Promise<void> {
+export async function gitPull(
+  cwd: string,
+  remote?: string,
+): Promise<void> {
   assertGitRepo(cwd);
-  await git(["pull"], cwd);
+  if (remote) await git(["pull", remote], cwd);
+  else await git(["pull"], cwd);
 }
 
-export async function gitFetch(cwd: string): Promise<void> {
+export async function gitFetch(
+  cwd: string,
+  remote?: string,
+): Promise<void> {
   assertGitRepo(cwd);
-  await git(["fetch", "--all"], cwd);
+  if (remote) await git(["fetch", remote], cwd);
+  else await git(["fetch", "--all"], cwd);
 }
 
 export async function gitRemotes(
@@ -371,7 +465,10 @@ export async function gitRemotes(
   return Array.from(map.values());
 }
 
-export async function gitHasUpstream(cwd: string): Promise<boolean> {
+export async function gitHasUpstream(
+  cwd: string,
+  _remote?: string,
+): Promise<boolean> {
   assertGitRepo(cwd);
   try {
     await git(
@@ -392,9 +489,10 @@ export async function gitBranches(
   assertGitRepo(cwd);
   const raw = await git(
     [
-      "branch",
-      "-a",
-      "--format=%(refname:short)|%(HEAD)|%(upstream:short)",
+      "for-each-ref",
+      "--format=%(refname:short)|%(refname)|%(HEAD)|%(upstream:short)",
+      "refs/heads",
+      "refs/remotes",
     ],
     cwd,
   );
@@ -404,9 +502,10 @@ export async function gitBranches(
     if (!line.trim()) continue;
     const parts = line.split("|");
     const name = parts[0]!.trim();
-    const isCurrent = parts[1]?.trim() === "*";
-    const upstream = parts[2]?.trim() || undefined;
-    const isRemote = name.startsWith("origin/") || name.includes("/");
+    const refname = parts[1]!.trim();
+    const isCurrent = parts[2]?.trim() === "*";
+    const upstream = parts[3]?.trim() || undefined;
+    const isRemote = refname.startsWith("refs/remotes/");
 
     // Skip HEAD pointers like "origin/HEAD"
     if (name.endsWith("/HEAD")) continue;
@@ -444,6 +543,16 @@ export async function gitDeleteBranch(
   await git(["branch", "-d", name], cwd);
 }
 
+export async function gitTags(cwd: string): Promise<GitTag[]> {
+  assertGitRepo(cwd);
+  const raw = await git(["tag", "-l"], cwd);
+  return raw
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((name) => ({ name }));
+}
+
 // -- Stash operations --
 
 export async function gitStashSave(
@@ -520,12 +629,676 @@ export async function gitShowFile(
   filePath: string,
 ): Promise<string> {
   assertGitRepo(cwd);
-  // ref = "HEAD" for committed, "" or ":" for index
-  const spec = ref ? `${ref}:${filePath}` : `:${filePath}`;
+  // ref = "HEAD", "index", ":1:path" conflict stage, or empty for index
+  let spec: string;
+  if (ref.startsWith(":")) {
+    spec = `${ref}${filePath}`;
+  } else if (ref === "index" || ref === "") {
+    spec = `:${filePath}`;
+  } else if (ref === "working") {
+    const { readFile } = await import("node:fs/promises");
+    try {
+      return await readFile(join(cwd, filePath), "utf8");
+    } catch {
+      return "";
+    }
+  } else {
+    spec = `${ref}:${filePath}`;
+  }
   try {
     return await git(["show", spec], cwd);
   } catch {
-    // File doesn't exist at that ref (new file)
     return "";
   }
 }
+
+// -- Read blob / diff refs --
+
+export async function gitReadBlob(
+  cwd: string,
+  ref: string,
+  filePath: string,
+): Promise<string> {
+  return gitShowFile(cwd, ref, filePath);
+}
+
+export async function gitDiffRefs(
+  cwd: string,
+  leftRef: string,
+  rightRef: string,
+  filePath: string,
+): Promise<string> {
+  assertGitRepo(cwd);
+  const args = ["diff"];
+  if (leftRef && rightRef) {
+    args.push(`${leftRef}..${rightRef}`);
+  }
+  args.push("--", filePath);
+  try {
+    return await git(args, cwd);
+  } catch {
+    return "";
+  }
+}
+
+// -- Clone --
+
+function repoNameFromCloneUrl(url: string): string {
+  const cleaned = url.replace(/\.git$/, "").replace(/\/$/, "");
+  const parts = cleaned.split(/[/:]/).filter(Boolean);
+  return parts[parts.length - 1] || "repository";
+}
+
+export async function gitClone(
+  url: string,
+  parentDir: string,
+  options?: GitCloneOptions,
+): Promise<GitCloneResult> {
+  const folderName = repoNameFromCloneUrl(url);
+  const target = join(parentDir, folderName);
+  const args = ["clone"];
+  if (options?.depth) args.push("--depth", String(options.depth));
+  if (options?.branch) args.push("--branch", options.branch);
+  args.push(url, target);
+  await git(args, parentDir);
+  return { path: target };
+}
+
+// -- Remote CRUD --
+
+export async function gitRemoteAdd(
+  cwd: string,
+  name: string,
+  url: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["remote", "add", name, url], cwd);
+}
+
+export async function gitRemoteRemove(
+  cwd: string,
+  name: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["remote", "remove", name], cwd);
+}
+
+export async function gitRemoteRename(
+  cwd: string,
+  oldName: string,
+  newName: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["remote", "rename", oldName, newName], cwd);
+}
+
+export async function gitRemoteSetUrl(
+  cwd: string,
+  name: string,
+  url: string,
+  push = false,
+): Promise<void> {
+  assertGitRepo(cwd);
+  const args = ["remote", "set-url"];
+  if (push) args.push("--push");
+  args.push(name, url);
+  await git(args, cwd);
+}
+
+// -- Conflict resolution --
+
+export async function gitCheckoutOurs(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["checkout", "--ours", "--", ...paths], cwd);
+}
+
+export async function gitCheckoutTheirs(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["checkout", "--theirs", "--", ...paths], cwd);
+}
+
+export async function gitAdd(
+  cwd: string,
+  paths: string[],
+): Promise<void> {
+  await gitStage(cwd, paths);
+}
+
+export async function gitMergeAbort(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["merge", "--abort"], cwd);
+}
+
+export async function gitMergeContinue(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["merge", "--continue"], cwd);
+}
+
+export async function gitCherryPickAbort(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["cherry-pick", "--abort"], cwd);
+}
+
+export async function gitCherryPickContinue(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["cherry-pick", "--continue"], cwd);
+}
+
+export async function gitRevertAbort(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["revert", "--abort"], cwd);
+}
+
+export async function gitRevertContinue(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["revert", "--continue"], cwd);
+}
+
+// -- History --
+
+export async function gitLog(
+  cwd: string,
+  options?: { maxCount?: number; ref?: string },
+): Promise<GitLogEntry[]> {
+  assertGitRepo(cwd);
+  const max = options?.maxCount ?? 50;
+  const ref = options?.ref ?? "HEAD";
+  const raw = await git(
+    [
+      "log",
+      ref,
+      `-n${max}`,
+      "--format=%H|%h|%s|%an|%ai|%P",
+    ],
+    cwd,
+  );
+  const entries: GitLogEntry[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("|");
+    if (parts.length < 6) continue;
+    const parents = parts[5]!.trim()
+      ? parts[5]!.trim().split(" ")
+      : [];
+    entries.push({
+      hash: parts[0]!,
+      shortHash: parts[1]!,
+      subject: parts[2]!,
+      author: parts[3]!,
+      date: parts[4]!,
+      parents,
+    });
+  }
+  return entries;
+}
+
+export async function gitLogFiles(
+  cwd: string,
+  hash: string,
+): Promise<GitLogFileChange[]> {
+  assertGitRepo(cwd);
+  const raw = await git(
+    ["show", "--name-status", "--format=", hash],
+    cwd,
+  );
+  const files: GitLogFileChange[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("\t");
+    if (parts.length < 2) continue;
+    files.push({ status: parts[0]!, path: parts[1]! });
+  }
+  return files;
+}
+
+export async function gitRevert(
+  cwd: string,
+  hash: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["revert", "--no-edit", hash], cwd);
+}
+
+export async function gitCherryPick(
+  cwd: string,
+  hash: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["cherry-pick", hash], cwd);
+}
+
+export async function gitReset(
+  cwd: string,
+  mode: "soft" | "mixed" | "hard",
+  ref: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["reset", `--${mode}`, ref], cwd);
+}
+
+// -- Merge / rebase --
+
+export async function gitMerge(
+  cwd: string,
+  branch: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["merge", branch], cwd);
+}
+
+export async function gitRebase(
+  cwd: string,
+  onto: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["rebase", onto], cwd);
+}
+
+export async function gitRebaseContinue(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["rebase", "--continue"], cwd);
+}
+
+export async function gitRebaseAbort(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["rebase", "--abort"], cwd);
+}
+
+export async function gitRebaseSkip(cwd: string): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["rebase", "--skip"], cwd);
+}
+
+const REBASE_ACTIONS = new Set<GitRebaseAction>([
+  "pick",
+  "reword",
+  "edit",
+  "squash",
+  "fixup",
+  "drop",
+]);
+
+function parseRebaseTodoLines(raw: string): GitRebaseTodoItem[] {
+  const items: GitRebaseTodoItem[] = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(
+      /^(pick|reword|edit|squash|fixup|drop)\s+([a-f0-9]+)\s*(.*)$/i,
+    );
+    if (!match) continue;
+    const action = match[1]!.toLowerCase() as GitRebaseAction;
+    if (!REBASE_ACTIONS.has(action)) continue;
+    items.push({
+      action,
+      hash: match[2]!,
+      subject: match[3]?.trim() ?? "",
+      raw: line,
+    });
+  }
+  return items;
+}
+
+export async function gitRebaseTodoList(
+  cwd: string,
+): Promise<GitRebaseTodoItem[]> {
+  assertGitRepo(cwd);
+  const rebaseDir = join(cwd, ".git", "rebase-merge");
+  const todoPath = join(rebaseDir, "git-rebase-todo");
+  if (!existsSync(todoPath)) return [];
+
+  let raw = readFileSync(todoPath, "utf8");
+  let items = parseRebaseTodoLines(raw);
+
+  // Paused at `break` (or similar): git empties git-rebase-todo; remaining picks
+  // stay in git-rebase-todo.backup until continue.
+  if (items.length === 0) {
+    const backupPath = join(rebaseDir, "git-rebase-todo.backup");
+    if (existsSync(backupPath)) {
+      raw = readFileSync(backupPath, "utf8");
+      items = parseRebaseTodoLines(raw);
+    }
+  }
+
+  return items;
+}
+
+export async function gitRebaseTodoWrite(
+  cwd: string,
+  items: GitRebaseTodoItem[],
+): Promise<void> {
+  assertGitRepo(cwd);
+  const todoPath = join(cwd, ".git", "rebase-merge", "git-rebase-todo");
+  if (!existsSync(todoPath)) {
+    throw new Error("No interactive rebase in progress");
+  }
+  const existing = readFileSync(todoPath, "utf8");
+  const headerLines: string[] = [];
+  for (const line of existing.split("\n")) {
+    const t = line.trim();
+    if (!t || t.startsWith("#")) headerLines.push(line);
+    else break;
+  }
+  const body = items
+    .map((item) => `${item.action} ${item.hash} ${item.subject}`.trimEnd())
+    .join("\n");
+  const rest = existing
+    .split("\n")
+    .filter((line) => {
+      const t = line.trim();
+      return (
+        t &&
+        !t.startsWith("#") &&
+        !/^(pick|reword|edit|squash|fixup|drop)\s/i.test(t)
+      );
+    })
+    .join("\n");
+  const output = [headerLines.join("\n"), body, rest]
+    .filter(Boolean)
+    .join("\n");
+  writeFileSync(todoPath, output.endsWith("\n") ? output : `${output}\n`);
+}
+
+export async function gitRebaseStartInteractive(
+  cwd: string,
+  onto: string | null,
+  count: number,
+): Promise<void> {
+  assertGitRepo(cwd);
+  if (onto) {
+    await git(["rebase", "-i", onto], cwd);
+  } else {
+    await git(["rebase", "-i", `HEAD~${count}`], cwd);
+  }
+}
+
+// -- Submodules --
+
+export async function gitSubmoduleStatus(
+  cwd: string,
+): Promise<GitSubmodule[]> {
+  assertGitRepo(cwd);
+  if (!existsSync(join(cwd, ".gitmodules"))) return [];
+  let raw: string;
+  try {
+    raw = await git(
+      ["submodule", "status", "--recursive"],
+      cwd,
+    );
+  } catch {
+    return [];
+  }
+  const subs: GitSubmodule[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const match = line.match(
+      /^([ +\-])([a-f0-9]+)\s+(\S+)(?:\s+\((.+)\))?/,
+    );
+    if (!match) continue;
+    const dirty = match[1] === "+" || match[1] === "U";
+    const path = match[3]!;
+    let url = "";
+    let branch: string | undefined;
+    try {
+      url = (
+        await git(["config", "-f", ".gitmodules", "--get", `submodule.${path}.url`], cwd)
+      ).trim();
+      branch = (
+        await git(
+          ["config", "-f", ".gitmodules", "--get", `submodule.${path}.branch`],
+          cwd,
+        )
+      ).trim() || undefined;
+    } catch {
+      /* optional */
+    }
+    subs.push({
+      path,
+      url,
+      branch,
+      commit: match[2]!,
+      dirty,
+    });
+  }
+  return subs;
+}
+
+export async function gitSubmoduleUpdate(
+  cwd: string,
+  init?: boolean,
+  recursive?: boolean,
+): Promise<void> {
+  assertGitRepo(cwd);
+  const args = ["submodule", "update"];
+  if (init) args.push("--init");
+  if (recursive) args.push("--recursive");
+  await git(args, cwd);
+}
+
+// -- Worktrees --
+
+export async function gitWorktreeList(
+  cwd: string,
+): Promise<GitWorktree[]> {
+  assertGitRepo(cwd);
+  const raw = await git(["worktree", "list", "--porcelain"], cwd);
+  const trees: GitWorktree[] = [];
+  let current: Partial<GitWorktree> = {};
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) trees.push(current as GitWorktree);
+      current = {
+        path: line.slice("worktree ".length),
+        branch: "",
+        head: "",
+        bare: false,
+        locked: false,
+      };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line
+        .slice("branch ".length)
+        .replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.bare = true;
+    } else if (line.startsWith("locked")) {
+      current.locked = true;
+    }
+  }
+  if (current.path) trees.push(current as GitWorktree);
+  return trees;
+}
+
+export async function gitWorktreeAdd(
+  cwd: string,
+  wtPath: string,
+  branch: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["worktree", "add", wtPath, branch], cwd);
+}
+
+export async function gitWorktreeRemove(
+  cwd: string,
+  wtPath: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await git(["worktree", "remove", wtPath], cwd);
+}
+
+// -- Partial staging --
+
+export async function gitDiffHunks(
+  cwd: string,
+  filePath: string,
+  cached = false,
+): Promise<GitDiffHunk[]> {
+  assertGitRepo(cwd);
+  const args = ["diff", "--unified=3"];
+  if (cached) args.push("--cached");
+  args.push("--", filePath);
+  let diff: string;
+  try {
+    diff = await git(args, cwd);
+  } catch {
+    return [];
+  }
+  return parseUnifiedDiffHunks(diff);
+}
+
+function parseUnifiedDiffHunks(diff: string): GitDiffHunk[] {
+  const hunks: GitDiffHunk[] = [];
+  const lines = diff.split("\n");
+  let i = 0;
+  let hunkIndex = 0;
+  while (i < lines.length) {
+    const line = lines[i]!;
+    if (line.startsWith("@@")) {
+      const header = line;
+      const patchLines = [line];
+      i++;
+      while (i < lines.length && !lines[i]!.startsWith("@@")) {
+        patchLines.push(lines[i]!);
+        i++;
+      }
+      hunks.push({
+        index: hunkIndex++,
+        header,
+        patch: patchLines.join("\n"),
+      });
+    } else {
+      i++;
+    }
+  }
+  return hunks;
+}
+
+export async function gitApplyCached(
+  cwd: string,
+  patch: string,
+): Promise<void> {
+  assertGitRepo(cwd);
+  await execFileAsync(
+    "git",
+    ["apply", "--cached", "-"],
+    { cwd, input: patch, maxBuffer: MAX_BUFFER },
+  );
+}
+
+export async function gitApplyWorking(
+  cwd: string,
+  patch: string,
+  reverse = false,
+): Promise<void> {
+  assertGitRepo(cwd);
+  const args = ["apply"];
+  if (reverse) args.push("-R");
+  await execFileAsync(
+    "git",
+    [...args, "-"],
+    { cwd, input: patch, maxBuffer: MAX_BUFFER },
+  );
+}
+
+export async function gitCheckIgnore(
+  cwd: string,
+  paths: string[],
+): Promise<string[]> {
+  assertGitRepo(cwd);
+  if (paths.length === 0) return [];
+  try {
+    const raw = await git(["check-ignore", "-v", "--", ...paths], cwd);
+    return raw
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// -- LFS --
+
+export async function gitLfsAvailable(): Promise<boolean> {
+  try {
+    await execFileAsync("git", ["lfs", "version"], {
+      maxBuffer: MAX_BUFFER,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function gitLfsTrackedPaths(
+  cwd: string,
+): Promise<Set<string>> {
+  assertGitRepo(cwd);
+  if (!(await gitLfsAvailable())) return new Set();
+  try {
+    const raw = await git(["lfs", "status", "--porcelain"], cwd);
+    const paths = new Set<string>();
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^\S+\s+(\S+)/);
+      if (match) paths.add(match[1]!);
+    }
+    return paths;
+  } catch {
+    return new Set();
+  }
+}
+
+/** Paths with `filter=lfs` in .gitattributes (for SCM badges). */
+export async function gitPathsUsingLfs(
+  cwd: string,
+  paths: string[],
+): Promise<Set<string>> {
+  if (paths.length === 0 || !isGitRepo(cwd)) return new Set();
+  try {
+    const raw = await git(["check-attr", "filter", "--", ...paths], cwd);
+    const lfs = new Set<string>();
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const match = trimmed.match(/^(.+): filter: (.*)$/);
+      if (match?.[2] === "lfs") lfs.add(match[1]!);
+    }
+    return lfs;
+  } catch {
+    return new Set();
+  }
+}
+
+// -- Config display --
+
+export async function gitConfigDisplay(
+  cwd: string,
+): Promise<GitConfigDisplay> {
+  assertGitRepo(cwd);
+  const read = async (key: string) => {
+    try {
+      return (await git(["config", "--get", key], cwd)).trim();
+    } catch {
+      return "";
+    }
+  };
+  const gpgSign = (await read("commit.gpgsign")) === "true";
+  return {
+    userName: await read("user.name"),
+    userEmail: await read("user.email"),
+    credentialHelper: await read("credential.helper"),
+    gpgSign,
+  };
+}
+
+export async function gitGpgSignEnabled(cwd: string): Promise<boolean> {
+  const cfg = await gitConfigDisplay(cwd);
+  return cfg.gpgSign;
+}
diff --git a/collab-electron/src/main/ipc-git.ts b/collab-electron/src/main/ipc-git.ts
index 4c73c7b9..aaac5b69 100644
--- a/collab-electron/src/main/ipc-git.ts
+++ b/collab-electron/src/main/ipc-git.ts
@@ -1,5 +1,9 @@
 import { ipcMain } from "electron";
+import { realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import type { AppConfig } from "./config";
+import type { GitDiffOpenParams } from "@collab/shared/git-types";
 import {
   gitStatus,
   gitStage,
@@ -12,6 +16,7 @@ import {
   gitDiff,
   gitDiffAll,
   gitDiffCached,
+  gitInit,
   gitPush,
   gitPushSetUpstream,
   gitPull,
@@ -19,6 +24,7 @@ import {
   gitRemotes,
   gitHasUpstream,
   gitBranches,
+  gitTags,
   gitCheckout,
   gitCreateBranch,
   gitDeleteBranch,
@@ -28,6 +34,46 @@ import {
   gitStashApply,
   gitStashDrop,
   gitShowFile,
+  gitReadBlob,
+  gitDiffRefs,
+  gitClone,
+  gitRemoteAdd,
+  gitRemoteRemove,
+  gitRemoteRename,
+  gitRemoteSetUrl,
+  gitCheckoutOurs,
+  gitCheckoutTheirs,
+  gitAdd,
+  gitMergeAbort,
+  gitMergeContinue,
+  gitCherryPickAbort,
+  gitCherryPickContinue,
+  gitRevertAbort,
+  gitRevertContinue,
+  gitLog,
+  gitLogFiles,
+  gitRevert,
+  gitCherryPick,
+  gitReset,
+  gitMerge,
+  gitRebase,
+  gitRebaseContinue,
+  gitRebaseAbort,
+  gitRebaseSkip,
+  gitRebaseTodoList,
+  gitRebaseTodoWrite,
+  gitRebaseStartInteractive,
+  gitSubmoduleStatus,
+  gitSubmoduleUpdate,
+  gitWorktreeList,
+  gitWorktreeAdd,
+  gitWorktreeRemove,
+  gitDiffHunks,
+  gitApplyCached,
+  gitApplyWorking,
+  gitCheckIgnore,
+  gitConfigDisplay,
+  gitGpgSignEnabled,
 } from "./git-source-control";
 import {
   getAvailableAgent,
@@ -36,129 +82,186 @@ import {
   generateCommitMessageViaApi,
   validateApiKey,
 } from "./ai-commit";
+import {
+  initWorkspaceFiles,
+  startSingleWorkspaceServices,
+} from "./ipc-workspace";
+import { saveConfig } from "./config";
 
 export interface IpcGitContext {
   config: () => AppConfig;
+  forwardToWebview?: (
+    target: string,
+    channel: string,
+    ...args: unknown[]
+  ) => void;
+  onWorkspaceAdded?: (path: string) => void;
+  setFileFilter?: (f: unknown) => void;
+  trackEvent?: (
+    name: string,
+    props?: Record<string, unknown>,
+  ) => void;
 }
 
-function activeWorkspacePath(config: AppConfig): string {
+function resolveWorkspacePath(
+  config: AppConfig,
+  workspacePath?: string,
+): string {
+  if (workspacePath?.trim()) {
+    return workspacePath;
+  }
   return config.workspaces[0] ?? "";
 }
 
+function requireWorkspace(
+  config: AppConfig,
+  workspacePath?: string,
+): string {
+  const cwd = resolveWorkspacePath(config, workspacePath);
+  if (!cwd) throw new Error("No active workspace");
+  return cwd;
+}
+
+const emptyStatus = {
+  branch: "",
+  ahead: 0,
+  behind: 0,
+  staged: [],
+  unstaged: [],
+  untracked: [],
+  merge: [],
+  isGitRepo: false,
+  hasCommits: false,
+  repoState: "clean" as const,
+};
+
+function forwardGitDiff(
+  ctx: IpcGitContext,
+  params: GitDiffOpenParams,
+): void {
+  ctx.forwardToWebview?.("viewer", "git-diff-open", params);
+}
+
 export function registerGitHandlers(ctx: IpcGitContext): void {
-  ipcMain.handle("git:status", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) {
-      return {
-        branch: "",
-        ahead: 0,
-        behind: 0,
-        staged: [],
-        unstaged: [],
-        untracked: [],
-        isGitRepo: false,
-      };
-    }
-    return gitStatus(cwd);
-  });
+  ipcMain.handle(
+    "git:status",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return emptyStatus;
+      return gitStatus(cwd);
+    },
+  );
 
   ipcMain.handle(
     "git:stage",
-    async (_event, paths: string[]) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitStage(cwd, paths);
     },
   );
 
   ipcMain.handle(
     "git:unstage",
-    async (_event, paths: string[]) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitUnstage(cwd, paths);
     },
   );
 
-  ipcMain.handle("git:stage-all", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitStageAll(cwd);
-  });
+  ipcMain.handle(
+    "git:stage-all",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitStageAll(cwd);
+    },
+  );
 
-  ipcMain.handle("git:unstage-all", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitUnstageAll(cwd);
-  });
+  ipcMain.handle(
+    "git:unstage-all",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitUnstageAll(cwd);
+    },
+  );
 
   ipcMain.handle(
     "git:discard",
-    async (_event, paths: string[]) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitDiscard(cwd, paths);
     },
   );
 
-  ipcMain.handle("git:discard-all", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitDiscardAll(cwd);
-  });
+  ipcMain.handle(
+    "git:discard-all",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitDiscardAll(cwd);
+    },
+  );
 
   ipcMain.handle(
     "git:commit",
-    async (_event, message: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
-      return gitCommit(cwd, message);
+    async (
+      _event,
+      workspacePath: string,
+      message: string,
+      options?: { amend?: boolean; sign?: boolean },
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitCommit(cwd, message, options);
     },
   );
 
   ipcMain.handle(
     "git:diff",
-    async (_event, filePath: string, cached: boolean) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (
+      _event,
+      workspacePath: string,
+      filePath: string,
+      cached: boolean,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       return gitDiff(cwd, filePath, cached);
     },
   );
 
-  ipcMain.handle("git:generate-commit-message", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
+  ipcMain.handle(
+    "git:generate-commit-message",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
 
-    let diff = await gitDiffCached(cwd);
-    if (!diff.trim()) {
-      diff = await gitDiffAll(cwd);
-    }
-    if (!diff.trim()) {
-      const status = await gitStatus(cwd);
-      if (status.untracked.length > 0 || status.unstaged.length > 0) {
-        await gitStageAll(cwd);
-        diff = await gitDiffCached(cwd);
-        await gitUnstageAll(cwd);
+      let diff = await gitDiffCached(cwd);
+      if (!diff.trim()) {
+        diff = await gitDiffAll(cwd);
+      }
+      if (!diff.trim()) {
+        const status = await gitStatus(cwd);
+        if (status.untracked.length > 0 || status.unstaged.length > 0) {
+          await gitStageAll(cwd);
+          diff = await gitDiffCached(cwd);
+          await gitUnstageAll(cwd);
+        }
+      }
+      if (!diff.trim()) {
+        throw new Error("No changes found to generate a message from.");
       }
-    }
-    if (!diff.trim()) {
-      throw new Error("No changes found to generate a message from.");
-    }
 
-    const agent = getAvailableAgent();
-    if (agent) {
-      return generateCommitMessageViaCli(agent, diff);
-    }
+      const agent = getAvailableAgent();
+      if (agent) {
+        return generateCommitMessageViaCli(agent, diff);
+      }
 
-    const apiKey = ctx.config().ui?.["ai.apiKey"];
-    if (typeof apiKey === "string" && apiKey) {
-      return generateCommitMessageViaApi(apiKey, diff);
-    }
+      const apiKey = ctx.config().ui?.["ai.apiKey"];
+      if (typeof apiKey === "string" && apiKey) {
+        return generateCommitMessageViaApi(apiKey, diff);
+      }
 
-    throw new Error(
-      "No AI agent found. Install Claude Code, Codex, or Gemini CLI — or add an API key in Settings → AI.",
-    );
-  });
+      throw new Error(
+        "No AI agent found. Install Claude Code, Codex, or Gemini CLI — or add an API key in Settings → AI.",
+      );
+    },
+  );
 
   ipcMain.handle(
     "ai:validate-key",
@@ -177,126 +280,582 @@ export function registerGitHandlers(ctx: IpcGitContext): void {
     return canGenerate(typeof apiKey === "string" ? apiKey : undefined);
   });
 
-  ipcMain.handle("git:push", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitPush(cwd);
-  });
+  ipcMain.handle(
+    "git:init",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitInit(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:push",
+    async (_event, workspacePath?: string, remote?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitPush(cwd, remote);
+    },
+  );
 
   ipcMain.handle(
     "git:push-set-upstream",
-    async (_event, remote: string, branch: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (
+      _event,
+      workspacePath: string,
+      remote: string,
+      branch: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitPushSetUpstream(cwd, remote, branch);
     },
   );
 
-  ipcMain.handle("git:pull", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitPull(cwd);
-  });
+  ipcMain.handle(
+    "git:pull",
+    async (_event, workspacePath?: string, remote?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitPull(cwd, remote);
+    },
+  );
 
-  ipcMain.handle("git:fetch", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) throw new Error("No active workspace");
-    await gitFetch(cwd);
-  });
+  ipcMain.handle(
+    "git:fetch",
+    async (_event, workspacePath?: string, remote?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitFetch(cwd, remote);
+    },
+  );
 
-  ipcMain.handle("git:remotes", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) return [];
-    return gitRemotes(cwd);
-  });
+  ipcMain.handle(
+    "git:remotes",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return [];
+      return gitRemotes(cwd);
+    },
+  );
 
-  ipcMain.handle("git:has-upstream", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) return false;
-    return gitHasUpstream(cwd);
-  });
+  ipcMain.handle(
+    "git:has-upstream",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return false;
+      return gitHasUpstream(cwd);
+    },
+  );
 
-  ipcMain.handle("git:branches", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) return [];
-    return gitBranches(cwd);
-  });
+  ipcMain.handle(
+    "git:branches",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return [];
+      return gitBranches(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:tags",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return [];
+      return gitTags(cwd);
+    },
+  );
 
   ipcMain.handle(
     "git:checkout",
-    async (_event, branch: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, branch: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitCheckout(cwd, branch);
     },
   );
 
   ipcMain.handle(
     "git:create-branch",
-    async (_event, name: string, startPoint?: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (
+      _event,
+      workspacePath: string,
+      name: string,
+      startPoint?: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitCreateBranch(cwd, name, startPoint);
     },
   );
 
   ipcMain.handle(
     "git:delete-branch",
-    async (_event, name: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, name: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitDeleteBranch(cwd, name);
     },
   );
 
   ipcMain.handle(
     "git:stash-save",
-    async (_event, message?: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, message?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitStashSave(cwd, message);
     },
   );
 
-  ipcMain.handle("git:stash-list", async () => {
-    const cwd = activeWorkspacePath(ctx.config());
-    if (!cwd) return [];
-    return gitStashList(cwd);
-  });
+  ipcMain.handle(
+    "git:stash-list",
+    async (_event, workspacePath?: string) => {
+      const cwd = resolveWorkspacePath(ctx.config(), workspacePath);
+      if (!cwd) return [];
+      return gitStashList(cwd);
+    },
+  );
 
   ipcMain.handle(
     "git:stash-pop",
-    async (_event, index: number) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, index: number) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitStashPop(cwd, index);
     },
   );
 
   ipcMain.handle(
     "git:stash-apply",
-    async (_event, index: number) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, index: number) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitStashApply(cwd, index);
     },
   );
 
   ipcMain.handle(
     "git:stash-drop",
-    async (_event, index: number) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (_event, workspacePath: string, index: number) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       await gitStashDrop(cwd, index);
     },
   );
 
   ipcMain.handle(
     "git:show-file",
-    async (_event, ref: string, filePath: string) => {
-      const cwd = activeWorkspacePath(ctx.config());
-      if (!cwd) throw new Error("No active workspace");
+    async (
+      _event,
+      workspacePath: string,
+      ref: string,
+      filePath: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
       return gitShowFile(cwd, ref, filePath);
     },
   );
+
+  ipcMain.handle(
+    "git:read-blob",
+    async (
+      _event,
+      workspacePath: string,
+      ref: string,
+      filePath: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitReadBlob(cwd, ref, filePath);
+    },
+  );
+
+  ipcMain.handle(
+    "git:diff-refs",
+    async (
+      _event,
+      workspacePath: string,
+      leftRef: string,
+      rightRef: string,
+      filePath: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitDiffRefs(cwd, leftRef, rightRef, filePath);
+    },
+  );
+
+  ipcMain.on(
+    "git:open-diff",
+    (_event, params: GitDiffOpenParams) => {
+      forwardGitDiff(ctx, params);
+    },
+  );
+
+  ipcMain.handle(
+    "git:clone",
+    async (
+      _event,
+      url: string,
+      parentDir: string,
+      options?: { branch?: string; depth?: number },
+    ) => {
+      if (!url.trim()) throw new Error("Clone URL is required");
+      if (!parentDir.trim()) throw new Error("Parent directory is required");
+      const result = await gitClone(url.trim(), parentDir, options);
+      const chosen = realpathSync(result.path);
+      const appConfig = ctx.config();
+
+      if (!appConfig.workspaces.includes(chosen)) {
+        const collabDir = join(chosen, ".collaborator");
+        const isNew = !existsSync(collabDir);
+        if (isNew) initWorkspaceFiles(chosen);
+        appConfig.workspaces.push(chosen);
+        saveConfig(appConfig);
+        ctx.trackEvent?.("workspace_added", { is_new: isNew, cloned: true });
+        startSingleWorkspaceServices(chosen, (f) => {
+          ctx.setFileFilter?.(f);
+        });
+        ctx.forwardToWebview?.("nav", "workspace-added", chosen);
+      }
+
+      return result;
+    },
+  );
+
+  ipcMain.handle(
+    "git:remote-add",
+    async (
+      _event,
+      workspacePath: string,
+      name: string,
+      url: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRemoteAdd(cwd, name, url);
+    },
+  );
+
+  ipcMain.handle(
+    "git:remote-remove",
+    async (_event, workspacePath: string, name: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRemoteRemove(cwd, name);
+    },
+  );
+
+  ipcMain.handle(
+    "git:remote-rename",
+    async (
+      _event,
+      workspacePath: string,
+      oldName: string,
+      newName: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRemoteRename(cwd, oldName, newName);
+    },
+  );
+
+  ipcMain.handle(
+    "git:remote-set-url",
+    async (
+      _event,
+      workspacePath: string,
+      name: string,
+      url: string,
+      push?: boolean,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRemoteSetUrl(cwd, name, url, push);
+    },
+  );
+
+  ipcMain.handle(
+    "git:checkout-ours",
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitCheckoutOurs(cwd, paths);
+    },
+  );
+
+  ipcMain.handle(
+    "git:checkout-theirs",
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitCheckoutTheirs(cwd, paths);
+    },
+  );
+
+  ipcMain.handle(
+    "git:add",
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitAdd(cwd, paths);
+    },
+  );
+
+  ipcMain.handle(
+    "git:merge-abort",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitMergeAbort(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:merge-continue",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitMergeContinue(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:cherry-pick-abort",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitCherryPickAbort(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:cherry-pick-continue",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitCherryPickContinue(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:revert-abort",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRevertAbort(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:revert-continue",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRevertContinue(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:log",
+    async (
+      _event,
+      workspacePath?: string,
+      options?: { maxCount?: number; ref?: string },
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitLog(cwd, options);
+    },
+  );
+
+  ipcMain.handle(
+    "git:log-files",
+    async (_event, workspacePath: string, hash: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitLogFiles(cwd, hash);
+    },
+  );
+
+  ipcMain.handle(
+    "git:revert",
+    async (_event, workspacePath: string, hash: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRevert(cwd, hash);
+    },
+  );
+
+  ipcMain.handle(
+    "git:cherry-pick",
+    async (_event, workspacePath: string, hash: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitCherryPick(cwd, hash);
+    },
+  );
+
+  ipcMain.handle(
+    "git:reset",
+    async (
+      _event,
+      workspacePath: string,
+      mode: "soft" | "mixed" | "hard",
+      ref: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitReset(cwd, mode, ref);
+    },
+  );
+
+  ipcMain.handle(
+    "git:merge",
+    async (_event, workspacePath: string, branch: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitMerge(cwd, branch);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase",
+    async (_event, workspacePath: string, onto: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebase(cwd, onto);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-continue",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebaseContinue(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-abort",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebaseAbort(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-skip",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebaseSkip(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-todo-list",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitRebaseTodoList(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-todo-write",
+    async (
+      _event,
+      workspacePath: string,
+      items: Parameters<typeof gitRebaseTodoWrite>[1],
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebaseTodoWrite(cwd, items);
+    },
+  );
+
+  ipcMain.handle(
+    "git:rebase-start-interactive",
+    async (
+      _event,
+      workspacePath: string,
+      onto: string | null,
+      count: number,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitRebaseStartInteractive(cwd, onto, count);
+    },
+  );
+
+  ipcMain.handle(
+    "git:submodule-status",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitSubmoduleStatus(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:submodule-update",
+    async (
+      _event,
+      workspacePath?: string,
+      init?: boolean,
+      recursive?: boolean,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitSubmoduleUpdate(cwd, init, recursive);
+    },
+  );
+
+  ipcMain.handle(
+    "git:worktree-list",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitWorktreeList(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:worktree-add",
+    async (
+      _event,
+      workspacePath: string,
+      wtPath: string,
+      branch: string,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitWorktreeAdd(cwd, wtPath, branch);
+    },
+  );
+
+  ipcMain.handle(
+    "git:worktree-remove",
+    async (_event, workspacePath: string, wtPath: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitWorktreeRemove(cwd, wtPath);
+    },
+  );
+
+  ipcMain.handle(
+    "git:diff-hunks",
+    async (
+      _event,
+      workspacePath: string,
+      filePath: string,
+      cached?: boolean,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitDiffHunks(cwd, filePath, cached);
+    },
+  );
+
+  ipcMain.handle(
+    "git:apply-cached",
+    async (_event, workspacePath: string, patch: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitApplyCached(cwd, patch);
+    },
+  );
+
+  ipcMain.handle(
+    "git:apply-working",
+    async (
+      _event,
+      workspacePath: string,
+      patch: string,
+      reverse?: boolean,
+    ) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      await gitApplyWorking(cwd, patch, reverse);
+    },
+  );
+
+  ipcMain.handle(
+    "git:check-ignore",
+    async (_event, workspacePath: string, paths: string[]) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitCheckIgnore(cwd, paths);
+    },
+  );
+
+  ipcMain.handle(
+    "git:config-display",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitConfigDisplay(cwd);
+    },
+  );
+
+  ipcMain.handle(
+    "git:gpg-sign-enabled",
+    async (_event, workspacePath?: string) => {
+      const cwd = requireWorkspace(ctx.config(), workspacePath);
+      return gitGpgSignEnabled(cwd);
+    },
+  );
 }
diff --git a/collab-electron/src/main/ipc-workspace.ts b/collab-electron/src/main/ipc-workspace.ts
index 53994424..b9c1e73f 100644
--- a/collab-electron/src/main/ipc-workspace.ts
+++ b/collab-electron/src/main/ipc-workspace.ts
@@ -67,7 +67,7 @@ function ensureGitignoreEntry(workspacePath: string): void {
   );
 }
 
-function initWorkspaceFiles(workspacePath: string): void {
+export function initWorkspaceFiles(workspacePath: string): void {
   const collabDir = join(workspacePath, ".collaborator");
   mkdirSync(collabDir, { recursive: true });
   ensureGitignoreEntry(workspacePath);
diff --git a/collab-electron/src/main/ipc.ts b/collab-electron/src/main/ipc.ts
index af61e383..3bdef030 100644
--- a/collab-electron/src/main/ipc.ts
+++ b/collab-electron/src/main/ipc.ts
@@ -133,5 +133,12 @@ export function registerIpcHandlers(config: AppConfig): void {
   registerKnowledgeHandlers(knowledgeCtx);
   registerCanvasHandlers(canvasCtx);
   registerMiscHandlers(miscCtx);
-  registerGitHandlers({ config: () => appConfig });
+  registerGitHandlers({
+    config: () => appConfig,
+    forwardToWebview,
+    setFileFilter: (f) => {
+      fileFilterRef.current = f as FileFilter;
+    },
+    trackEvent,
+  });
 }
diff --git a/collab-electron/src/preload/universal.ts b/collab-electron/src/preload/universal.ts
index 5a94b3ea..18f14be9 100644
--- a/collab-electron/src/preload/universal.ts
+++ b/collab-electron/src/preload/universal.ts
@@ -491,6 +491,17 @@ contextBridge.exposeInMainWorld("api", {
     return () =>
       ipcRenderer.removeListener("scope-changed", handler);
   },
+  onGitDiffOpen: (
+    cb: (params: import("@collab/shared/git-types").GitDiffOpenParams) => void,
+  ) => {
+    const handler = (
+      _event: IpcRendererEvent,
+      params: import("@collab/shared/git-types").GitDiffOpenParams,
+    ) => cb(params);
+    ipcRenderer.on("git-diff-open", handler);
+    return () =>
+      ipcRenderer.removeListener("git-diff-open", handler);
+  },
 
   // Auto-updater
   updateGetStatus: () =>
@@ -692,70 +703,270 @@ contextBridge.exposeInMainWorld("api", {
   },
 
   // Git source control
-  gitStatus: () =>
-    ipcRenderer.invoke("git:status"),
-  gitStage: (paths: string[]) =>
-    ipcRenderer.invoke("git:stage", paths),
-  gitUnstage: (paths: string[]) =>
-    ipcRenderer.invoke("git:unstage", paths),
-  gitStageAll: () =>
-    ipcRenderer.invoke("git:stage-all"),
-  gitUnstageAll: () =>
-    ipcRenderer.invoke("git:unstage-all"),
-  gitDiscard: (paths: string[]) =>
-    ipcRenderer.invoke("git:discard", paths),
-  gitDiscardAll: () =>
-    ipcRenderer.invoke("git:discard-all"),
-  gitCommit: (message: string) =>
-    ipcRenderer.invoke("git:commit", message),
-  gitDiff: (filePath: string, cached: boolean) =>
-    ipcRenderer.invoke("git:diff", filePath, cached),
-  gitGenerateCommitMessage: () =>
-    ipcRenderer.invoke("git:generate-commit-message"),
+  gitStatus: (workspacePath: string) =>
+    ipcRenderer.invoke("git:status", workspacePath),
+  gitStage: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:stage", workspacePath, paths),
+  gitUnstage: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:unstage", workspacePath, paths),
+  gitStageAll: (workspacePath: string) =>
+    ipcRenderer.invoke("git:stage-all", workspacePath),
+  gitUnstageAll: (workspacePath: string) =>
+    ipcRenderer.invoke("git:unstage-all", workspacePath),
+  gitDiscard: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:discard", workspacePath, paths),
+  gitDiscardAll: (workspacePath: string) =>
+    ipcRenderer.invoke("git:discard-all", workspacePath),
+  gitCommit: (
+    workspacePath: string,
+    message: string,
+    options?: { amend?: boolean },
+  ) =>
+    ipcRenderer.invoke("git:commit", workspacePath, message, options),
+  gitDiff: (workspacePath: string, filePath: string, cached: boolean) =>
+    ipcRenderer.invoke("git:diff", workspacePath, filePath, cached),
+  gitGenerateCommitMessage: (workspacePath: string) =>
+    ipcRenderer.invoke("git:generate-commit-message", workspacePath),
+  gitInit: (workspacePath: string) =>
+    ipcRenderer.invoke("git:init", workspacePath),
   aiValidateKey: (key: string) =>
     ipcRenderer.invoke("ai:validate-key", key),
+  aiHasKey: () =>
+    ipcRenderer.invoke("ai:has-key"),
   aiCanGenerate: () =>
     ipcRenderer.invoke("ai:can-generate"),
 
   // Push / Pull / Fetch
-  gitPush: () =>
-    ipcRenderer.invoke("git:push"),
-  gitPushSetUpstream: (remote: string, branch: string) =>
-    ipcRenderer.invoke("git:push-set-upstream", remote, branch),
-  gitPull: () =>
-    ipcRenderer.invoke("git:pull"),
-  gitFetch: () =>
-    ipcRenderer.invoke("git:fetch"),
-  gitRemotes: () =>
-    ipcRenderer.invoke("git:remotes"),
-  gitHasUpstream: () =>
-    ipcRenderer.invoke("git:has-upstream"),
+  gitPush: (workspacePath: string, remote?: string) =>
+    ipcRenderer.invoke("git:push", workspacePath, remote),
+  gitPushSetUpstream: (
+    workspacePath: string,
+    remote: string,
+    branch: string,
+  ) =>
+    ipcRenderer.invoke(
+      "git:push-set-upstream",
+      workspacePath,
+      remote,
+      branch,
+    ),
+  gitPull: (workspacePath: string, remote?: string) =>
+    ipcRenderer.invoke("git:pull", workspacePath, remote),
+  gitFetch: (workspacePath: string, remote?: string) =>
+    ipcRenderer.invoke("git:fetch", workspacePath, remote),
+  gitRemotes: (workspacePath: string) =>
+    ipcRenderer.invoke("git:remotes", workspacePath),
+  gitHasUpstream: (workspacePath: string) =>
+    ipcRenderer.invoke("git:has-upstream", workspacePath),
 
   // Branch operations
-  gitBranches: () =>
-    ipcRenderer.invoke("git:branches"),
-  gitCheckout: (branch: string) =>
-    ipcRenderer.invoke("git:checkout", branch),
-  gitCreateBranch: (name: string, startPoint?: string) =>
-    ipcRenderer.invoke("git:create-branch", name, startPoint),
-  gitDeleteBranch: (name: string) =>
-    ipcRenderer.invoke("git:delete-branch", name),
+  gitBranches: (workspacePath: string) =>
+    ipcRenderer.invoke("git:branches", workspacePath),
+  gitTags: (workspacePath: string) =>
+    ipcRenderer.invoke("git:tags", workspacePath),
+  gitCheckout: (workspacePath: string, branch: string) =>
+    ipcRenderer.invoke("git:checkout", workspacePath, branch),
+  gitCreateBranch: (
+    workspacePath: string,
+    name: string,
+    startPoint?: string,
+  ) =>
+    ipcRenderer.invoke(
+      "git:create-branch",
+      workspacePath,
+      name,
+      startPoint,
+    ),
+  gitDeleteBranch: (workspacePath: string, name: string) =>
+    ipcRenderer.invoke("git:delete-branch", workspacePath, name),
 
   // Stash operations
-  gitStashSave: (message?: string) =>
-    ipcRenderer.invoke("git:stash-save", message),
-  gitStashList: () =>
-    ipcRenderer.invoke("git:stash-list"),
-  gitStashPop: (index: number) =>
-    ipcRenderer.invoke("git:stash-pop", index),
-  gitStashApply: (index: number) =>
-    ipcRenderer.invoke("git:stash-apply", index),
-  gitStashDrop: (index: number) =>
-    ipcRenderer.invoke("git:stash-drop", index),
+  gitStashSave: (workspacePath: string, message?: string) =>
+    ipcRenderer.invoke("git:stash-save", workspacePath, message),
+  gitStashList: (workspacePath: string) =>
+    ipcRenderer.invoke("git:stash-list", workspacePath),
+  gitStashPop: (workspacePath: string, index: number) =>
+    ipcRenderer.invoke("git:stash-pop", workspacePath, index),
+  gitStashApply: (workspacePath: string, index: number) =>
+    ipcRenderer.invoke("git:stash-apply", workspacePath, index),
+  gitStashDrop: (workspacePath: string, index: number) =>
+    ipcRenderer.invoke("git:stash-drop", workspacePath, index),
 
   // Show file at ref (for diff viewer)
-  gitShowFile: (ref: string, filePath: string) =>
-    ipcRenderer.invoke("git:show-file", ref, filePath),
+  gitShowFile: (
+    workspacePath: string,
+    ref: string,
+    filePath: string,
+  ) =>
+    ipcRenderer.invoke("git:show-file", workspacePath, ref, filePath),
+  gitReadBlob: (
+    workspacePath: string,
+    ref: string,
+    filePath: string,
+  ) =>
+    ipcRenderer.invoke("git:read-blob", workspacePath, ref, filePath),
+  gitDiffRefs: (
+    workspacePath: string,
+    leftRef: string,
+    rightRef: string,
+    filePath: string,
+  ) =>
+    ipcRenderer.invoke(
+      "git:diff-refs",
+      workspacePath,
+      leftRef,
+      rightRef,
+      filePath,
+    ),
+  openGitDiff: (
+    params: import("@collab/shared/git-types").GitDiffOpenParams,
+  ) => ipcRenderer.send("git:open-diff", params),
+  gitClone: (
+    url: string,
+    parentDir: string,
+    options?: { branch?: string; depth?: number },
+  ) => ipcRenderer.invoke("git:clone", url, parentDir, options),
+  gitRemoteAdd: (
+    workspacePath: string,
+    name: string,
+    url: string,
+  ) =>
+    ipcRenderer.invoke("git:remote-add", workspacePath, name, url),
+  gitRemoteRemove: (workspacePath: string, name: string) =>
+    ipcRenderer.invoke("git:remote-remove", workspacePath, name),
+  gitRemoteRename: (
+    workspacePath: string,
+    oldName: string,
+    newName: string,
+  ) =>
+    ipcRenderer.invoke(
+      "git:remote-rename",
+      workspacePath,
+      oldName,
+      newName,
+    ),
+  gitRemoteSetUrl: (
+    workspacePath: string,
+    name: string,
+    url: string,
+    push?: boolean,
+  ) =>
+    ipcRenderer.invoke(
+      "git:remote-set-url",
+      workspacePath,
+      name,
+      url,
+      push,
+    ),
+  gitCheckoutOurs: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:checkout-ours", workspacePath, paths),
+  gitCheckoutTheirs: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:checkout-theirs", workspacePath, paths),
+  gitAdd: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:add", workspacePath, paths),
+  gitMergeAbort: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:merge-abort", workspacePath),
+  gitMergeContinue: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:merge-continue", workspacePath),
+  gitCherryPickAbort: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:cherry-pick-abort", workspacePath),
+  gitCherryPickContinue: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:cherry-pick-continue", workspacePath),
+  gitRevertAbort: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:revert-abort", workspacePath),
+  gitRevertContinue: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:revert-continue", workspacePath),
+  gitLog: (
+    workspacePath?: string,
+    options?: { maxCount?: number; ref?: string },
+  ) => ipcRenderer.invoke("git:log", workspacePath, options),
+  gitLogFiles: (workspacePath: string, hash: string) =>
+    ipcRenderer.invoke("git:log-files", workspacePath, hash),
+  gitRevertCommit: (workspacePath: string, hash: string) =>
+    ipcRenderer.invoke("git:revert", workspacePath, hash),
+  gitCherryPick: (workspacePath: string, hash: string) =>
+    ipcRenderer.invoke("git:cherry-pick", workspacePath, hash),
+  gitReset: (
+    workspacePath: string,
+    mode: "soft" | "mixed" | "hard",
+    ref: string,
+  ) => ipcRenderer.invoke("git:reset", workspacePath, mode, ref),
+  gitMerge: (workspacePath: string, branch: string) =>
+    ipcRenderer.invoke("git:merge", workspacePath, branch),
+  gitRebase: (workspacePath: string, onto: string) =>
+    ipcRenderer.invoke("git:rebase", workspacePath, onto),
+  gitRebaseContinue: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:rebase-continue", workspacePath),
+  gitRebaseAbort: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:rebase-abort", workspacePath),
+  gitRebaseSkip: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:rebase-skip", workspacePath),
+  gitRebaseTodoList: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:rebase-todo-list", workspacePath),
+  gitRebaseTodoWrite: (
+    workspacePath: string,
+    items: import("@collab/shared/git-types").GitRebaseTodoItem[],
+  ) =>
+    ipcRenderer.invoke("git:rebase-todo-write", workspacePath, items),
+  gitRebaseStartInteractive: (
+    workspacePath: string,
+    onto: string | null,
+    count: number,
+  ) =>
+    ipcRenderer.invoke(
+      "git:rebase-start-interactive",
+      workspacePath,
+      onto,
+      count,
+    ),
+  gitSubmoduleStatus: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:submodule-status", workspacePath),
+  gitSubmoduleUpdate: (
+    workspacePath?: string,
+    init?: boolean,
+    recursive?: boolean,
+  ) =>
+    ipcRenderer.invoke(
+      "git:submodule-update",
+      workspacePath,
+      init,
+      recursive,
+    ),
+  gitWorktreeList: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:worktree-list", workspacePath),
+  gitWorktreeAdd: (
+    workspacePath: string,
+    wtPath: string,
+    branch: string,
+  ) =>
+    ipcRenderer.invoke("git:worktree-add", workspacePath, wtPath, branch),
+  gitWorktreeRemove: (workspacePath: string, wtPath: string) =>
+    ipcRenderer.invoke("git:worktree-remove", workspacePath, wtPath),
+  gitDiffHunks: (
+    workspacePath: string,
+    filePath: string,
+    cached?: boolean,
+  ) =>
+    ipcRenderer.invoke("git:diff-hunks", workspacePath, filePath, cached),
+  gitApplyCached: (workspacePath: string, patch: string) =>
+    ipcRenderer.invoke("git:apply-cached", workspacePath, patch),
+  gitApplyWorking: (
+    workspacePath: string,
+    patch: string,
+    reverse?: boolean,
+  ) =>
+    ipcRenderer.invoke(
+      "git:apply-working",
+      workspacePath,
+      patch,
+      reverse,
+    ),
+  gitCheckIgnore: (workspacePath: string, paths: string[]) =>
+    ipcRenderer.invoke("git:check-ignore", workspacePath, paths),
+  gitConfigDisplay: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:config-display", workspacePath),
+  gitGpgSignEnabled: (workspacePath?: string) =>
+    ipcRenderer.invoke("git:gpg-sign-enabled", workspacePath),
 });
 
 // Forward ctrl+wheel (trackpad pinch) from tile webviews to the canvas
diff --git a/collab-electron/src/windows/settings/src/App.tsx b/collab-electron/src/windows/settings/src/App.tsx
index bf10a605..356bdf5f 100644
--- a/collab-electron/src/windows/settings/src/App.tsx
+++ b/collab-electron/src/windows/settings/src/App.tsx
@@ -8,6 +8,7 @@ import {
   Moon,
   Monitor,
   Terminal,
+  GitBranch,
   Sparkle,
   CheckCircle,
   XCircle,
@@ -29,6 +30,17 @@ interface SettingsApi {
   getAgents: () => Promise<AgentStatus[]>;
   installSkill: (agentId: string) => Promise<{ ok: boolean }>;
   uninstallSkill: (agentId: string) => Promise<{ ok: boolean }>;
+  aiHasKey: () => Promise<boolean>;
+  aiValidateKey: (key: string) => Promise<{ valid: boolean }>;
+  getConfig: () => Promise<{ workspaces: string[] }>;
+  gitConfigDisplay: (
+    workspacePath?: string,
+  ) => Promise<{
+    userName: string;
+    userEmail: string;
+    credentialHelper: string;
+    gpgSign: boolean;
+  }>;
   close: () => void;
 }
 
@@ -604,7 +616,8 @@ type Pane =
   | "terminal"
   | "integrations"
   | "controls"
-  | "ai";
+  | "ai"
+  | "git";
 
 const NAV_ITEMS: {
   id: Pane;
@@ -616,8 +629,69 @@ const NAV_ITEMS: {
     { id: "integrations", label: "Integrations", icon: PuzzlePiece },
     { id: "controls", label: "Controls", icon: Keyboard },
     { id: "ai", label: "AI", icon: Sparkle },
+    { id: "git", label: "Git", icon: GitBranch },
   ];
 
+function GitPane() {
+  const [cfg, setCfg] = useState<{
+    userName: string;
+    userEmail: string;
+    credentialHelper: string;
+    gpgSign: boolean;
+  } | null>(null);
+
+  useEffect(() => {
+    void api
+      .getConfig()
+      .then((c) => {
+        const ws = c.workspaces?.[0];
+        if (!ws) return;
+        return api.gitConfigDisplay(ws);
+      })
+      .then((display) => {
+        if (display) setCfg(display);
+      })
+      .catch(() => {});
+  }, []);
+
+  return (
+    <div className="space-y-6 p-6">
+      <div className="space-y-1">
+        <h2 className="text-base font-semibold">Git</h2>
+        <p className="text-sm text-muted-foreground">
+          Read-only view of your system git configuration. Manage credentials
+          with your OS credential manager or{" "}
+          <code className="text-xs">git config</code> in a terminal.
+        </p>
+      </div>
+      {cfg ? (
+        <dl className="space-y-3 text-sm font-mono">
+          <div>
+            <dt className="text-muted-foreground">user.name</dt>
+            <dd>{cfg.userName || "—"}</dd>
+          </div>
+          <div>
+            <dt className="text-muted-foreground">user.email</dt>
+            <dd>{cfg.userEmail || "—"}</dd>
+          </div>
+          <div>
+            <dt className="text-muted-foreground">credential.helper</dt>
+            <dd>{cfg.credentialHelper || "—"}</dd>
+          </div>
+          <div>
+            <dt className="text-muted-foreground">commit.gpgsign</dt>
+            <dd>{cfg.gpgSign ? "true" : "false"}</dd>
+          </div>
+        </dl>
+      ) : (
+        <p className="text-sm text-muted-foreground">
+          Open a workspace to view git configuration.
+        </p>
+      )}
+    </div>
+  );
+}
+
 function AiPane() {
   const [apiKey, setApiKey] = useState("");
   const [hasExistingKey, setHasExistingKey] = useState(false);
@@ -627,15 +701,10 @@ function AiPane() {
   >(null);
 
   useEffect(() => {
-    api.getPref("ai.hasKey").then(() => {
-      // We can't read the key (guarded), so check via aiHasKey
-      (window as unknown as { api: { aiHasKey: () => Promise<boolean> } }).api
-        .aiHasKey()
-        .then((has: boolean) => {
-          setHasExistingKey(has);
-        })
-        .catch(() => {});
-    }).catch(() => {});
+    void api
+      .aiHasKey()
+      .then(setHasExistingKey)
+      .catch(() => {});
   }, []);
 
   async function handleSave() {
@@ -643,11 +712,7 @@ function AiPane() {
     setValidating(true);
     setValidationResult(null);
     try {
-      const { valid } = await (
-        window as unknown as {
-          api: { aiValidateKey: (k: string) => Promise<{ valid: boolean }> };
-        }
-      ).api.aiValidateKey(apiKey.trim());
+      const { valid } = await api.aiValidateKey(apiKey.trim());
       if (valid) {
         await api.setPref("ai.apiKey", apiKey.trim());
         setHasExistingKey(true);
@@ -917,6 +982,7 @@ export default function App() {
         {activePane === "integrations" && <IntegrationsPane />}
         {activePane === "controls" && <ControlsPane />}
         {activePane === "ai" && <AiPane />}
+        {activePane === "git" && <GitPane />}
       </div>
     </div>
   );
diff --git a/collab-electron/src/windows/shell/src/renderer.js b/collab-electron/src/windows/shell/src/renderer.js
index f1228473..b8c2bba2 100644
--- a/collab-electron/src/windows/shell/src/renderer.js
+++ b/collab-electron/src/windows/shell/src/renderer.js
@@ -1183,6 +1183,9 @@ async function init() {
 						focusSurface(lastNonModalSurface);
 					}
 				}
+				if (channel === "git-diff-open") {
+					singletonViewer.webview.style.display = "";
+				}
 				if (channel === "file-renamed") {
 					tileManager.updateTileForRename(
 						args[0], args[1],
diff --git a/collab-electron/src/windows/viewer/src/App.tsx b/collab-electron/src/windows/viewer/src/App.tsx
index fc2e3085..b1df5ef6 100644
--- a/collab-electron/src/windows/viewer/src/App.tsx
+++ b/collab-electron/src/windows/viewer/src/App.tsx
@@ -15,6 +15,9 @@ import "@collab/components/Editor/Blocknote.css";
 import "@collab/components/Editor/WikiLink.css";
 import { CodeEditorView } from "@collab/components/CodeEditorView";
 import "@collab/components/CodeEditorView/CodeEditorView.css";
+import { DiffEditorView } from "@collab/components/DiffEditorView";
+import "@collab/components/DiffEditorView/DiffEditorView.css";
+import type { GitDiffOpenParams } from "@collab/shared/git-types";
 import { isImageFile } from "@collab/shared/image";
 import { isPdfFile } from "@collab/shared/pdf";
 import { toCollabFileUrl } from "@collab/shared/collab-file-url";
@@ -84,6 +87,11 @@ function blurGuestActiveElement() {
 
 export default function App() {
 	const [selectedPath, setSelectedPath] = useState<string | null>(null);
+	const [diffSession, setDiffSession] =
+		useState<GitDiffOpenParams | null>(null);
+	const [diffOriginal, setDiffOriginal] = useState("");
+	const [diffModified, setDiffModified] = useState("");
+	const [diffLoading, setDiffLoading] = useState(false);
 	const [focusedFolder, setFocusedFolder] = useState<string | null>(null);
 	const [workspacePath, setWorkspacePath] = useState<string | null>(null);
 	const [fileContent, setFileContent] = useState("");
@@ -153,9 +161,51 @@ export default function App() {
 		return window.api.onFileSelected((path) => {
 			setSelectedPath(path);
 			setFocusedFolder(null);
+			setDiffSession(null);
 		});
 	}, []);
 
+	useEffect(() => {
+		if (isTileMode) return;
+		return window.api.onGitDiffOpen((params) => {
+			setDiffSession(params);
+			setSelectedPath(null);
+			setFocusedFolder(null);
+		});
+	}, [isTileMode]);
+
+	useEffect(() => {
+		if (!diffSession) {
+			setDiffOriginal("");
+			setDiffModified("");
+			return;
+		}
+		const { workspacePath, relativePath, left, right } = diffSession;
+		setDiffLoading(true);
+		Promise.all([
+			window.api.gitReadBlob(
+				workspacePath,
+				left.ref,
+				relativePath,
+			),
+			window.api.gitReadBlob(
+				workspacePath,
+				right.ref,
+				relativePath,
+			),
+		])
+			.then(([orig, mod]) => {
+				setDiffOriginal(orig);
+				setDiffModified(mod);
+			})
+			.catch((err) => {
+				console.error("Failed to load diff:", err);
+				setDiffOriginal("");
+				setDiffModified("");
+			})
+			.finally(() => setDiffLoading(false));
+	}, [diffSession]);
+
 	// Listen for folder selection from nav view
 	useEffect(() => {
 		return window.api.onFolderSelected((path) => {
@@ -454,6 +504,11 @@ export default function App() {
 	const handleClose = useCallback(() => {
 		window.api.selectFile(null);
 		setSelectedPath(null);
+		setDiffSession(null);
+	}, []);
+
+	const handleCloseDiff = useCallback(() => {
+		setDiffSession(null);
 	}, []);
 
 	const handleCloseFolder = useCallback(() => {
@@ -465,7 +520,7 @@ export default function App() {
 		function onKeyDown(e: KeyboardEvent) {
 			if (e.key !== "Escape") return;
 			if (isTileMode) return;
-			if (!focusedFolder && !selectedPath) return;
+			if (!focusedFolder && !selectedPath && !diffSession) return;
 
 			const active = document.activeElement as HTMLElement | null;
 			const isEditable =
@@ -483,7 +538,9 @@ export default function App() {
 			}
 
 			e.preventDefault();
-			if (focusedFolder && !selectedPath) {
+			if (diffSession) {
+				handleCloseDiff();
+			} else if (focusedFolder && !selectedPath) {
 				handleCloseFolder();
 			} else {
 				handleClose();
@@ -492,7 +549,15 @@ export default function App() {
 
 		window.addEventListener("keydown", onKeyDown);
 		return () => window.removeEventListener("keydown", onKeyDown);
-	}, [selectedPath, focusedFolder, isTileMode, handleClose, handleCloseFolder]);
+	}, [
+		selectedPath,
+		focusedFolder,
+		diffSession,
+		isTileMode,
+		handleClose,
+		handleCloseFolder,
+		handleCloseDiff,
+	]);
 
 	const displayedPath = loadedPath;
 	const editingDisabled = !!selectedPath && selectedPath !== loadedPath && !isRenamingRef.current;
@@ -530,14 +595,26 @@ export default function App() {
 		!displayedIsPdf;
 	const hasFile =
 		hasMarkdownFile || hasCodeFile || hasImageFile || hasPdfFile || showFileLoading;
-	const hasFolder = !!focusedFolder && !selectedPath;
+	const hasFolder = !!focusedFolder && !selectedPath && !diffSession;
+	const hasDiff = !!diffSession;
 	const headerPath = showFileLoading
 		? selectedPath
 		: displayedPath;
 
+	const diffHeader =
+		diffSession &&
+		`${diffSession.relativePath} (${diffSession.left.label} ↔ ${diffSession.right.label})`;
+
 	return (
 		<div className={`app${navVisible ? " nav-visible" : ""}`}>
-			{hasFile && headerPath && !isTileMode && (() => {
+			{hasDiff && diffHeader && !isTileMode && (
+				<div className="item-filepath">
+					<span className="filepath-text" title={diffHeader}>
+						{diffHeader}
+					</span>
+				</div>
+			)}
+			{hasFile && headerPath && !isTileMode && !hasDiff && (() => {
 				const { parent, name } = splitFilepath(headerPath);
 				return (
 					<div className="item-filepath">
@@ -564,6 +641,25 @@ export default function App() {
 						{fileError}
 					</div>
 				)}
+				{hasDiff && !isTileMode && (
+					<CloseOverlay onClick={handleCloseDiff} theme={theme} />
+				)}
+				{hasDiff && diffSession && (
+					diffLoading ? (
+						<div className="loading-state">
+							<div className="loading-spinner" />
+							<div className="loading-text">Loading diff…</div>
+						</div>
+					) : (
+						<DiffEditorView
+							filePath={diffSession.relativePath}
+							original={diffOriginal}
+							modified={diffModified}
+							theme={theme}
+							readOnly
+						/>
+					)
+				)}
 				{hasFolder && (
 					<>
 						{!isTileMode && <CloseOverlay onClick={handleCloseFolder} theme={theme} />}
@@ -573,7 +669,7 @@ export default function App() {
 						/>
 					</>
 				)}
-				{hasFile && !isTileMode && (
+				{hasFile && !isTileMode && !hasDiff && (
 					<CloseOverlay onClick={handleClose} theme={theme} />
 				)}
 				{showFileLoading && (
diff --git a/fixtures/git/README.md b/fixtures/git/README.md
new file mode 100644
index 00000000..9339c388
--- /dev/null
+++ b/fixtures/git/README.md
@@ -0,0 +1,33 @@
+# Git SCM QA fixtures
+
+Scripts build local repos under this directory for manual SCM testing in Collaborator. Generated repos are gitignored; only scripts and this README are tracked.
+
+## Prerequisites
+
+- `git` on PATH
+- Optional: `git-lfs` (for LFS badge checks in any repo with `.gitattributes`)
+
+## Setup
+
+From the repository root:
+
+```bash
+./fixtures/git/setup-all.sh
+```
+
+Or individually:
+
+| Script | Output dir | Use case |
+|--------|------------|----------|
+| `setup-merge-conflict.sh` | `merge-conflict/` | Merge in progress with conflict in `base.txt` |
+| `setup-submodule.sh` | `submodule/` | Parent repo with nested `child` submodule |
+| `setup-rebase-todo.sh` | `rebase-todo/` | Interactive rebase paused (`feature` onto `main`) |
+| `setup-dirty-worktree.sh` | `dirty-worktree/` | Staged/unstaged/untracked, tags, stashes, two remotes, ahead |
+
+## Open in Collaborator
+
+Add the fixture directory as a workspace folder (e.g. `fixtures/git/merge-conflict`) and run through [SCM_TEST_MATRIX.md](../../collab-electron/docs/SCM_TEST_MATRIX.md).
+
+## Reset
+
+Delete a fixture folder and re-run its setup script.
diff --git a/fixtures/git/setup-all.sh b/fixtures/git/setup-all.sh
new file mode 100755
index 00000000..15eeadb4
--- /dev/null
+++ b/fixtures/git/setup-all.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+for script in setup-merge-conflict.sh setup-submodule.sh setup-rebase-todo.sh setup-dirty-worktree.sh; do
+  bash "$ROOT/$script"
+done
+echo "All git SCM fixtures created under $ROOT"
diff --git a/fixtures/git/setup-dirty-worktree.sh b/fixtures/git/setup-dirty-worktree.sh
new file mode 100755
index 00000000..aba9a31c
--- /dev/null
+++ b/fixtures/git/setup-dirty-worktree.sh
@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+DIR="$ROOT/dirty-worktree"
+BARE="$ROOT/_bare-dirty.git"
+rm -rf "$DIR" "$BARE"
+mkdir -p "$DIR"
+cd "$DIR"
+
+git init -q
+git config user.email "fixture@collaborator.test"
+git config user.name "SCM Fixture"
+
+mkdir -p src
+echo 'export function greet() { return "hello"; }' > src/app.ts
+git add src/app.ts
+git commit -q -m "initial commit"
+
+git branch -M main
+git clone --bare -q . "$BARE"
+git remote add origin "$BARE"
+git push -q -u origin main
+
+git checkout -q -b feature/login
+echo '// wip' >> src/app.ts
+git add src/app.ts
+git commit -q -m "feature: login scaffold"
+
+git checkout -q main
+echo 'export const VERSION = "1.0.0";' > src/version.ts
+git add src/version.ts
+git commit -q -m "chore: add version constant"
+git tag -a v1.0.0 -m "release 1.0.0"
+
+echo 'scratch' > spike.txt
+git add spike.txt
+git commit -q -m "spike: parser experiment"
+echo 'more spike' >> spike.txt
+git stash push -q -m "wip: spike parser"
+git reset --hard HEAD~1
+
+echo 'notes' > notes-only.txt
+git add notes-only.txt
+git commit -q -m "docs: notes"
+echo 'extra notes' >> notes-only.txt
+git stash push -q -m "wip: local experiments"
+git reset --hard HEAD~1
+
+git remote add backup "$BARE"
+git commit -q --allow-empty -m "ahead of origin"
+
+echo 'console.log("debug");' >> src/app.ts
+echo '# readme' > README.md
+git add README.md
+echo 'draft notes' > notes.txt
+
+echo "Fixture ready: $DIR (staged/unstaged/untracked, tags, stashes, 2 remotes, ahead)"
diff --git a/fixtures/git/setup-merge-conflict.sh b/fixtures/git/setup-merge-conflict.sh
new file mode 100755
index 00000000..b31e6e01
--- /dev/null
+++ b/fixtures/git/setup-merge-conflict.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+DIR="$ROOT/merge-conflict"
+rm -rf "$DIR"
+mkdir -p "$DIR"
+cd "$DIR"
+
+git init -q
+git config user.email "fixture@collaborator.test"
+git config user.name "SCM Fixture"
+
+echo "base" > base.txt
+git add base.txt
+git commit -q -m "initial on main"
+
+git checkout -q -b feature
+echo "feature line" >> base.txt
+git add base.txt
+git commit -q -m "feature change"
+
+git checkout -q main
+echo "main line" >> base.txt
+git add base.txt
+git commit -q -m "main change"
+
+git merge feature || true
+# Leaves MERGE_HEAD and conflict in base.txt
+
+echo "Fixture ready: $DIR (merge conflict on base.txt)"
diff --git a/fixtures/git/setup-rebase-todo.sh b/fixtures/git/setup-rebase-todo.sh
new file mode 100755
index 00000000..10a1d7e3
--- /dev/null
+++ b/fixtures/git/setup-rebase-todo.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+DIR="$ROOT/rebase-todo"
+rm -rf "$DIR"
+mkdir -p "$DIR"
+cd "$DIR"
+
+git init -q
+git config user.email "fixture@collaborator.test"
+git config user.name "SCM Fixture"
+
+echo "v1" > file.txt
+git add file.txt
+git commit -q -m "main: v1"
+
+git checkout -q -b feature
+echo "v2" >> file.txt
+git add file.txt
+git commit -q -m "feature: v2"
+echo "v3" >> file.txt
+git add file.txt
+git commit -q -m "feature: v3"
+
+git checkout -q feature
+GIT_SEQUENCE_EDITOR='sed -i.bak "2s/^pick .*/break/"' git rebase -i main || true
+# Stops at `break` with git-rebase-todo present
+
+echo "Fixture ready: $DIR (interactive rebase in progress on feature)"
diff --git a/fixtures/git/setup-submodule.sh b/fixtures/git/setup-submodule.sh
new file mode 100755
index 00000000..7b6599c0
--- /dev/null
+++ b/fixtures/git/setup-submodule.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+DIR="$ROOT/submodule"
+CHILD="$DIR/child"
+rm -rf "$DIR"
+mkdir -p "$CHILD"
+cd "$CHILD"
+
+git init -q
+git config user.email "fixture@collaborator.test"
+git config user.name "SCM Fixture"
+echo "child content" > README.md
+git add README.md
+git commit -q -m "child initial"
+
+cd "$DIR"
+git init -q
+git config user.email "fixture@collaborator.test"
+git config user.name "SCM Fixture"
+git submodule add -q "$CHILD" child
+git commit -q -m "add child submodule"
+
+echo "Fixture ready: $DIR (submodule at child/)"