@myrialabs/clopen 0.1.9 → 0.1.10

package/backend/index.ts

@@ -118,7 +118,11 @@ async function startServer() {
 		port: actualPort,
 		hostname: HOST
 	}, () => {
-		console.log(`🚀 Clopen running at http://localhost:${actualPort}`);
+		if (isDevelopment) {
+			console.log('🚀 Backend ready — waiting for frontend...');
+		} else {
+			console.log(`🚀 Clopen running at http://localhost:${actualPort}`);
+		}
 		if (HOST === '0.0.0.0') {
 			const ips = getLocalIps();
 			for (const ip of ips) {

package/backend/lib/chat/stream-manager.ts

@@ -891,7 +891,10 @@ class StreamManager extends EventEmitter {
 			const { projectPath, projectId, chatSessionId } = requestData;
 			if (projectPath && projectId && chatSessionId && userMessageId) {
 				snapshotService.captureSnapshot(projectPath, projectId, chatSessionId, userMessageId)
-					.then(() => debug.log('chat', `Stream-end snapshot captured for message: ${userMessageId}`))
+					.then(() => {
+						debug.log('chat', `Stream-end snapshot captured for message: ${userMessageId}`);
+						this.emit('snapshot:captured', { projectId, chatSessionId });
+					})
 					.catch(err => debug.error('chat', 'Failed to capture stream-end snapshot:', err));
 			}
 		}

package/backend/lib/database/queries/session-queries.ts

@@ -188,6 +188,19 @@ export const sessionQueries = {
 		`).run(messageId, sessionId);
 	},
 
+	/**
+	 * Clear the HEAD pointer (set to NULL).
+	 * Used when restoring to the initial state (before any messages).
+	 */
+	clearHead(sessionId: string): void {
+		const db = getDatabase();
+		db.prepare(`
+			UPDATE chat_sessions
+			SET current_head_message_id = NULL
+			WHERE id = ?
+		`).run(sessionId);
+	},
+
 	/**
 	 * Get current HEAD message ID for a session
 	 */

package/backend/lib/database/queries/snapshot-queries.ts

@@ -114,7 +114,7 @@ export const snapshotQueries = {
 		const db = getDatabase();
 		const snapshots = db.prepare(`
 			SELECT * FROM message_snapshots
-			WHERE session_id = ?
+			WHERE session_id = ? AND (is_deleted IS NULL OR is_deleted = 0)
 			ORDER BY created_at ASC
 		`).all(sessionId) as MessageSnapshot[];
 

package/backend/lib/engine/adapters/opencode/server.ts

@@ -81,6 +81,14 @@ export function getClient(): OpencodeClient | null {
 	return ready ? client : null;
 }
 
+/**
+ * Get the OpenCode server base URL (e.g. "http://127.0.0.1:4096").
+ * Used for direct HTTP calls to v2 endpoints not available on the v1 client.
+ */
+export function getServerUrl(): string | null {
+	return serverHandle?.url ?? null;
+}
+
 /**
  * Dispose the OpenCode client and stop the server.
  * Called during full server shutdown (disposeAllEngines).

package/backend/lib/engine/adapters/opencode/stream.ts

@@ -40,7 +40,7 @@ import {
 	convertSubtaskToolUseOnly,
 	getToolInput,
 } from './message-converter';
-import { ensureClient, getClient } from './server';
+import { ensureClient, getClient, getServerUrl } from './server';
 import { debug } from '$shared/utils/logger';
 
 /** Map SDK Model.status to our category */
@@ -75,6 +75,8 @@ export class OpenCodeEngine implements AIEngine {
 	private activeAbortController: AbortController | null = null;
 	private activeSessionId: string | null = null;
 	private activeProjectPath: string | null = null;
+	/** Pending question requests keyed by tool callID → { requestId, questions } */
+	private pendingQuestions = new Map<string, { requestId: string; questions: Array<{ question: string }> }>();
 
 	get isInitialized(): boolean {
 		return this._isInitialized;
@@ -102,6 +104,7 @@ export class OpenCodeEngine implements AIEngine {
 	 */
 	async dispose(): Promise<void> {
 		await this.cancel();
+		this.pendingQuestions.clear();
 		this._isInitialized = false;
 		debug.log('engine', 'Open Code engine instance disposed');
 	}
@@ -664,6 +667,39 @@ export class OpenCodeEngine implements AIEngine {
 							break;
 						}
 
+						// v2 question event — emitted when the question tool needs user input
+						case 'question.asked': {
+							const props = evt.properties as {
+								id: string;
+								sessionID: string;
+								questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string }> }>;
+								tool?: { messageID: string; callID: string };
+							};
+							if (props.sessionID !== sessionId) break;
+							if (props.tool?.callID) {
+								this.pendingQuestions.set(props.tool.callID, {
+									requestId: props.id,
+									questions: props.questions,
+								});
+								debug.log('engine', `[OC] question.asked: stored question ${props.id} for callID ${props.tool.callID}`);
+							}
+							break;
+						}
+
+						// v2 permission event — auto-approve to avoid blocking the session
+						// (tool permissions like file_write, bash, etc. are bypassed)
+						case 'permission.asked':
+						case 'permission.updated': {
+							const props = evt.properties as {
+								id: string;
+								sessionID: string;
+								callID?: string;
+							};
+							if (props.sessionID !== sessionId) break;
+							this.autoApprovePermission(props.id, props.sessionID);
+							break;
+						}
+
 						case 'session.error': {
 							const errorProps = (event as EventSessionError).properties;
 							// Only handle errors for our session (sessionID is optional on errors)
@@ -729,6 +765,7 @@ export class OpenCodeEngine implements AIEngine {
 			this.activeAbortController = null;
 			this.activeSessionId = null;
 			this.activeProjectPath = null;
+			this.pendingQuestions.clear();
 		}
 	}
 
@@ -754,6 +791,7 @@ export class OpenCodeEngine implements AIEngine {
 		this._isActive = false;
 		this.activeSessionId = null;
 		this.activeProjectPath = null;
+		this.pendingQuestions.clear();
 	}
 
 	/**
@@ -779,6 +817,142 @@ export class OpenCodeEngine implements AIEngine {
 		await this.cancel();
 	}
 
+	/**
+	 * Resolve a pending AskUserQuestion by replying via the OpenCode question API.
+	 *
+	 * Flow:
+	 * 1. If a `question.asked` event was received → use stored requestId to reply
+	 * 2. Fallback → fetch pending questions from GET /question and match by callID
+	 *
+	 * The reply is sent to POST /question/{requestID}/reply with answers
+	 * ordered by the original questions array.
+	 */
+	resolveUserAnswer(toolUseId: string, answers: Record<string, string>): boolean {
+		const pending = this.pendingQuestions.get(toolUseId);
+
+		if (pending) {
+			// Convert Record<questionText, answerLabel> → Array<Array<string>> ordered by questions
+			const orderedAnswers = pending.questions.map(q => {
+				const answer = answers[q.question];
+				return answer ? [answer] : [];
+			});
+			this.replyToQuestion(pending.requestId, orderedAnswers);
+			this.pendingQuestions.delete(toolUseId);
+			return true;
+		}
+
+		// Fallback: fetch pending questions from the API and find matching one
+		debug.log('engine', `resolveUserAnswer: No stored question for toolUseId ${toolUseId}, fetching from API...`);
+		this.fetchAndReplyToQuestion(toolUseId, answers);
+		return true;
+	}
+
+	/**
+	 * POST /question/{requestID}/reply to send user answers back to the OpenCode server.
+	 */
+	private replyToQuestion(requestId: string, orderedAnswers: string[][]): void {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) {
+			debug.warn('engine', 'replyToQuestion: Server URL not available');
+			return;
+		}
+
+		const dirParam = this.activeProjectPath ? `?directory=${encodeURIComponent(this.activeProjectPath)}` : '';
+		const url = `${serverUrl}/question/${requestId}/reply${dirParam}`;
+		debug.log('engine', `Replying to question ${requestId}:`, orderedAnswers);
+
+		fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ answers: orderedAnswers }),
+		}).then(async res => {
+			if (res.ok) {
+				debug.log('engine', `Question reply accepted: ${requestId} (${res.status})`);
+			} else {
+				const body = await res.text().catch(() => '');
+				debug.error('engine', `Question reply failed: ${res.status} ${res.statusText}`, body);
+			}
+		}).catch(error => {
+			debug.error('engine', 'Failed to reply to question:', error);
+		});
+	}
+
+	/**
+	 * Fallback: GET /question to list pending questions, find the matching one, and reply.
+	 */
+	private async fetchAndReplyToQuestion(toolUseId: string, answers: Record<string, string>): Promise<void> {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) {
+			debug.warn('engine', 'fetchAndReplyToQuestion: Server URL not available');
+			return;
+		}
+
+		try {
+			const dirParam = this.activeProjectPath ? `?directory=${encodeURIComponent(this.activeProjectPath)}` : '';
+			const res = await fetch(`${serverUrl}/question${dirParam}`);
+			if (!res.ok) {
+				debug.error('engine', `Failed to list pending questions: ${res.status}`);
+				return;
+			}
+
+			const questions = await res.json() as Array<{
+				id: string;
+				questions: Array<{ question: string }>;
+				tool?: { callID: string };
+			}>;
+
+			const matching = questions.find(q => q.tool?.callID === toolUseId);
+			if (!matching) {
+				debug.warn('engine', 'fetchAndReplyToQuestion: No matching question for toolUseId:', toolUseId);
+				return;
+			}
+
+			const orderedAnswers = matching.questions.map(q => {
+				const answer = answers[q.question];
+				return answer ? [answer] : [];
+			});
+			this.replyToQuestion(matching.id, orderedAnswers);
+		} catch (error) {
+			debug.error('engine', 'Failed to fetch and reply to question:', error);
+		}
+	}
+
+	/**
+	 * Auto-approve a permission request to avoid blocking the session.
+	 * Uses direct HTTP since the v1 client may not have the v2 permission.reply method.
+	 */
+	private autoApprovePermission(permissionId: string, sessionId: string): void {
+		const serverUrl = getServerUrl();
+		if (!serverUrl) return;
+
+		// Try v2 endpoint first (/permission/{requestID}/reply), fall back to v1
+		fetch(`${serverUrl}/permission/${permissionId}/reply`, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ reply: 'once' }),
+		}).then(res => {
+			if (res.ok) {
+				debug.log('engine', `[OC] auto-approved permission ${permissionId} (v2)`);
+				return;
+			}
+			// v2 endpoint not available — try v1
+			const client = getClient();
+			if (client) {
+				client.postSessionIdPermissionsPermissionId({
+					path: { id: sessionId, permissionID: permissionId },
+					body: { response: 'once' },
+					...(this.activeProjectPath && { query: { directory: this.activeProjectPath } }),
+				}).then(() => {
+					debug.log('engine', `[OC] auto-approved permission ${permissionId} (v1)`);
+				}).catch(err => {
+					debug.error('engine', 'Failed to auto-approve permission (v1):', err);
+				});
+			}
+		}).catch(error => {
+			debug.error('engine', 'Failed to auto-approve permission:', error);
+		});
+	}
+
 	/**
 	 * Extract prompt parts (text + file attachments) from SDKUserMessage.
 	 * Converts Claude-format image/document blocks to OpenCode FilePartInput format.

package/backend/lib/snapshot/helpers.ts

@@ -7,6 +7,9 @@ import type { DatabaseMessage } from '$shared/types/database/schema';
  * Snapshot domain helper functions
  */
 
+/** Sentinel ID for the "initial state" node (before any chat messages) */
+export const INITIAL_NODE_ID = '__initial__';
+
 export interface CheckpointNode {
 	id: string;
 	messageId: string;
@@ -18,6 +21,7 @@ export interface CheckpointNode {
 	isOrphaned: boolean; // descendant of current active checkpoint
 	isCurrent: boolean; // this is the current active checkpoint
 	hasSnapshot: boolean;
+	isInitial?: boolean; // true for the "initial state" node
 	senderName?: string | null;
 	// File change statistics (git-like)
 	filesChanged?: number;
@@ -335,62 +339,31 @@ export function isDescendant(
 }
 
 /**
- * Get file change stats for a checkpoint by looking at snapshots
- * between this checkpoint and the next.
+ * Get file change stats for a checkpoint.
+ * The snapshot associated with the checkpoint message itself contains the stats
+ * (file changes the assistant made in response to this user message).
  */
 export function getCheckpointFileStats(
-	checkpointMsg: DatabaseMessage,
-	allMessages: DatabaseMessage[],
-	nextCheckpointTimestamp?: string
+	checkpointMsg: DatabaseMessage
 ): { filesChanged: number; insertions: number; deletions: number } {
-	let filesChanged = 0;
-	let insertions = 0;
-	let deletions = 0;
-
-	const checkpointTimestamp = checkpointMsg.timestamp;
-
-	const laterMessages = allMessages
-		.filter(m => {
-			if (m.timestamp <= checkpointTimestamp) return false;
-			if (nextCheckpointTimestamp && m.timestamp >= nextCheckpointTimestamp) return false;
-			return true;
-		})
-		.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+	const snapshot = snapshotQueries.getByMessageId(checkpointMsg.id);
+	if (!snapshot) {
+		return { filesChanged: 0, insertions: 0, deletions: 0 };
+	}
 
-	const allChangedFiles = new Set<string>();
-	const statsInRange: Array<{ files: number; ins: number; del: number }> = [];
+	let filesChanged = snapshot.files_changed || 0;
+	const insertions = snapshot.insertions || 0;
+	const deletions = snapshot.deletions || 0;
 
-	for (const msg of laterMessages) {
+	// Try to get a more accurate file count from session_changes
+	if (snapshot.session_changes) {
 		try {
-			const sdkMsg = JSON.parse(msg.sdk_message) as SDKMessage;
-			if (sdkMsg.type !== 'user') continue;
-
-			const userSnapshot = snapshotQueries.getByMessageId(msg.id);
-			if (!userSnapshot) continue;
-
-			const fc = userSnapshot.files_changed || 0;
-			const ins = userSnapshot.insertions || 0;
-			const del = userSnapshot.deletions || 0;
-
-			if (fc > 0 || ins > 0 || del > 0) {
-				statsInRange.push({ files: fc, ins, del });
-			}
-
-			if (userSnapshot.delta_changes) {
-				try {
-					const delta = JSON.parse(userSnapshot.delta_changes);
-					if (delta.added) Object.keys(delta.added).forEach(f => allChangedFiles.add(f));
-					if (delta.modified) Object.keys(delta.modified).forEach(f => allChangedFiles.add(f));
-					if (delta.deleted && Array.isArray(delta.deleted)) delta.deleted.forEach((f: string) => allChangedFiles.add(f));
-				} catch { /* skip */ }
+			const changes = JSON.parse(snapshot.session_changes as string);
+			const changeCount = Object.keys(changes).length;
+			if (changeCount > 0) {
+				filesChanged = changeCount;
 			}
-		} catch { /* skip */ }
-	}
-
-	if (statsInRange.length > 0) {
-		filesChanged = allChangedFiles.size > 0 ? allChangedFiles.size : Math.max(...statsInRange.map(s => s.files));
-		insertions = statsInRange.reduce((sum, s) => sum + s.ins, 0);
-		deletions = statsInRange.reduce((sum, s) => sum + s.del, 0);
+		} catch { /* use files_changed from DB */ }
 	}
 
 	return { filesChanged, insertions, deletions };

package/backend/lib/snapshot/snapshot-service.ts

@@ -285,47 +285,18 @@ export class SnapshotService {
 	 */
 	async checkRestoreConflicts(
 		sessionId: string,
-		targetCheckpointMessageId: string,
-		projectPath?: string
+		targetCheckpointMessageId: string | null,
+		projectPath?: string,
+		targetPath?: string[]
 	): Promise<RestoreConflictCheck> {
 		const sessionSnapshots = snapshotQueries.getBySessionId(sessionId);
+		const isInitialRestore = targetCheckpointMessageId === null;
 
-		const targetIndex = sessionSnapshots.findIndex(
-			s => s.message_id === targetCheckpointMessageId
+		// Build expected state at target (branch-aware when targetPath is provided)
+		const expectedState = this.buildExpectedState(
+			sessionSnapshots, targetCheckpointMessageId, targetPath
 		);
 
-		if (targetIndex === -1) {
-			return { hasConflicts: false, conflicts: [], checkpointsToUndo: [] };
-		}
-
-		// Build expected state at target (same bidirectional algorithm as restoreSessionScoped)
-		// This determines ALL files that would be affected by the restore
-		const expectedState = new Map<string, string>(); // filepath → expectedHash
-
-		for (let i = 0; i <= targetIndex; i++) {
-			const snap = sessionSnapshots[i];
-			if (!snap.session_changes) continue;
-			try {
-				const changes = JSON.parse(snap.session_changes) as SessionScopedChanges;
-				for (const [filepath, change] of Object.entries(changes)) {
-					expectedState.set(filepath, change.newHash);
-				}
-			} catch { /* skip malformed */ }
-		}
-
-		for (let i = targetIndex + 1; i < sessionSnapshots.length; i++) {
-			const snap = sessionSnapshots[i];
-			if (!snap.session_changes) continue;
-			try {
-				const changes = JSON.parse(snap.session_changes) as SessionScopedChanges;
-				for (const [filepath, change] of Object.entries(changes)) {
-					if (!expectedState.has(filepath)) {
-						expectedState.set(filepath, change.oldHash);
-					}
-				}
-			} catch { /* skip malformed */ }
-		}
-
 		if (expectedState.size === 0) {
 			return { hasConflicts: false, conflicts: [], checkpointsToUndo: [] };
 		}
@@ -354,8 +325,13 @@ export class SnapshotService {
 
 		// Determine reference time for cross-session conflict check
 		// Use min(targetTime, currentHeadTime) to cover both undo and redo
-		const targetSnapshot = sessionSnapshots[targetIndex];
-		const targetTime = targetSnapshot.created_at;
+		// For initial restore, use the session's created_at or the earliest snapshot time
+		const targetSnapshot = isInitialRestore
+			? null
+			: sessionSnapshots.find(s => s.message_id === targetCheckpointMessageId) || null;
+		const targetTime = targetSnapshot
+			? targetSnapshot.created_at
+			: (sessionSnapshots[0]?.created_at || new Date(0).toISOString());
 		let referenceTime = targetTime;
 
 		const currentHead = sessionQueries.getHead(sessionId);
@@ -384,7 +360,9 @@ export class SnapshotService {
 
 		// Check for cross-session conflicts
 		const conflicts: RestoreConflict[] = [];
-		const projectId = targetSnapshot.project_id;
+		const projectId = targetSnapshot
+			? targetSnapshot.project_id
+			: (sessionSnapshots[0]?.project_id || '');
 		const allProjectSnapshots = this.getAllProjectSnapshots(projectId);
 
 		for (const otherSnap of allProjectSnapshots) {
@@ -472,60 +450,29 @@ export class SnapshotService {
 	 * Restore to a checkpoint using session-scoped changes.
 	 * Works in both directions (forward and backward).
 	 *
-	 * Algorithm:
-	 * 1. Walk snapshots [0..targetIndex] → build expected file state at target
-	 * 2. Walk snapshots [targetIndex+1..end] → files changed only after target need reverting
-	 * 3. For each file in the expected state map, compare with current disk and restore if different
+	 * When targetPath is provided, uses branch-aware algorithm:
+	 * 1. Only apply changes from snapshots on the path (root → target)
+	 * 2. Revert ALL changes from snapshots on other branches
+	 * 3. Compare expected state with disk and restore if different
 	 * 4. Update in-memory baseline to match restored state
+	 *
+	 * Falls back to linear algorithm when targetPath is not provided.
 	 */
 	async restoreSessionScoped(
 		projectPath: string,
 		sessionId: string,
-		targetCheckpointMessageId: string,
-		conflictResolutions?: ConflictResolution
+		targetCheckpointMessageId: string | null,
+		conflictResolutions?: ConflictResolution,
+		targetPath?: string[]
 	): Promise<{ restoredFiles: number; skippedFiles: number }> {
 		try {
 			const sessionSnapshots = snapshotQueries.getBySessionId(sessionId);
 
-			const targetIndex = sessionSnapshots.findIndex(
-				s => s.message_id === targetCheckpointMessageId
-			);
-
-			if (targetIndex === -1) {
-				debug.warn('snapshot', 'Target checkpoint snapshot not found');
-				return { restoredFiles: 0, skippedFiles: 0 };
-			}
-
 			// Build expected file state at the target checkpoint
-			// filepath → hash that the file should be at the target
-			const expectedState = new Map<string, string>();
-
-			// Walk snapshots from first to target (inclusive): apply forward changes
-			for (let i = 0; i <= targetIndex; i++) {
-				const snap = sessionSnapshots[i];
-				if (!snap.session_changes) continue;
-				try {
-					const changes = JSON.parse(snap.session_changes) as SessionScopedChanges;
-					for (const [filepath, change] of Object.entries(changes)) {
-						expectedState.set(filepath, change.newHash);
-					}
-				} catch { /* skip */ }
-			}
-
-			// Walk snapshots after target: files changed only after target need reverting to oldHash
-			for (let i = targetIndex + 1; i < sessionSnapshots.length; i++) {
-				const snap = sessionSnapshots[i];
-				if (!snap.session_changes) continue;
-				try {
-					const changes = JSON.parse(snap.session_changes) as SessionScopedChanges;
-					for (const [filepath, change] of Object.entries(changes)) {
-						if (!expectedState.has(filepath)) {
-							// File was first changed AFTER target → revert to pre-change state
-							expectedState.set(filepath, change.oldHash);
-						}
-					}
-				} catch { /* skip */ }
-			}
+			// Branch-aware when targetPath is provided
+			const expectedState = this.buildExpectedState(
+				sessionSnapshots, targetCheckpointMessageId, targetPath
+			);
 
 			debug.log('snapshot', `Restore to checkpoint: ${expectedState.size} files in expected state`);
 
@@ -600,6 +547,124 @@ export class SnapshotService {
 	// Helpers
 	// ========================================================================
 
+	/**
+	 * Build the expected file state map for a restore operation.
+	 *
+	 * Branch-aware algorithm (when targetPath is provided):
+	 * 1. Separate snapshots into path (root→target) vs non-path
+	 * 2. Forward walk: only apply newHash from snapshots on the path (in path order)
+	 * 3. Revert walk: revert ALL non-path snapshots using oldHash (first-wins)
+	 *
+	 * This correctly handles multi-branch checkpoint trees by NOT including
+	 * changes from other branches in the forward walk.
+	 *
+	 * Fallback linear algorithm (when targetPath is not provided):
+	 * Walks all snapshots chronologically — only correct for single-branch paths.
+	 */
+	private buildExpectedState(
+		sessionSnapshots: MessageSnapshot[],
+		targetCheckpointMessageId: string | null,
+		targetPath?: string[]
+	): Map<string, string> {
+		const expectedState = new Map<string, string>();
+		const isInitialRestore = targetCheckpointMessageId === null;
+
+		if (isInitialRestore) {
+			// Revert ALL snapshots → everything goes back to oldHash (first-wins)
+			for (const snap of sessionSnapshots) {
+				if (!snap.session_changes) continue;
+				try {
+					const changes = JSON.parse(snap.session_changes as string) as SessionScopedChanges;
+					for (const [filepath, change] of Object.entries(changes)) {
+						if (!expectedState.has(filepath)) {
+							expectedState.set(filepath, change.oldHash);
+						}
+					}
+				} catch { /* skip malformed */ }
+			}
+		} else if (targetPath && targetPath.length > 0) {
+			// Branch-aware restore: only include snapshots on the path from root to target
+			const pathSet = new Set(targetPath);
+
+			// Separate snapshots into path vs non-path
+			const snapshotByMsgId = new Map<string, MessageSnapshot>();
+			const nonPathSnapshots: MessageSnapshot[] = [];
+
+			for (const snap of sessionSnapshots) {
+				if (pathSet.has(snap.message_id)) {
+					snapshotByMsgId.set(snap.message_id, snap);
+				} else {
+					nonPathSnapshots.push(snap);
+				}
+			}
+
+			// Forward walk: apply path snapshots in path order (root → target)
+			// Later path snapshots overwrite earlier ones for the same file (correct)
+			for (const cpId of targetPath) {
+				const snap = snapshotByMsgId.get(cpId);
+				if (!snap?.session_changes) continue;
+				try {
+					const changes = JSON.parse(snap.session_changes as string) as SessionScopedChanges;
+					for (const [filepath, change] of Object.entries(changes)) {
+						expectedState.set(filepath, change.newHash);
+					}
+				} catch { /* skip malformed */ }
+			}
+
+			// Revert all non-path snapshots (changes on other branches)
+			// Process in chronological order with first-wins semantics:
+			// if two non-path snapshots change the same file, the earliest one's
+			// oldHash is used (state before any branch diverged)
+			for (const snap of nonPathSnapshots) {
+				if (!snap.session_changes) continue;
+				try {
+					const changes = JSON.parse(snap.session_changes as string) as SessionScopedChanges;
+					for (const [filepath, change] of Object.entries(changes)) {
+						if (!expectedState.has(filepath)) {
+							expectedState.set(filepath, change.oldHash);
+						}
+					}
+				} catch { /* skip malformed */ }
+			}
+		} else {
+			// Fallback: linear algorithm (no path info available)
+			const targetIndex = sessionSnapshots.findIndex(
+				s => s.message_id === targetCheckpointMessageId
+			);
+
+			if (targetIndex === -1) {
+				debug.warn('snapshot', 'Target checkpoint snapshot not found (linear fallback)');
+				return expectedState;
+			}
+
+			for (let i = 0; i <= targetIndex; i++) {
+				const snap = sessionSnapshots[i];
+				if (!snap.session_changes) continue;
+				try {
+					const changes = JSON.parse(snap.session_changes as string) as SessionScopedChanges;
+					for (const [filepath, change] of Object.entries(changes)) {
+						expectedState.set(filepath, change.newHash);
+					}
+				} catch { /* skip malformed */ }
+			}
+
+			for (let i = targetIndex + 1; i < sessionSnapshots.length; i++) {
+				const snap = sessionSnapshots[i];
+				if (!snap.session_changes) continue;
+				try {
+					const changes = JSON.parse(snap.session_changes as string) as SessionScopedChanges;
+					for (const [filepath, change] of Object.entries(changes)) {
+						if (!expectedState.has(filepath)) {
+							expectedState.set(filepath, change.oldHash);
+						}
+					}
+				} catch { /* skip malformed */ }
+			}
+		}
+
+		return expectedState;
+	}
+
 	/**
 	 * Calculate line-level change stats for changed files.
 	 */