diff --git a/src/core/checkpoints/__tests__/changeJournal.spec.ts b/src/core/checkpoints/__tests__/changeJournal.spec.ts
new file mode 100644
index 0000000000..84175afbd4
--- /dev/null
+++ b/src/core/checkpoints/__tests__/changeJournal.spec.ts
@@ -0,0 +1,148 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+
+import { appendChange, journalPath, loadChanges, type ChangeJournalEntry } from "../changeJournal"
+
+describe("changeJournal", () => {
+	const taskId = "test-task"
+
+	let tmpRoot: string
+
+	beforeEach(async () => {
+		tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "b2-journal-"))
+	})
+
+	afterEach(async () => {
+		await fs.rm(tmpRoot, { recursive: true, force: true })
+	})
+
+	function entry(overrides: Partial<ChangeJournalEntry> = {}): ChangeJournalEntry {
+		return {
+			path: "src/foo.ts",
+			operation: "create",
+			checkpointId: "abc12345",
+			...overrides,
+		}
+	}
+
+	describe("journalPath", () => {
+		it("places the journal at <root>/tasks/<taskId>/checkpoints/changes.jsonl", () => {
+			expect(journalPath(tmpRoot, taskId)).toBe(
+				path.join(tmpRoot, "tasks", taskId, "checkpoints", "changes.jsonl"),
+			)
+		})
+	})
+
+	describe("appendChange", () => {
+		it("writes one JSON line per entry with the documented field shape", async () => {
+			await appendChange(tmpRoot, taskId, entry({ operation: "create", checkpointId: "aaa" }))
+
+			const raw = await fs.readFile(journalPath(tmpRoot, taskId), "utf8")
+			const lines = raw.split("\n").filter((line) => line !== "")
+			expect(lines).toHaveLength(1)
+			const parsed = JSON.parse(lines[0]) as ChangeJournalEntry
+			expect(parsed.path).toBe("src/foo.ts")
+			expect(parsed.operation).toBe("create")
+			expect(parsed.checkpointId).toBe("aaa")
+		})
+
+		it("appends multiple entries sequentially", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "a" }))
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "b" }))
+
+			const raw = await fs.readFile(journalPath(tmpRoot, taskId), "utf8")
+			expect(raw.split("\n").filter((line) => line !== "")).toHaveLength(2)
+		})
+	})
+
+	describe("loadChanges", () => {
+		it("returns [] for an absent journal file", async () => {
+			expect(await loadChanges(tmpRoot, taskId)).toEqual([])
+		})
+
+		it("returns [] for an empty journal file", async () => {
+			await fs.mkdir(path.dirname(journalPath(tmpRoot, taskId)), { recursive: true })
+			await fs.writeFile(journalPath(tmpRoot, taskId), "")
+
+			expect(await loadChanges(tmpRoot, taskId)).toEqual([])
+		})
+
+		it("parses all entries in order with a clean tail", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "x" }))
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "y" }))
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "z" }))
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result).toHaveLength(3)
+			expect(result[0].checkpointId).toBe("x")
+			expect(result[1].checkpointId).toBe("y")
+			expect(result[2].checkpointId).toBe("z")
+		})
+
+		it("parses a journal whose final line has no trailing newline", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "ok" }))
+
+			// Rewrite the file without the trailing newline of the last line.
+			const filePath = journalPath(tmpRoot, taskId)
+			const content = (await fs.readFile(filePath, "utf8")).replace(/\n$/, "")
+			await fs.writeFile(filePath, content)
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result).toHaveLength(1)
+			expect(result[0].checkpointId).toBe("ok")
+		})
+
+		it("discards a torn final line and returns the complete entries", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "ok" }))
+
+			// Append a second line truncated mid-content, with no trailing newline.
+			await fs.appendFile(journalPath(tmpRoot, taskId), '{"path":"src/half.ts","operation":"upd')
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result).toHaveLength(1)
+			expect(result[0].checkpointId).toBe("ok")
+		})
+
+		it("skips a corrupt middle line and still loads the later valid entries", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "ok" }))
+
+			// Corrupt the first line in place, then append a valid entry after it.
+			await fs.writeFile(
+				journalPath(tmpRoot, taskId),
+				'"{"path":"src/corrupt.ts","operation":"update"\n' +
+					JSON.stringify(entry({ checkpointId: "after" })) +
+					"\n",
+			)
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result).toHaveLength(1)
+			expect(result[0].checkpointId).toBe("after")
+		})
+
+		it("does not throw when the entire journal is torn", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "first" }))
+
+			// Truncate to a single character — definitely invalid JSON.
+			await fs.writeFile(journalPath(tmpRoot, taskId), "{")
+
+			expect(await loadChanges(tmpRoot, taskId)).toEqual([])
+		})
+
+		it("includes diffStats when present", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "s", diffStats: { additions: 5, deletions: 2 } }))
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result[0].diffStats).toEqual({ additions: 5, deletions: 2 })
+		})
+
+		it("omits diffStats when not provided", async () => {
+			await appendChange(tmpRoot, taskId, entry({ checkpointId: "n" }))
+
+			const result = await loadChanges(tmpRoot, taskId)
+			expect(result[0].diffStats).toBeUndefined()
+		})
+	})
+})
diff --git a/src/core/checkpoints/__tests__/index.checkpointJournal.test.ts b/src/core/checkpoints/__tests__/index.checkpointJournal.test.ts
new file mode 100644
index 0000000000..34bfc68852
--- /dev/null
+++ b/src/core/checkpoints/__tests__/index.checkpointJournal.test.ts
@@ -0,0 +1,225 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest"
+
+import type { Task } from "../../task/Task"
+import { loadChanges } from "../changeJournal"
+import { checkpointSave, type CheckpointWriteInfo } from "../index"
+
+// Mock the VS Code API surface (index.ts imports vscode at module level).
+vi.mock("vscode", () => ({
+	window: {
+		showErrorMessage: vi.fn(),
+		showInformationMessage: vi.fn(),
+		createTextEditorDecorationType: vi.fn(() => ({})),
+	},
+	Uri: {
+		file: vi.fn((p: string) => ({ fsPath: p })),
+		parse: vi.fn((uri: string) => ({ with: vi.fn(() => ({})) })),
+	},
+	commands: {
+		executeCommand: vi.fn(),
+	},
+}))
+
+vi.mock("@roo-code/telemetry", () => ({
+	TelemetryService: {
+		instance: {
+			captureCheckpointCreated: vi.fn(),
+			captureCheckpointRestored: vi.fn(),
+			captureCheckpointDiffed: vi.fn(),
+		},
+	},
+}))
+
+vi.mock("../../../utils/path", () => ({
+	getWorkspacePath: vi.fn(() => "/test/workspace"),
+}))
+
+vi.mock("../../../utils/git", () => ({
+	checkGitInstalled: vi.fn().mockResolvedValue(true),
+}))
+
+vi.mock("../../../i18n", () => ({
+	t: vi.fn((key: string) => key),
+}))
+
+vi.mock("p-wait-for", () => ({
+	default: vi.fn(),
+}))
+
+// The real service would require a git repo; the checkpointSave under test
+// only needs the pre-initialized service on the task.
+vi.mock("../../../services/checkpoints")
+
+const TASK_ID = "journal-test-task"
+const COMMIT = "test-commit-hash"
+
+interface ServiceLike {
+	isInitialized: boolean
+	saveCheckpoint: (...args: unknown[]) => Promise<unknown>
+}
+
+interface ProviderLike {
+	context: { globalStorageUri: { fsPath: string } }
+	log: (...args: unknown[]) => void
+	postMessageToWebview: (...args: unknown[]) => void
+}
+
+interface TaskLike {
+	taskId: string
+	enableCheckpoints: boolean
+	checkpointService: ServiceLike
+	checkpointServiceInitializing: boolean
+	providerRef: { deref: () => ProviderLike | undefined }
+}
+
+describe("checkpointSave change-journal wiring (B2)", () => {
+	let tmpStorageDir: string
+	let saveCheckpointSpy: Mock
+	let mockProvider: ProviderLike
+	let mockTask: TaskLike
+	const write: CheckpointWriteInfo = {
+		path: "src/foo.ts",
+		operation: "create",
+		diffStats: { additions: 3, deletions: 0 },
+	}
+
+	beforeEach(async () => {
+		tmpStorageDir = await fs.mkdtemp(path.join(os.tmpdir(), "b2-journal-wiring-"))
+		saveCheckpointSpy = vi.fn().mockResolvedValue({ commit: COMMIT })
+		mockProvider = {
+			context: { globalStorageUri: { fsPath: tmpStorageDir } },
+			log: vi.fn(),
+			postMessageToWebview: vi.fn(),
+		}
+		// Structural test double for Task (the class is not instantiated at
+		// this unit layer); the cast is safe because the fields checkpointSave
+		// reads are exactly these.
+		mockTask = {
+			taskId: TASK_ID,
+			enableCheckpoints: true,
+			checkpointService: { isInitialized: true, saveCheckpoint: saveCheckpointSpy },
+			checkpointServiceInitializing: false,
+			providerRef: { deref: () => mockProvider },
+		}
+	})
+
+	afterEach(async () => {
+		vi.restoreAllMocks()
+		await fs.rm(tmpStorageDir, { recursive: true, force: true })
+	})
+
+	it("appends exactly one journal line referencing the B1 checkpoint id for a per-write save", async () => {
+		await checkpointSave(mockTask as Task, false, true, write)
+
+		const entries = await loadChanges(tmpStorageDir, TASK_ID)
+		expect(entries).toHaveLength(1)
+		expect(entries[0]).toEqual({
+			path: "src/foo.ts",
+			operation: "create",
+			checkpointId: COMMIT,
+			diffStats: { additions: 3, deletions: 0 },
+		})
+
+		// The raw file holds exactly one JSON line.
+		const journalFile = path.join(tmpStorageDir, "tasks", TASK_ID, "checkpoints", "changes.jsonl")
+		const raw = await fs.readFile(journalFile, "utf8")
+		expect(raw.split("\n").filter((line) => line !== "")).toHaveLength(1)
+	})
+
+	it("omits diffStats in the journal entry when not provided", async () => {
+		await checkpointSave(mockTask as Task, false, true, { path: "src/bar.ts", operation: "update" })
+
+		const entries = await loadChanges(tmpStorageDir, TASK_ID)
+		expect(entries).toHaveLength(1)
+		expect(entries[0].path).toBe("src/bar.ts")
+		expect(entries[0].operation).toBe("update")
+		expect(entries[0].checkpointId).toBe(COMMIT)
+		expect(entries[0].diffStats).toBeUndefined()
+	})
+
+	it("does not write a journal entry for non-write checkpoint saves (task-start baseline)", async () => {
+		const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+		await checkpointSave(mockTask as Task)
+
+		// The default save keeps the documented behavior for both flags.
+		expect(saveCheckpointSpy).toHaveBeenCalledWith(expect.stringContaining(`Task: ${TASK_ID}`), {
+			allowEmpty: false,
+			suppressMessage: false,
+		})
+		const journalFile = path.join(tmpStorageDir, "tasks", TASK_ID, "checkpoints", "changes.jsonl")
+		await expect(fs.stat(journalFile)).rejects.toThrow()
+		expect(await loadChanges(tmpStorageDir, TASK_ID)).toEqual([])
+		// The baseline save must not reach the journal error path.
+		expect(consoleErrorSpy).not.toHaveBeenCalled()
+	})
+
+	it("appends one entry per file change for a multi-file write (apply-patch shape)", async () => {
+		await checkpointSave(mockTask as Task, false, true, [
+			{ path: "src/a.ts", operation: "create" },
+			{ path: "src/b.ts", operation: "update" },
+			{ path: "src/c.ts", operation: "delete" },
+		])
+
+		const entries = await loadChanges(tmpStorageDir, TASK_ID)
+		expect(entries).toHaveLength(3)
+		// Every entry references the single checkpoint of the whole patch.
+		expect(entries.map((entry) => entry.checkpointId)).toEqual([COMMIT, COMMIT, COMMIT])
+		expect(entries.map((entry) => entry.path)).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"])
+		expect(entries.map((entry) => entry.operation)).toEqual(["create", "update", "delete"])
+	})
+
+	it("keeps the existing error-swallowing behavior and skips the journal on save failure", async () => {
+		saveCheckpointSpy.mockRejectedValueOnce(new Error("git exploded"))
+
+		await expect(checkpointSave(mockTask as Task, false, true, write)).resolves.toBeUndefined()
+		expect(mockTask.enableCheckpoints).toBe(false)
+		expect(await loadChanges(tmpStorageDir, TASK_ID)).toEqual([])
+	})
+
+	it("does not write a journal entry when the checkpoint save is a no-op (empty commit)", async () => {
+		saveCheckpointSpy.mockResolvedValueOnce(undefined)
+		const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+		await checkpointSave(mockTask as Task, false, true, write)
+
+		expect(await loadChanges(tmpStorageDir, TASK_ID)).toEqual([])
+		expect(mockTask.enableCheckpoints).toBe(true)
+		// A no-op commit is skipped cleanly, not error-swallowed.
+		expect(consoleErrorSpy).not.toHaveBeenCalled()
+	})
+
+	it("does not crash when the provider has no globalStorageDir", async () => {
+		mockTask.providerRef = { deref: () => undefined }
+		const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+		await expect(checkpointSave(mockTask as Task, false, true, write)).resolves.toMatchObject({ commit: COMMIT })
+		expect(mockTask.enableCheckpoints).toBe(true)
+		expect(await loadChanges(tmpStorageDir, TASK_ID)).toEqual([])
+		// Without a storage dir the journal write is skipped, not error-swallowed.
+		expect(consoleErrorSpy).not.toHaveBeenCalled()
+	})
+
+	it("logs and continues when the journal cannot be written (checkpoints stay enabled)", async () => {
+		// Block the per-task checkpoint dir so the journal mkdir/append fails.
+		const taskDir = path.join(tmpStorageDir, "tasks", TASK_ID)
+		await fs.mkdir(taskDir, { recursive: true })
+		await fs.writeFile(path.join(taskDir, "checkpoints"), "blocker")
+
+		const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+
+		// The journal failure is swallowed (logged, not rethrown), so the
+		// checkpoint result still resolves exactly as without journaling.
+		await expect(checkpointSave(mockTask as Task, false, true, write)).resolves.toMatchObject({ commit: COMMIT })
+
+		expect(mockTask.enableCheckpoints).toBe(true)
+		expect(consoleErrorSpy).toHaveBeenCalledWith(
+			expect.stringContaining("failed to append change journal entry"),
+			expect.anything(),
+		)
+	})
+})
diff --git a/src/core/checkpoints/changeJournal.ts b/src/core/checkpoints/changeJournal.ts
new file mode 100644
index 0000000000..03ee27f955
--- /dev/null
+++ b/src/core/checkpoints/changeJournal.ts
@@ -0,0 +1,96 @@
+import fs from "fs/promises"
+import * as path from "path"
+
+/**
+ * A single entry in the per-task change journal (changes.jsonl).
+ *
+ * One line is appended for every successful file write that goes through a
+ * B1 per-write checkpoint hook.  WriteToFileTool and EditFileTool emit one
+ * entry per write; ApplyPatchTool emits one entry per file change of a fully
+ * successful patch — those entries all reference the single B1 checkpoint
+ * that the patch's post-loop hook saves for the whole patch.  The task-start
+ * baseline never produces an entry (it is not a file write).
+ */
+export interface ChangeJournalEntry {
+	/** The file path as the tool knows it (relative to task cwd). */
+	path: string
+	/** "create" | "update" | "delete" — derived from what the tool did. */
+	operation: "create" | "update" | "delete"
+	/** The B1 checkpoint commit SHA for this write (from checkpointSave result). */
+	checkpointId: string
+	/** { additions, deletions } from the approval diff; null/omit when not computable. */
+	diffStats?: { additions: number; deletions: number }
+}
+
+/** Derive the per-task checkpoint directory from globalStorageDir and taskId. */
+function taskCheckpointDir(globalStorageDir: string, taskId: string): string {
+	return path.join(globalStorageDir, "tasks", taskId, "checkpoints")
+}
+
+/** Journal file path for a given task. */
+export function journalPath(globalStorageDir: string, taskId: string): string {
+	// The filename literal lives inside this function body (not at module
+	// scope) so mutation testing can exercise it at runtime.
+	return path.join(taskCheckpointDir(globalStorageDir, taskId), "changes.jsonl")
+}
+
+/**
+ * Append one change-journal entry to the per-task changes.jsonl file.
+ *
+ * Uses appendFile so each write is a single syscall — minimal torn-write risk.
+ * Creates parent directories if they don't exist yet (e.g. first checkpoint).
+ */
+export async function appendChange(globalStorageDir: string, taskId: string, entry: ChangeJournalEntry): Promise<void> {
+	const filePath = journalPath(globalStorageDir, taskId)
+	await fs.mkdir(path.dirname(filePath), { recursive: true })
+	const line = JSON.stringify(entry) + "\n"
+	await fs.appendFile(filePath, line)
+}
+
+/**
+ * Load all change-journal entries for a task.
+ *
+ * Torn-tail repair: if the final line is truncated (JSON.parse fails), it is
+ * silently discarded.  The rest of the file is returned in order.  An absent
+ * or empty journal returns [].
+ */
+export async function loadChanges(globalStorageDir: string, taskId: string): Promise<ChangeJournalEntry[]> {
+	const filePath = journalPath(globalStorageDir, taskId)
+
+	let content: string
+	try {
+		content = await fs.readFile(filePath, "utf8")
+	} catch {
+		// File absent or unreadable → empty journal.
+		return []
+	}
+
+	// Stryker disable next-line ConditionalExpression,MethodExpression : equivalent - an empty or whitespace-only journal reaches the same [] through the parse loop's JSON.parse catch below
+	if (!content.trim()) {
+		return []
+	}
+
+	const lines = content.split("\n")
+	// Remove trailing empty line from a file that ends with \n.
+	// Stryker disable next-line ConditionalExpression,ArithmeticOperator,StringLiteral : equivalent - skipping the pop leaves the trailing empty line, which the parse loop's JSON.parse catch below discards identically
+	if (lines[lines.length - 1] === "") {
+		// Stryker disable next-line CallExpression : equivalent - the trailing empty line is discarded identically by the parse loop's JSON.parse catch
+		lines.pop()
+	}
+
+	const entries: ChangeJournalEntry[] = []
+	// Stryker disable next-line EqualityOperator : equivalent - the extra iteration reads undefined, whose JSON.parse throws and the catch below swallows
+	for (let i = 0; i < lines.length; i++) {
+		try {
+			entries.push(JSON.parse(lines[i]) as ChangeJournalEntry)
+		} catch {
+			// A corrupt line before the final line (e.g. a partially flushed
+			// append) must not hide the valid entries after it. The final line
+			// is still discarded as a torn tail — `continue` at the last index
+			// ends the loop either way.
+			continue
+		}
+	}
+
+	return entries
+}
diff --git a/src/core/checkpoints/index.ts b/src/core/checkpoints/index.ts
index 26a137b939..bcfafb5cd6 100644
--- a/src/core/checkpoints/index.ts
+++ b/src/core/checkpoints/index.ts
@@ -16,6 +16,8 @@ import { DIFF_VIEW_URI_SCHEME } from "../../integrations/editor/DiffViewProvider
 
 import { CheckpointServiceOptions, RepoPerTaskCheckpointService } from "../../services/checkpoints"
 
+import { appendChange, ChangeJournalEntry } from "./changeJournal"
+
 const WARNING_THRESHOLD_MS = 5000
 
 function sendCheckpointInitWarn(task: Task, type?: "WAIT_TIMEOUT" | "INIT_TIMEOUT", timeout?: number) {
@@ -209,7 +211,28 @@ async function checkGitInstallation(
 	}
 }
 
-export async function checkpointSave(task: Task, force = false, suppressMessage = false) {
+/**
+ * Write metadata for the per-task change journal (B2).
+ *
+ * `path` is the file path as the tool knows it (relative to the task cwd),
+ * consistent with what the B1 per-write checkpoint hooks see. `diffStats` is
+ * the { additions, deletions } pair from the approval diff when it was
+ * computable; omitted otherwise. ApplyPatchTool passes one entry per file
+ * change of a fully successful patch (an array), all sharing the single
+ * checkpoint the patch's post-loop hook saves.
+ */
+export type CheckpointWriteInfo = {
+	path: string
+	operation: "create" | "update" | "delete"
+	diffStats?: { additions: number; deletions: number }
+}
+
+export async function checkpointSave(
+	task: Task,
+	force = false,
+	suppressMessage = false,
+	write?: CheckpointWriteInfo | CheckpointWriteInfo[],
+) {
 	const service = await getCheckpointService(task)
 
 	if (!service) {
@@ -221,6 +244,34 @@ export async function checkpointSave(task: Task, force = false, suppressMessage
 	// Start the checkpoint process in the background.
 	return service
 		.saveCheckpoint(`Task: ${task.taskId}, Time: ${Date.now()}`, { allowEmpty: force, suppressMessage })
+		.then(async (result) => {
+			// B2: record successful file writes in the per-task change journal.
+			// Only a real commit produces an entry (an empty or failed save
+			// resolves to undefined / rejects), and non-write checkpoint calls
+			// (e.g. the task-start baseline) pass no `write` value at all.
+			if (result?.commit && write) {
+				const globalStorageDir = task.providerRef.deref()?.context.globalStorageUri.fsPath
+				if (globalStorageDir) {
+					const writes = Array.isArray(write) ? write : [write]
+					// Append sequentially so journal lines preserve write order. A
+					// journal failure is logged here and never propagates to the
+					// checkpoint error handler (checkpoints stay enabled).
+					try {
+						for (const w of writes) {
+							await appendChange(globalStorageDir, task.taskId, {
+								path: w.path,
+								operation: w.operation,
+								checkpointId: result.commit,
+								...(w.diffStats ? { diffStats: w.diffStats } : {}),
+							})
+						}
+					} catch (err) {
+						console.error("[Task#checkpointSave] failed to append change journal entry", err)
+					}
+				}
+			}
+			return result
+		})
 		.catch((err) => {
 			console.error("[Task#checkpointSave] caught unexpected error, disabling checkpoints", err)
 			task.enableCheckpoints = false