[Fix] Subtasks fail to return when users work across windows

packages/core/src/task-history/__tests__/task-history.spec.ts

@@ -2,7 +2,17 @@ import * as fs from "fs/promises"
 import * as os from "os"
 import * as path from "path"
 
-import { readTaskSessionsFromStoragePath } from "../index.js"
+import type { HistoryItem } from "@roo-code/types"
+
+import {
+	ABSENT_TASK_FILE_PREIMAGE,
+	INVALID_TASK_FILE_PREIMAGE,
+	expectedTaskFileStates,
+	isValidTaskFilePreImage,
+	matchesExpectedHistoryItem,
+	readTaskSessionsFromStoragePath,
+	taskFilePreImage,
+} from "../index.js"
 
 describe("readTaskSessionsFromStoragePath", () => {
 	let tempDir: string
@@ -112,3 +122,37 @@ describe("readTaskSessionsFromStoragePath", () => {
 		await expect(readTaskSessionsFromStoragePath(tempDir)).resolves.toEqual([])
 	})
 })
+
+describe("task file pre-images", () => {
+	const item: HistoryItem = {
+		id: "task-1",
+		number: 1,
+		ts: 1,
+		task: "Task",
+		tokensIn: 0,
+		tokensOut: 0,
+		totalCost: 0,
+	}
+
+	it("distinguishes validated, absent, and invalid pre-images", () => {
+		const valid = taskFilePreImage(item, item.id, true)
+		expect(valid).toEqual(item)
+		expect(valid).not.toBe(item)
+		expect(taskFilePreImage(null, item.id, false)).toBe(ABSENT_TASK_FILE_PREIMAGE)
+		expect(taskFilePreImage(null, item.id, true)).toBe(INVALID_TASK_FILE_PREIMAGE)
+		expect(taskFilePreImage({ ...item, id: "other" }, item.id, true)).toBe(INVALID_TASK_FILE_PREIMAGE)
+		expect(taskFilePreImage({ ...item, id: "other" }, item.id, false)).toBe(INVALID_TASK_FILE_PREIMAGE)
+		expect(taskFilePreImage({ id: item.id }, item.id, true)).toBe(INVALID_TASK_FILE_PREIMAGE)
+	})
+
+	it("recognizes valid snapshots and expected records", () => {
+		expect(isValidTaskFilePreImage(item)).toBe(true)
+		expect(isValidTaskFilePreImage(ABSENT_TASK_FILE_PREIMAGE)).toBe(false)
+		expect(isValidTaskFilePreImage(INVALID_TASK_FILE_PREIMAGE)).toBe(false)
+		expect(expectedTaskFileStates(item, { ...item })).toEqual([item, item])
+		expect(expectedTaskFileStates(item, ABSENT_TASK_FILE_PREIMAGE)).toEqual([item])
+		expect(expectedTaskFileStates(item, INVALID_TASK_FILE_PREIMAGE)).toEqual([item])
+		expect(matchesExpectedHistoryItem(item, [{ ...item }], (left, right) => left.id === right.id)).toBe(true)
+		expect(matchesExpectedHistoryItem(item, [], (left, right) => left.id === right.id)).toBe(false)
+	})
+})

packages/core/src/task-history/index.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises"
 import * as path from "path"
 
-import type { HistoryItem } from "@roo-code/types"
+import { historyItemSchema, type HistoryItem } from "@roo-code/types"
 
 const HISTORY_ITEM_FILENAME = "history_item.json"
 const HISTORY_INDEX_FILENAME = "_index.json"
@@ -15,6 +15,34 @@ export interface TaskSessionEntry {
 	status?: HistoryItem["status"]
 }
 
+export const ABSENT_TASK_FILE_PREIMAGE = "absent" as const
+export const INVALID_TASK_FILE_PREIMAGE = "invalid" as const
+export type TaskFilePreImage = HistoryItem | typeof ABSENT_TASK_FILE_PREIMAGE | typeof INVALID_TASK_FILE_PREIMAGE
+
+export function taskFilePreImage(existing: unknown, taskId: string, fileExists: boolean): TaskFilePreImage {
+	const parsed = historyItemSchema.safeParse(existing)
+	if (parsed.success && parsed.data.id === taskId) return structuredClone(existing as HistoryItem)
+	if (existing !== null) return INVALID_TASK_FILE_PREIMAGE
+	if (fileExists) return INVALID_TASK_FILE_PREIMAGE
+	return ABSENT_TASK_FILE_PREIMAGE
+}
+
+export function isValidTaskFilePreImage(preImage: TaskFilePreImage): preImage is HistoryItem {
+	return preImage !== ABSENT_TASK_FILE_PREIMAGE && preImage !== INVALID_TASK_FILE_PREIMAGE
+}
+
+export function expectedTaskFileStates(written: HistoryItem, preImage: TaskFilePreImage): HistoryItem[] {
+	return isValidTaskFilePreImage(preImage) ? [written, preImage] : [written]
+}
+
+export function matchesExpectedHistoryItem(
+	item: HistoryItem,
+	expected: readonly HistoryItem[],
+	equals: (left: HistoryItem, right: HistoryItem) => boolean,
+): boolean {
+	return expected.some((candidate) => equals(item, candidate))
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null
 }