@@ -78,12 +78,11 @@ interface DelegationRepairIntent {
  * A single index file (`globalStorage/tasks/_index.json`) is maintained
  * as a cache for fast list reads at startup.
  *
- * Cross-process safety for per-task files comes from `safeWriteJson`'s
- * `proper-lockfile`. The shared `_index.json` is a best-effort startup
- * cache: it may lag or miss entries from other hosts, but
- * `reconcile()` rebuilds from authoritative per-task files — at startup
- * (`forceRefresh: true`), via `fs.watch`, and on a 5-minute periodic
- * fallback. Within a single extension host process,
+ * Cross-process safety for per-task files and `_index.json` comes from
+ * `safeWriteJson`'s `proper-lockfile` with a `merge` callback: each
+ * write reads the current file under the advisory lock and merges
+ * incoming fields, so a concurrent writer's changes are preserved
+ * rather than silently dropped. Within a single extension host process,
  * an in-process write lock serializes mutations.
  */
 /**
@@ -261,8 +260,15 @@ export class TaskHistoryStore {
 		// Merge: preserve existing metadata unless explicitly overwritten
 		const merged = existing ? { ...existing, ...item } : item
 
-		// Write per-task file (source of truth)
-		await this.writeTaskFile(merged)
+		// Compute the actual changed fields relative to the cached state.
+		// Only these are applied to the disk version, so fields updated by
+		// another process are preserved rather than reverted from a stale cache.
+		const delta = existing
+			? Object.fromEntries(
+					Object.entries(item).filter(([k, v]) => !deepEqual(v, (existing as Record<string, unknown>)[k])),
+				)
+			: undefined
+		await this.writeTaskFile(merged, delta ? ({ id: item.id, ...delta } as HistoryItem) : undefined)
 
 		// Update in-memory cache
 		this.cache.set(merged.id, merged)
@@ -884,17 +890,46 @@ export class TaskHistoryStore {
 	}
 
 	/**
-	 * Write the full index to disk.
+	 * Write the index to disk, merging entries from other hosts.
+	 *
+	 * Peer entries (task ids present on disk but absent from this host's
+	 * cache) are kept only if their task directory still exists, so a
+	 * local delete propagates instead of being undone by the merge.
 	 */
 	private async writeIndex(): Promise<void> {
 		const indexPath = await this.getIndexPath()
+		const tasksDir = await this.getTasksDir()
 		const index: HistoryIndex = {
 			version: 1,
 			updatedAt: Date.now(),
 			entries: this.getAll(),
 		}
 
-		await safeWriteJson(indexPath, index)
+		let onDiskIds: Set<string>
+		try {
+			const dirEntries = await fs.readdir(tasksDir)
+			onDiskIds = new Set(dirEntries.filter((n) => !n.startsWith("_") && !n.startsWith(".")))
+		} catch {
+			onDiskIds = new Set()
+		}
+
+		await safeWriteJson(indexPath, index, {
+			merge: (existing, incoming) => {
+				if (!existing || existing.version !== 1 || !Array.isArray(existing.entries)) {
+					return incoming
+				}
+				const ourIds = new Set(incoming.entries.map((e: HistoryItem) => e.id))
+				const peerEntries = existing.entries.filter(
+					(e: HistoryItem) => e.id && !ourIds.has(e.id) && onDiskIds.has(e.id),
+				)
+				return {
+					...incoming,
+					entries: [...incoming.entries, ...peerEntries].sort(
+						(a: HistoryItem, b: HistoryItem) => b.ts - a.ts,
+					),
+				}
+			},
+		})
 	}
 
 	/**
@@ -935,10 +970,26 @@ export class TaskHistoryStore {
 
 	/**
 	 * Write a HistoryItem to its per-task `history_item.json` file.
+	 *
+	 * When `delta` is provided, the merge callback applies only the
+	 * delta to the current disk state, so fields written by another
+	 * process are preserved. Without a delta the full item is written
+	 * as-is (used by administrative repair paths that are authoritative).
 	 */
-	private async writeTaskFile(item: HistoryItem): Promise<void> {
+	private async writeTaskFile(item: HistoryItem, delta?: Partial<HistoryItem>): Promise<void> {
 		const filePath = await this.getTaskFilePath(item.id)
-		await safeWriteJson(filePath, item)
+		if (delta) {
+			await safeWriteJson(filePath, item, {
+				merge: (existing, incoming) => {
+					if (!existing || typeof existing !== "object" || !("id" in existing)) {
+						return incoming
+					}
+					return { ...existing, ...delta }
+				},
+			})
+		} else {
+			await safeWriteJson(filePath, item)
+		}
 	}
 
 	/**
@@ -1109,10 +1160,18 @@ export class TaskHistoryStore {
 			const mergedFirst = { ...first, ...updatedFirst }
 			const mergedSecond = { ...second, ...updatedSecond }
 
+			// Compute actual diffs against cached state, mirroring upsertCore.
+			const deltaFirst = Object.fromEntries(
+				Object.entries(updatedFirst).filter(([k, v]) => !deepEqual(v, (first as Record<string, unknown>)[k])),
+			)
+			const deltaSecond = Object.fromEntries(
+				Object.entries(updatedSecond).filter(([k, v]) => !deepEqual(v, (second as Record<string, unknown>)[k])),
+			)
+
 			// Write both files before touching the cache so readers never observe a
 			// half-updated in-memory state between the two await points.
-			await this.writeTaskFile(mergedFirst)
-			await this.writeTaskFile(mergedSecond)
+			await this.writeTaskFile(mergedFirst, { id: firstId, ...deltaFirst } as HistoryItem)
+			await this.writeTaskFile(mergedSecond, { id: secondId, ...deltaSecond } as HistoryItem)
 
 			// Both disk writes succeeded — now update the cache atomically.
 			this.cache.set(firstId, mergedFirst)
 
@@ -15,12 +15,30 @@ vi.mock("../../../utils/storage", () => ({
 	}),
 }))
 
-// Mock safeWriteJson to use plain fs writes in tests (avoids proper-lockfile issues)
+// Mock safeWriteJson to use plain fs writes but honor the merge callback.
 vi.mock("../../../utils/safeWriteJson", () => ({
-	safeWriteJson: vi.fn().mockImplementation(async (filePath: string, data: any) => {
-		await fs.mkdir(path.dirname(filePath), { recursive: true })
-		await fs.writeFile(filePath, JSON.stringify(data, null, "\t"), "utf8")
-	}),
+	safeWriteJson: vi
+		.fn()
+		.mockImplementation(
+			async (
+				filePath: string,
+				data: unknown,
+				options?: { merge?: (existing: unknown, incoming: unknown) => unknown },
+			) => {
+				await fs.mkdir(path.dirname(filePath), { recursive: true })
+				if (options?.merge) {
+					let existing: unknown = null
+					try {
+						const raw = await fs.readFile(filePath, "utf8")
+						existing = JSON.parse(raw)
+					} catch {
+						// File does not exist or is corrupt
+					}
+					data = options.merge(existing, data)
+				}
+				await fs.writeFile(filePath, JSON.stringify(data, null, "\t"), "utf8")
+			},
+		),
 }))
 
 function makeHistoryItem(overrides: Partial<HistoryItem> = {}): HistoryItem {
@@ -166,12 +184,12 @@ describe("TaskHistoryStore cross-instance safety", () => {
 	})
 
 	/**
-	 * Regression for #1231: two hosts each hold only their own task in cache and
-	 * flush `_index.json` without watcher reconciliation. The last writer's
-	 * index reflects only its own cache (LWW). Per-task files remain intact,
-	 * and reconcile recovers the full set.
+	 * Two hosts each hold only their own task in cache
+	 * and flush `_index.json` without watcher reconciliation. The merge
+	 * callback in writeIndex preserves peer entries so neither host's
+	 * flush drops the other's task.
 	 */
-	it("reconcile recovers peer entries after a last-writer-wins index flush", async () => {
+	it("index flush merges peer entries instead of clobbering them", async () => {
 		await storeA.initialize()
 		await storeB.initialize()
 
@@ -181,6 +199,7 @@ describe("TaskHistoryStore cross-instance safety", () => {
 		await storeA.upsert(makeHistoryItem({ id: "task-a", task: "from A", ts: 1000 }))
 		await storeB.upsert(makeHistoryItem({ id: "task-b", task: "from B", ts: 2000 }))
 
+		// Each cache is intentionally partial.
 		expect(storeA.get("task-a")).toBeDefined()
 		expect(storeA.get("task-b")).toBeUndefined()
 		expect(storeB.get("task-b")).toBeDefined()
@@ -189,28 +208,97 @@ describe("TaskHistoryStore cross-instance safety", () => {
 		await storeA.flushIndex()
 		await storeB.flushIndex()
 
-		// Per-task files survive regardless of which host flushed last.
+		// Both entries survive in the index — no reconcile needed.
 		const tasksDir = path.join(tmpDir, "tasks")
+		const indexRaw = await fs.readFile(path.join(tasksDir, GlobalFileNames.historyIndex), "utf8")
+		const index = JSON.parse(indexRaw) as { entries: HistoryItem[] }
+		const indexIds = index.entries.map((entry) => entry.id).sort()
+		expect(indexIds).toEqual(["task-a", "task-b"])
+	})
 
-		// The index reflects the last writer's partial cache (LWW clobber).
-		const indexRawBefore = await fs.readFile(path.join(tasksDir, GlobalFileNames.historyIndex), "utf8")
-		const indexBefore = JSON.parse(indexRawBefore) as { entries: HistoryItem[] }
-		expect(indexBefore.entries.map((e) => e.id)).toEqual(["task-b"])
-		const taskDirs = (await fs.readdir(tasksDir)).filter((name) => !name.startsWith("_") && !name.startsWith("."))
-		expect(taskDirs.sort()).toEqual(["task-a", "task-b"])
+	/**
+	 * A deleted task must not reappear in the index after a subsequent flush.
+	 * The merge keeps peer entries only if their task directory exists.
+	 */
+	it("index flush does not resurrect deleted tasks via the merge", async () => {
+		await storeA.initialize()
+		await storeB.initialize()
 
-		// Reconcile rebuilds the full picture from authoritative per-task files.
-		await storeA.reconcile({ forceRefresh: true })
-		expect(storeA.get("task-a")).toBeDefined()
-		expect(storeA.get("task-b")).toBeDefined()
-		expect(storeA.getAll()).toHaveLength(2)
+		disableBackgroundReconciliation(storeA)
+		disableBackgroundReconciliation(storeB)
+
+		await storeA.upsert(makeHistoryItem({ id: "keep", ts: 1000 }))
+		await storeA.upsert(makeHistoryItem({ id: "doomed", ts: 2000 }))
+		await storeA.flushIndex()
+
+		// Delete doomed — removes from cache and unlinks the file.
+		await storeA.delete("doomed")
+		const taskDir = path.join(tmpDir, "tasks", "doomed")
+		await fs.rm(taskDir, { recursive: true, force: true })
 
-		// A post-reconcile flush writes the complete set.
+		// Flush again — the merge must not re-add "doomed" from the old index.
 		await storeA.flushIndex()
+
+		const tasksDir = path.join(tmpDir, "tasks")
 		const indexRaw = await fs.readFile(path.join(tasksDir, GlobalFileNames.historyIndex), "utf8")
 		const index = JSON.parse(indexRaw) as { entries: HistoryItem[] }
 		const indexIds = index.entries.map((entry) => entry.id).sort()
-		expect(indexIds).toEqual(["task-a", "task-b"])
+		expect(indexIds).toEqual(["keep"])
+	})
+
+	/**
+	 * Host B completes a task on disk while host A's cache still has it
+	 * active. Host A's next save updates only totalCost (a full-object
+	 * upsert — the realistic production shape). The diff-delta merge
+	 * preserves B's status because status did not change in A's cache.
+	 */
+	it("per-task diff-delta preserves a peer's status change on full-object upsert", async () => {
+		await storeA.initialize()
+
+		// Base item with an explicit status — mirrors real production items.
+		const base = makeHistoryItem({ id: "shared-task", status: "active", totalCost: 0.01, ts: 1000 })
+		await storeA.upsert(base)
+
+		// Host B completes the task on disk; A's cache still has "active".
+		const filePath = path.join(tmpDir, "tasks", "shared-task", GlobalFileNames.historyItem)
+		const onDisk = JSON.parse(await fs.readFile(filePath, "utf8"))
+		onDisk.status = "completed"
+		onDisk.completionResultSummary = "done by host B"
+		await fs.writeFile(filePath, JSON.stringify(onDisk), "utf8")
+
+		// Host A does a full-object upsert (the realistic path — spread the
+		// cached item and change one field). The cached item has status: "active".
+		await storeA.upsert({ ...storeA.get("shared-task")!, totalCost: 9.99 })
+
+		const final = JSON.parse(await fs.readFile(filePath, "utf8")) as HistoryItem
+		expect(final.totalCost).toBe(9.99)
+		// Status is preserved from disk because A's delta does not include
+		// status — it was unchanged relative to A's cache.
+		expect(final.status).toBe("completed")
+		expect(final.completionResultSummary).toBe("done by host B")
+	})
+
+	/**
+	 * When both hosts change the same field, the last writer wins.
+	 * This is expected — true conflict resolution requires application
+	 * semantics that a generic merge cannot provide.
+	 */
+	it("same-field changes from both hosts are last-writer-wins", async () => {
+		await storeA.initialize()
+		await storeB.initialize()
+
+		const base = makeHistoryItem({ id: "shared-task", status: "active", totalCost: 0.01, ts: 1000 })
+		await storeA.upsert(base)
+		await storeB.reconcile()
+
+		// Both hosts change totalCost.
+		await storeA.upsert({ ...storeA.get("shared-task")!, totalCost: 1.0 })
+		await storeB.upsert({ ...storeB.get("shared-task")!, totalCost: 2.0 })
+
+		const filePath = path.join(tmpDir, "tasks", "shared-task", GlobalFileNames.historyItem)
+		const final = JSON.parse(await fs.readFile(filePath, "utf8")) as HistoryItem
+		// B wrote last, so B's value wins.
+		expect(final.totalCost).toBe(2.0)
 	})
 })
 
 
@@ -779,11 +779,6 @@
 			"count": 4
 		}
 	},
-	"core/task-persistence/__tests__/TaskHistoryStore.crossInstance.spec.ts": {
-		"@typescript-eslint/no-explicit-any": {
-			"count": 1
-		}
-	},
 	"core/task-persistence/__tests__/TaskHistoryStore.spec.ts": {
 		"@typescript-eslint/no-explicit-any": {
 			"count": 4
 
@@ -468,4 +468,40 @@ describe("safeWriteJson", () => {
 
 		consoleErrorSpy.mockRestore()
 	})
+
+	// Merge option tests
+	test("should merge incoming data with existing file content when merge callback is provided", async () => {
+		const initial = { a: 1, b: 2 }
+		await safeWriteJson(currentTestFilePath, initial)
+
+		const incoming = { b: 3, c: 4 }
+		await safeWriteJson(currentTestFilePath, incoming, {
+			merge: (existing, data) => ({ ...existing, ...data }),
+		})
+
+		const content = await readFileContent(currentTestFilePath)
+		expect(content).toEqual({ a: 1, b: 3, c: 4 })
+	})
+
+	test("should pass null to merge callback when file does not exist", async () => {
+		const newFilePath = path.join(tempDir, "nonexistent.json")
+		const mergeFn = vi.fn((existing, incoming) => incoming)
+
+		await safeWriteJson(newFilePath, { value: 42 }, { merge: mergeFn })
+
+		expect(mergeFn).toHaveBeenCalledWith(null, { value: 42 })
+		const content = await readFileContent(newFilePath)
+		expect(content).toEqual({ value: 42 })
+	})
+
+	test("should write incoming data directly when no merge callback is provided", async () => {
+		const initial = { a: 1, b: 2 }
+		await safeWriteJson(currentTestFilePath, initial)
+
+		const replacement = { c: 3 }
+		await safeWriteJson(currentTestFilePath, replacement)
+
+		const content = await readFileContent(currentTestFilePath)
+		expect(content).toEqual({ c: 3 })
+	})
 })
@@ -15,6 +15,16 @@ export interface SafeWriteJsonOptions {
 	 * @default false
 	 */
 	prettyPrint?: boolean
+
+	/**
+	 * When provided, the current file is read under the advisory lock
+	 * and passed to this function along with the incoming data. The
+	 * return value replaces `data` for the write. This turns a blind
+	 * overwrite into an atomic read-modify-write, preventing cross-process
+	 * lost updates. `existing` is null when the file does not exist or
+	 * cannot be parsed.
+	 */
+	merge?: (existing: unknown, incoming: unknown) => unknown
 }
 
 /**
@@ -78,6 +88,19 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso
 		throw lockError
 	}
 
+	// If a merge callback was provided, read the current file under the lock
+	// and let the caller merge before we write.
+	if (options?.merge) {
+		let existing: unknown = null
+		try {
+			const raw = await fs.readFile(absoluteFilePath, "utf8")
+			existing = JSON.parse(raw)
+		} catch {
+			// No readable file yet, so the merge receives null.
+		}
+		data = options.merge(existing, data)
+	}
+
 	// Variables to hold the actual paths of temp files if they are created.
 	let actualTempNewFilePath: string | null = null
 	let actualTempBackupFilePath: string | null = null