@@ -13,6 +13,7 @@ import {
 	getWorkspaceGitInfo,
 	convertGitUrlToHttps,
 	getGitStatus,
+	getCommitContext,
 } from "../git"
 import { truncateOutput } from "../../integrations/misc/extract-text"
 
@@ -351,6 +352,136 @@ describe("git utils", () => {
 		})
 	})
 
+	describe("getCommitContext", () => {
+		const mockDiff = "@@ -1,1 +1,2 @@\n-old line\n+new line"
+
+		type ExecResult = { stdout: string; stderr: string }
+
+		const mockExec = (responses: Map<string, ExecResult>) => {
+			const implementation = (
+				command: string,
+				_options: unknown,
+				callback: (error: Error | null, result?: ExecResult) => void,
+			) => {
+				const response = responses.get(command)
+
+				if (response) {
+					callback(null, response)
+				} else {
+					callback(new Error("Unexpected command"))
+				}
+
+				// `exec` returns a ChildProcess that none of these tests inspect.
+				return {} as ReturnType<typeof exec>
+			}
+
+			vitest.mocked(exec).mockImplementation(implementation as unknown as typeof exec)
+		}
+
+		const gitAvailable: Array<[string, { stdout: string; stderr: string }]> = [
+			["git --version", { stdout: "git version 2.39.2", stderr: "" }],
+			["git rev-parse --git-dir", { stdout: ".git", stderr: "" }],
+		]
+
+		it("should use staged changes when something is staged", async () => {
+			mockExec(
+				new Map([
+					...gitAvailable,
+					["git diff --cached --stat", { stdout: " src/file1.ts | 2 +-", stderr: "" }],
+					["git diff --cached --unified=1", { stdout: mockDiff, stderr: "" }],
+				]),
+			)
+
+			const result = await getCommitContext(cwd)
+			expect(result).toContain("Staged changes:")
+			expect(result).toContain("src/file1.ts")
+			expect(result).toContain("+new line")
+		})
+
+		// These tests mock `exec`, so they cannot catch a diff flag that real git rejects. `exec`
+		// runs through cmd.exe on Windows, which does not strip the single quotes that
+		// `:(exclude)` pathspecs need - keep the argument string free of shell metacharacters.
+		it("should build diff arguments that need no shell quoting", async () => {
+			const commands: string[] = []
+
+			vitest.mocked(exec).mockImplementation(((
+				command: string,
+				_options: unknown,
+				callback: (error: Error | null, result?: ExecResult) => void,
+			) => {
+				commands.push(command)
+				const stdout = command.includes("--stat") ? " src/file1.ts | 2 +-" : mockDiff
+				callback(null, { stdout, stderr: "" })
+				return {} as ReturnType<typeof exec>
+			}) as unknown as typeof exec)
+
+			await getCommitContext(cwd)
+
+			const diffCommands = commands.filter((c) => c.startsWith("git diff"))
+			expect(diffCommands.length).toBeGreaterThan(0)
+
+			for (const command of diffCommands) {
+				expect(command).not.toMatch(/['"()]/)
+			}
+		})
+
+		it("should fall back to the working tree when nothing is staged", async () => {
+			mockExec(
+				new Map([
+					...gitAvailable,
+					["git diff --cached --stat", { stdout: "", stderr: "" }],
+					["git status --short", { stdout: " M src/file1.ts\n?? src/untracked.ts", stderr: "" }],
+					["git diff --unified=1", { stdout: mockDiff, stderr: "" }],
+				]),
+			)
+
+			const result = await getCommitContext(cwd)
+			expect(result).toContain("Unstaged changes:")
+			// `git status --short` is used here specifically so untracked files are visible.
+			expect(result).toContain("src/untracked.ts")
+			expect(result).toContain("+new line")
+		})
+
+		it("should work in a repository without an initial commit", async () => {
+			// `HEAD` does not resolve before the first commit, so the fallback must not reference it.
+			mockExec(
+				new Map([
+					...gitAvailable,
+					["git diff --cached --stat", { stdout: "", stderr: "" }],
+					["git status --short", { stdout: "?? file.txt", stderr: "" }],
+					["git diff --unified=1", { stdout: "", stderr: "" }],
+				]),
+			)
+
+			const result = await getCommitContext(cwd)
+			expect(result).toContain("file.txt")
+		})
+
+		it("should return null when the tree is clean", async () => {
+			mockExec(
+				new Map([
+					...gitAvailable,
+					["git diff --cached --stat", { stdout: "", stderr: "" }],
+					["git status --short", { stdout: "", stderr: "" }],
+				]),
+			)
+
+			expect(await getCommitContext(cwd)).toBeNull()
+		})
+
+		it("should return null when git is not installed", async () => {
+			mockExec(new Map())
+
+			expect(await getCommitContext(cwd)).toBeNull()
+		})
+
+		it("should return null when not in a git repository", async () => {
+			mockExec(new Map([gitAvailable[0]]))
+
+			expect(await getCommitContext(cwd)).toBeNull()
+		})
+	})
+
 	describe("getWorkingState", () => {
 		const mockStatus = " M src/file1.ts\n?? src/file2.ts"
 		const mockDiff = "@@ -1,1 +1,2 @@\n-old line\n+new line"
 
@@ -12,6 +12,17 @@ const execAsync = promisify(exec)
 
 const GIT_OUTPUT_LINE_LIMIT = 500
 
+// Node's default `exec` buffer is 1MB, which real-world diffs routinely exceed.
+const GIT_DIFF_MAX_BUFFER = 10 * 1024 * 1024
+
+// A commit message needs to know what changed, not every line of how. One line of surrounding
+// context per hunk is enough to tell the model where an edit landed, and shrinking the prompt is
+// the one latency factor we control without affecting the model's output.
+//
+// Deliberately no `:(exclude)` pathspecs here: `exec` goes through cmd.exe on Windows, which does
+// not strip the single quotes those require. Oversized diffs are handled by `truncateOutput`.
+const COMMIT_DIFF_ARGS = "--unified=1"
+
 /**
  * Extracts git repository information from the workspace's .git directory
  * @param workspaceRoot The root path of the workspace
@@ -346,6 +357,52 @@ export async function getWorkingState(cwd: string): Promise<string> {
 	}
 }
 
+/**
+ * Collects the changes to describe in a commit message.
+ *
+ * Prefers staged changes, since that is what a commit will actually contain. When nothing is
+ * staged, falls back to the whole working tree so the caller still has something to summarize.
+ *
+ * @param cwd The repository root to inspect
+ * @returns A summary + diff suitable for a prompt, or null if there is nothing to commit
+ */
+export async function getCommitContext(cwd: string): Promise<string | null> {
+	const isInstalled = await checkGitInstalled()
+	if (!isInstalled) {
+		return null
+	}
+
+	const isRepo = await checkGitRepo(cwd)
+	if (!isRepo) {
+		return null
+	}
+
+	const options = { cwd, maxBuffer: GIT_DIFF_MAX_BUFFER }
+
+	const { stdout: stagedSummary } = await execAsync("git diff --cached --stat", options)
+
+	if (stagedSummary.trim()) {
+		const { stdout: stagedDiff } = await execAsync(`git diff --cached ${COMMIT_DIFF_ARGS}`, options)
+		const output = `Staged changes:\n\n${stagedSummary.trim()}\n\n${stagedDiff.trim()}`
+		return truncateOutput(output, GIT_OUTPUT_LINE_LIMIT)
+	}
+
+	// Nothing staged - describe the working tree instead. `git status --short` is used rather than
+	// `--stat` here because it also lists untracked files, which no diff would show.
+	const { stdout: status } = await execAsync("git status --short", options)
+
+	if (!status.trim()) {
+		return null
+	}
+
+	// Deliberately `git diff` rather than `git diff HEAD`: we only reach this branch when the index
+	// is empty, so the two produce identical output - but `HEAD` does not resolve in a repository
+	// without an initial commit, where it would fail outright.
+	const { stdout: diff } = await execAsync(`git diff ${COMMIT_DIFF_ARGS}`, options)
+	const output = `Unstaged changes:\n\n${status.trim()}\n\n${diff.trim()}`.trim()
+	return truncateOutput(output, GIT_OUTPUT_LINE_LIMIT)
+}
+
 /**
  * Gets git status output with configurable file limit
  * @param cwd The working directory to check git status in