@gitkraken/core-gitlens 0.4.101 → 0.5.101

package/src/git/models/graphSession.ts

@@ -1,10 +1,4 @@
-import type {
-	GitGraph,
-	GitGraphRow,
-	GitGraphRowStats,
-	GraphReachabilityTable,
-	IncrementalGraphFallbackReason,
-} from './graph.js';
+import type { GitGraph, GitGraphRow, IncrementalGraphFallbackReason } from './graph.js';
 
 /**
  * A provider-owned, stateful graph window for a single repo. It is the canonical accumulated window and
@@ -16,8 +10,8 @@ import type {
  * `getGraph` incremental machinery (it internally builds the seed from the accumulated window, tips, and
  * prior artifacts, with the same shape gating), {@link more} delegates to the prior result's `more()`,
  * and {@link current} mirrors today's `GitGraph` result shape so the publisher/wire semantics stay
- * byte-identical. R7b (refresh-result-driven channel marking) and R7c (restart persistence) extend this
- * without breaking — {@link refresh} returns a result object, never a bare `GitGraph`.
+ * byte-identical. R7b (refresh-result-driven channel marking) extends this without breaking —
+ * {@link refresh} returns a result object, never a bare `GitGraph`.
  */
 export interface GitGraphSession {
 	readonly repoPath: string;
@@ -47,106 +41,9 @@ export interface GitGraphSession {
 	 */
 	more(limit?: number, targetId?: string, cancellation?: AbortSignal): Promise<boolean>;
 
-	/**
-	 * Snapshot the canonical window for restart persistence, or `undefined` when there's nothing worth
-	 * persisting — an empty window, or a provider without an incremental restore path (e.g. GitHub, which
-	 * stamps no ref tips for the restore's tip-diff gate). The host writes this into the repo's own git dir
-	 * (`<commonGitDir>/gitlens/graph/` — a repo-derived cache, like git's commit-graph file) on an idle
-	 * debounce / dispose; a later {@link GitGraphSubProvider.openGraphSession} `restore` reconstructs +
-	 * refreshes it. Never trusted over git — restore always re-refreshes (see {@link GitGraphSessionSnapshot}).
-	 */
-	serialize(): GitGraphSessionSnapshot | undefined;
-
 	dispose(): void;
 }
 
-/**
- * Schema version for {@link GitGraphSessionSnapshot}. Bump on ANY shape change (field add/remove/rename or a
- * semantics change): a restore whose snapshot version doesn't match this EXACTLY is discarded (a normal
- * initial walk), so an old-shaped cache written by a prior extension version can never be misread.
- */
-export const graphSessionSnapshotVersion = 3;
-
-/**
- * Restart-persistence snapshot of a {@link GitGraphSession}'s canonical window — everything a restore needs
- * to reconstruct the session's prior generation as an R6 incremental SEED, so a cold open on an unchanged
- * repo is ≈ deserialize + one enumeration instead of a full walk.
- *
- * NEVER trusted over git: on restore the session reconstructs this as its window/tips/builders WITHOUT any
- * git, then IMMEDIATELY {@link GitGraphSession.refresh | refreshes} — the same enumeration + tip-diff + FF +
- * stash gates reconcile a stale snapshot (fast when unchanged, a full walk on any structural change), and any
- * parse/validation failure discards it entirely for a normal initial walk.
- *
- * Rows are persisted as-is: they're already the JSON-safe wire shapes (strings/numbers/plain objects — the
- * graph's Maps live at the graph level, not on rows, and the transient per-row `reachability` is stripped
- * before a row is emitted). Maps are persisted as entry arrays.
- */
-export interface GitGraphSessionSnapshot {
-	/** Must equal {@link graphSessionSnapshotVersion}; any mismatch discards the snapshot. */
-	readonly v: number;
-	readonly repoPath: string;
-	/** Walk shape the window was produced under (`${ordering}|${onlyFollowFirstParent}`). A restore is
-	 *  discarded when this disagrees with the current config's shape — the cached rows can't be reused. */
-	readonly buildShape: string;
-	readonly ordering: 'date' | 'author-date' | 'topo';
-	readonly onlyFollowFirstParent: boolean;
-	/** The persisted window rows, in walk order — a TOP slice capped at a bounded row count (see the host
-	 *  store); a longer window persists its top slice with {@link hasMore} forced true so the bottom re-pages. */
-	readonly rows: GitGraphRow[];
-	/** Ref tips as of the persisted walk: `[canonical refname, peeled tip sha]` entries — the map the restore
-	 *  refresh diffs against current git to find the structural changes that force a full fallback. */
-	readonly refTips: [string, string][];
-	/** {@link GitGraph.decorationFingerprint} as of the persisted walk — the restore refresh diffs it against
-	 *  current git so a metadata-only change while closed (upstream/default/worktree/remote/user) still forces
-	 *  the full fallback that rebuilds row decorations. Absent ⇒ never matches ⇒ safe full fallback. */
-	readonly decorationFingerprint?: string;
-	/** Shared reachability table for the window (the primary reachability representation — rows carry only a
-	 *  `contexts.reachabilityIndex` into its `sets`). The restore refresh CONTINUES it (stable indices). */
-	readonly reachability?: GraphReachabilityTable;
-	/** Per-sha immutable stats `[sha, stats]` entries for the persisted rows (present only when stats were
-	 *  included in the walk). */
-	readonly rowsStats?: [string, GitGraphRowStats][];
-	/** Downstreams `[upstream name, tracking branch names]` entries (for the refresh's change diffing). */
-	readonly downstreams: [string, string[]][];
-	/** Whether the persisted window had more rows below it — genuinely paged OR truncated by the cap. */
-	readonly hasMore: boolean;
-	/** Whether the persisted walk included per-row stats. */
-	readonly includesStats: boolean;
-	/** Whether the repo was a shallow clone when the window was walked. The restore refresh diffs this
-	 *  against current git — an un-shallow (or re-shallow) while closed forces a full fallback. */
-	readonly shallow: boolean;
-}
-
-/** Why a restore discarded its snapshot (reported via {@link GraphSessionRestoreResult.reason}). */
-export type GraphSessionRestoreDiscardReason =
-	| 'schema'
-	| 'repo-path'
-	| 'shape'
-	| 'empty'
-	| 'tips'
-	| 'rows'
-	| 'reachability'
-	| 'downstreams'
-	| 'rowsStats'
-	// A throw past structural validation (e.g. the restore refresh's enumerate chokes on a garbage rev).
-	| 'corrupt';
-
-/**
- * Outcome of a restore attempt, reported via the {@link GitGraphSubProvider.openGraphSession} `onRestore`
- * callback so the host can emit its single, assertable INFO line. `restored` is true only when the snapshot
- * validated and seeded the (always-run) refresh — `refresh` then carries that refresh's path so the host can
- * distinguish `→ refresh fast (+M)` from `→ refresh full (<reason>)`.
- */
-export interface GraphSessionRestoreResult {
-	readonly restored: boolean;
-	/** Present when `!restored`: why the snapshot was discarded; the host logs `miss (<reason>)`. */
-	readonly reason?: GraphSessionRestoreDiscardReason;
-	/** Present when `restored`: how many window rows the snapshot carried. */
-	readonly rows?: number;
-	/** Present when `restored`: the post-restore refresh outcome (a restore ALWAYS refreshes to current truth). */
-	readonly refresh?: GitGraphSessionRefreshResult;
-}
-
 export interface GitGraphSessionRefreshOptions {
 	/** Rebuild anchor / find target — the loaded window's bottom sha (pins the walk's bottom boundary),
 	 *  or a selection/centering hint. Mirrors the `rev` the host passed to `getGraph` today. */

package/src/git/models/issue.ts

@@ -8,7 +8,8 @@ import type { RepositoryIdentityDescriptor } from './repositoryIdentities.js';
 export type IssueStateFilter = 'open' | 'closed' | 'all';
 
 export interface IssueShape extends IssueOrPullRequest {
-	author: IssueMember;
+	/** `undefined` when the provider can't resolve the author, e.g. a deleted GitHub account */
+	author: IssueMember | undefined;
 	assignees: IssueMember[];
 	repository?: IssueRepository;
 	labels?: IssueLabel[];
@@ -31,7 +32,7 @@ export class Issue implements IssueShape {
 		public readonly updatedDate: Date,
 		public readonly closed: boolean,
 		public readonly state: IssueOrPullRequestState,
-		public readonly author: IssueMember,
+		public readonly author: IssueMember | undefined,
 		public readonly assignees: IssueMember[],
 		public readonly repository?: IssueRepository,
 		public readonly closedDate?: Date,

package/src/git/providers/graph.ts

@@ -12,7 +12,7 @@ import type {
 	GitGraphSearchProgress,
 	GitGraphSearchResults,
 } from '../models/graphSearch.js';
-import type { GitGraphSession, GitGraphSessionSnapshot, GraphSessionRestoreResult } from '../models/graphSession.js';
+import type { GitGraphSession } from '../models/graphSession.js';
 import type { SearchQuery } from '../models/search.js';
 
 export interface GitGraphSubProvider {
@@ -30,20 +30,6 @@ export interface GitGraphSubProvider {
 			rev?: string;
 			limit?: number;
 			include?: { stats?: boolean };
-			/**
-			 * Restart-persistence snapshot to seed the session from (see {@link GitGraphSessionSnapshot}). When
-			 * present and structurally valid, the session reconstructs it as its prior generation WITHOUT any git,
-			 * then immediately refreshes to current truth — so a cold open on an unchanged repo is ≈ deserialize +
-			 * one enumeration. Any validation/parse failure is ignored (a normal initial walk). Never trusted over
-			 * git. Providers without an incremental restore path (e.g. GitHub) ignore it.
-			 */
-			restore?: GitGraphSessionSnapshot;
-			/**
-			 * Reports the restore outcome (validated + refreshed, or discarded with a reason) so the host can log
-			 * a single assertable line. Called at most once, only when `restore` was provided. See
-			 * {@link GraphSessionRestoreResult}.
-			 */
-			onRestore?: (result: GraphSessionRestoreResult) => void;
 		},
 		cancellation?: AbortSignal,
 	): Promise<GitGraphSession>;

package/src/git/providers/pausedOperations.ts

@@ -7,5 +7,12 @@ export interface GitPausedOperationsSubProvider {
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined>;
 	abortPausedOperation(repoPath: string, options?: { quit?: boolean }): Promise<void>;
-	continuePausedOperation(repoPath: string, options?: { skip?: boolean }): Promise<void>;
+	continuePausedOperation(
+		repoPath: string,
+		options?: {
+			skip?: boolean;
+			/** Editor command used if the operation needs to edit a commit message (e.g. `true` to keep the original message without opening an editor) */
+			messageEditor?: string;
+		},
+	): Promise<void>;
 }

package/src/git/utils/issue.utils.ts

@@ -38,12 +38,15 @@ export function serializeIssue(value: IssueShape): IssueShape {
 		closedDate: value.closedDate,
 		closed: value.closed,
 		state: value.state,
-		author: {
-			id: value.author.id,
-			name: value.author.name,
-			avatarUrl: value.author.avatarUrl,
-			url: value.author.url,
-		},
+		author:
+			value.author == null
+				? undefined
+				: {
+						id: value.author.id,
+						name: value.author.name,
+						avatarUrl: value.author.avatarUrl,
+						url: value.author.url,
+					},
 		repository:
 			value.repository == null
 				? undefined

package/src/git/utils/reachability.utils.ts

@@ -10,7 +10,7 @@ type ReachableRef = GitCommitReachability['refs'][number];
  * set and the walk's HEAD-derived sets. Single-sourced so the host row processor
  * (`GlGraphRowProcessor`), the R6b incremental fast path, and the equivalence harness all compute
  * byte-identical flags (no manual mirrors that can drift). Stash rows carry no flags — callers skip this
- * for `stash-node` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.
+ * for `stash` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.
  */
 export function computeGraphRowContextFlags(
 	sha: string,

package/src/git/utils/remote.utils.ts

@@ -7,6 +7,12 @@ export function getDefaultRemoteOrHighlander<T extends GitRemote>(remotes: T[]):
 	return remotes.length === 1 ? remotes[0] : remotes.find(r => r.default);
 }
 
+/** Like {@link getDefaultRemoteOrHighlander}, but falls back to `origin` when no remote is designated
+ *  default — otherwise features keyed on "the default remote" silently do nothing on multi-remote repos */
+export function getDefaultRemoteOrOrigin<T extends GitRemote>(remotes: T[]): T | undefined {
+	return getDefaultRemoteOrHighlander(remotes) ?? remotes.find(r => r.name === 'origin');
+}
+
 export function getHighlanderProviderName(remotes: GitRemote<RemoteProvider>[]): string | undefined {
 	if (remotes.length === 0) return undefined;
 

package/src/git-cli/providers/graph.ts

@@ -25,15 +25,11 @@ import type {
 	GitGraphSearchResultData,
 	GitGraphSearchResults,
 } from '../../git/models/graphSearch.js';
-import { graphSessionSnapshotVersion } from '../../git/models/graphSession.js';
 import type {
 	GitGraphSession,
 	GitGraphSessionChangedChannels,
 	GitGraphSessionRefreshOptions,
 	GitGraphSessionRefreshResult,
-	GitGraphSessionSnapshot,
-	GraphSessionRestoreDiscardReason,
-	GraphSessionRestoreResult,
 } from '../../git/models/graphSession.js';
 import type { GitRemote } from '../../git/models/remote.js';
 import type { SearchQuery } from '../../git/models/search.js';
@@ -195,130 +191,12 @@ function downstreamsChanged(prior: ReadonlyMap<string, string[]>, next: Readonly
 	return false;
 }
 
-/**
- * Cap on the number of window rows a {@link GraphSession.serialize} persists. A longer window persists only
- * its TOP slice with `hasMore` forced true (restore then behaves as a shorter loaded window — the bottom
- * re-pages on demand). Pragmatic: generous enough that a typical session restores its whole window, bounded
- * enough that the JSON file stays sub-MB-class (rows are a few hundred bytes each).
- */
-const maxPersistedGraphRows = 2000;
-
 /** The walk-shape key (`ordering|onlyFollowFirstParent`) an incremental seed is gated on — one builder so the
- *  restore/refresh/rebuild sites can't drift in how they stringify it. */
+ *  refresh/rebuild sites can't drift in how they stringify it. */
 function buildShapeKey(shape: { ordering: string; onlyFollowFirstParent: boolean }): string {
 	return `${shape.ordering}|${shape.onlyFollowFirstParent}`;
 }
 
-/**
- * Validates a persisted {@link GitGraphSessionSnapshot} structurally before it's trusted to seed a restore.
- * Returns the discard reason on any failure (→ the caller ignores the snapshot and does a normal initial
- * walk), or `undefined` when it's coherent. Never throws — a corrupt/adversarial cache must degrade to a
- * full walk, never crash the open. Deep validation (does the cache match current git?) is NOT done here:
- * that's the restore's immediate refresh, which reconciles a stale-but-valid snapshot against ground truth.
- */
-function validateGraphSnapshot(
-	snapshot: GitGraphSessionSnapshot,
-	repoPath: string,
-	currentBuildShape: string,
-): GraphSessionRestoreDiscardReason | undefined {
-	if (snapshot.v !== graphSessionSnapshotVersion) return 'schema';
-	if (snapshot.repoPath !== repoPath) return 'repo-path';
-	// A shape change reshapes every row's parents/order — the cached rows can't be reused.
-	if (snapshot.buildShape !== currentBuildShape) return 'shape';
-	if (!Array.isArray(snapshot.rows) || snapshot.rows.length === 0) return 'empty';
-	if (
-		!Array.isArray(snapshot.refTips) ||
-		snapshot.refTips.some(
-			t => !Array.isArray(t) || t.length !== 2 || typeof t[0] !== 'string' || typeof t[1] !== 'string',
-		)
-	) {
-		return 'tips';
-	}
-
-	// Each row must be structurally sane — a corrupt row poisons the seed / stitch math. Duplicate shas break
-	// the ids set / stitch dedup (they'd re-appear as "already seen"), so reject them too.
-	const seenShas = new Set<string>();
-	for (const row of snapshot.rows) {
-		if (row == null || typeof row.sha !== 'string' || !Array.isArray(row.parents) || typeof row.date !== 'number') {
-			return 'rows';
-		}
-		if (seenShas.has(row.sha)) return 'rows';
-
-		seenShas.add(row.sha);
-	}
-
-	// Every row's `reachabilityIndex` must be a valid index into the table's `sets` (the decode reads it
-	// directly). Guards against a truncated table / mismatched pairing.
-	const reachability = snapshot.reachability;
-	if (reachability != null && (!Array.isArray(reachability.sets) || !Array.isArray(reachability.dictionary))) {
-		return 'reachability';
-	}
-
-	const setCount = reachability?.sets?.length ?? 0;
-	for (const row of snapshot.rows) {
-		const index = row.contexts?.reachabilityIndex;
-		if (index != null && (!Number.isInteger(index) || index < 0 || index >= setCount)) return 'reachability';
-	}
-
-	// Downstreams must be `[upstream name, tracking branch names]` entries (reconstructed into a Map on restore).
-	if (
-		!Array.isArray(snapshot.downstreams) ||
-		snapshot.downstreams.some(
-			d => !Array.isArray(d) || d.length !== 2 || typeof d[0] !== 'string' || !Array.isArray(d[1]),
-		)
-	) {
-		return 'downstreams';
-	}
-
-	// Per-sha stats, when present, must be `[sha, stats-object]` entries (reconstructed into a Map on restore).
-	if (
-		snapshot.rowsStats != null &&
-		(!Array.isArray(snapshot.rowsStats) ||
-			snapshot.rowsStats.some(
-				s =>
-					!Array.isArray(s) ||
-					s.length !== 2 ||
-					typeof s[0] !== 'string' ||
-					typeof s[1] !== 'object' ||
-					s[1] == null,
-			))
-	) {
-		return 'rowsStats';
-	}
-
-	return undefined;
-}
-
-/**
- * Reconstruct a persisted snapshot into the synthetic `GitGraph` a {@link GraphSession.restore} hands to its
- * immediate refresh as the PRIOR generation — carrying exactly the fields the refresh's seed construction +
- * change-diffing read (`refTips`, `reachability`, `rowsStats`, `downstreams`, `paging.hasMore`). Avatars are
- * deliberately empty: resolved avatar URLs are webview-instance-bound and don't survive a restart, so the
- * refresh re-derives them (and the write-once merge over an empty prior map is a no-op). The side-queried
- * collections (`branches`/`remotes`/`stashes`/`worktrees`) aren't read by the refresh, so they're left empty.
- */
-function buildRestoredGraph(snapshot: GitGraphSessionSnapshot): GitGraph {
-	return {
-		repoPath: snapshot.repoPath,
-		avatars: new Map<string, string>(),
-		ids: new Set<string>(snapshot.rows.map(r => r.sha)),
-		includes: snapshot.includesStats ? { stats: true } : undefined,
-		branches: new Map<string, GitBranch>(),
-		remotes: new Map<string, GitRemote>(),
-		downstreams: new Map(snapshot.downstreams),
-		stashes: undefined,
-		worktrees: undefined,
-		worktreesByBranch: undefined,
-		reachability: snapshot.reachability,
-		refTips: new Map(snapshot.refTips),
-		decorationFingerprint: snapshot.decorationFingerprint,
-		shallow: snapshot.shallow,
-		rows: snapshot.rows,
-		rowsStats: snapshot.rowsStats != null ? new Map(snapshot.rowsStats) : undefined,
-		paging: { limit: snapshot.rows.length, startingCursor: undefined, hasMore: snapshot.hasMore },
-	};
-}
-
 /** The graph log parser's per-record shape (see `graphMapping`), narrowed to the fields the row builder reads. */
 type GraphCommitRecord = {
 	sha: string;
@@ -405,8 +283,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			rev?: string;
 			limit?: number;
 			include?: { stats?: boolean };
-			restore?: GitGraphSessionSnapshot;
-			onRestore?: (result: GraphSessionRestoreResult) => void;
 		},
 		cancellation?: AbortSignal,
 	): Promise<GitGraphSession> {
@@ -422,30 +298,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		};
 		const session = new GraphSession(this, repoPath, options?.rowProcessor, getWalkShape);
 
-		// R7c restart persistence: seed from a persisted snapshot when it's structurally valid for THIS repo +
-		// walk shape, then immediately refresh (the snapshot is exactly an R6 seed — enumeration + the tip/FF/
-		// stash gates reconcile a stale one). Any validation failure discards it and falls through to a normal
-		// initial walk. Never trusted over git.
-		const restore = options?.restore;
-		if (restore != null) {
-			const shape = getWalkShape();
-			const reason = validateGraphSnapshot(restore, repoPath, buildShapeKey(shape));
-			if (reason == null) {
-				try {
-					const refresh = await session.restore(restore, options, cancellation);
-					options?.onRestore?.({ restored: true, rows: restore.rows.length, refresh: refresh });
-					return session;
-				} catch {
-					// Belt-and-suspenders: structural validation can't catch a snapshot that reconstructs but
-					// throws in the restore's refresh (e.g. a garbage rev its enumerate chokes on). A corrupt
-					// cache must degrade to a full walk, never crash the open — report a miss and fall through.
-					options?.onRestore?.({ restored: false, reason: 'corrupt' });
-				}
-			} else {
-				options?.onRestore?.({ restored: false, reason: reason });
-			}
-		}
-
 		await session.initialize(options, cancellation);
 		return session;
 	}
@@ -810,6 +662,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 								// `defaultLocalName!` is non-null here because `tip === defaultBranchName` short-circuits when `defaultBranchName` is null.
 								isDefault: tip === defaultBranchName && !branchMap.has(defaultLocalName!),
 								hostingServiceType: remote.provider?.gkProviderId,
+								// `branchMap` is keyed by full name, so the remote ref resolves here — the same
+								// lookup the host does today to bake `+starred` into the context string.
+								starred: branchMap.get(tip)?.starred || undefined,
 							});
 							continue;
 						}
@@ -823,7 +678,11 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 						(branchId === branchIdOfMainWorktree ? mainWorktree : undefined);
 					const worktreeRef =
 						worktree != null
-							? { id: getWorktreeId(repoPath, worktree.name), path: worktree.path }
+							? {
+									id: getWorktreeId(repoPath, worktree.name),
+									path: worktree.path,
+									isDefault: worktree.isDefault === true,
+								}
 							: undefined;
 					refHeads.push({
 						id: branchId,
@@ -831,11 +690,19 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 						isCurrentHead: head,
 						upstream:
 							branch?.upstream != null
-								? { name: branch.upstream.name, id: getBranchId(repoPath, true, branch.upstream.name) }
+								? {
+										name: branch.upstream.name,
+										id: getBranchId(repoPath, true, branch.upstream.name),
+										missing: branch.upstream.missing,
+										state: {
+											ahead: branch.upstream.state.ahead,
+											behind: branch.upstream.state.behind,
+										},
+									}
 								: undefined,
 						worktree: worktreeRef,
-						worktreeId: worktree?.isDefault === false ? worktreeRef?.id : undefined,
 						isDefault: defaultLocalName != null && tip === defaultLocalName,
+						starred: branch?.starred || undefined,
 					});
 				}
 			}
@@ -853,10 +720,11 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					date: Number(ordering === 'author-date' ? commit.authorDate : commit.committerDate) * 1000,
 					commitDate: Number(commit.committerDate) * 1000,
 					message: (stash.message ?? commit.message).trim(),
-					type: 'stash-node',
-					heads: refHeads,
-					remotes: refRemoteHeads,
-					tags: refTags,
+					kind: 'stash',
+					stashNumber: stash.stashNumber,
+					heads: refHeads.length ? refHeads : undefined,
+					remotes: refRemoteHeads.length ? refRemoteHeads : undefined,
+					tags: refTags.length ? refTags : undefined,
 					isCurrentUser: true,
 				};
 				// Don't seed `rowStats` from `stash.stats` here: the graph's stash list is fetched with
@@ -873,10 +741,10 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					date: Number(ordering === 'author-date' ? commit.authorDate : commit.committerDate) * 1000,
 					commitDate: Number(commit.committerDate) * 1000,
 					message: commit.message.trim(),
-					type: parents.length > 1 ? 'merge-node' : 'commit-node',
-					heads: refHeads,
-					remotes: refRemoteHeads,
-					tags: refTags,
+					kind: parents.length > 1 ? 'merge' : 'commit',
+					heads: refHeads.length ? refHeads : undefined,
+					remotes: refRemoteHeads.length ? refRemoteHeads : undefined,
+					tags: refTags.length ? refTags : undefined,
 					isCurrentUser: isCurrentUser || undefined,
 				};
 				if (commit.stats != null) {
@@ -1035,7 +903,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							continue;
 						}
 
-						if (row.type === 'stash-node') {
+						if (row.kind === 'stash') {
 							missingStashStdin += `${row.sha}\n`;
 						} else {
 							missingStdin += `${row.sha}\n`;
@@ -1215,7 +1083,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							refRemoteHeads,
 							refTags,
 							head,
-							row.type === 'stash-node',
+							row.kind === 'stash',
 						);
 						// Transient: the row processor's `+unique` decision reads this; stripped by finalize.
 						// Unsorted (the consumer re-sorts after decoding) — order doesn't affect interning.
@@ -1446,7 +1314,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			// Stash-set gate: any push/pop/drop changes the injected rows.
 			const currentStashShas =
 				gitStash?.stashes != null ? new Set<string>(gitStash.stashes.keys()) : new Set<string>();
-			const priorStashShas = seed.rows.filter(r => r.type === 'stash-node').map(r => r.sha);
+			const priorStashShas = seed.rows.filter(r => r.kind === 'stash').map(r => r.sha);
 			if (priorStashShas.length !== currentStashShas.size || priorStashShas.some(s => !currentStashShas.has(s))) {
 				fallback('stash-changed');
 				return undefined;
@@ -1456,9 +1324,9 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 			// upstreams, worktree assignments, remote urls/providers, current user) that can change without
 			// moving any ref tip — e.g. `git remote set-head`, `branch --set-upstream-to`, `worktree add`.
 			// Reused rows keep their prior decorations (only flags/reachability are re-derived below), so ANY
-			// change here must take the full walk that rebuilds them. An absent seed fingerprint (old persisted
-			// snapshot) never matches — safe full fallback. Deliberately LAST of the gates so the structural
-			// gates above keep their precise reasons (a deleted tracking branch reports `ref-deleted`, not this).
+			// change here must take the full walk that rebuilds them. An absent seed fingerprint never matches —
+			// safe full fallback. Deliberately LAST of the gates so the structural gates above keep their precise
+			// reasons (a deleted tracking branch reports `ref-deleted`, not this).
 			if (seed.decorationFingerprint !== decorationFingerprint) {
 				fallback('metadata-changed');
 				return undefined;
@@ -1617,7 +1485,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					row.remotes ?? [],
 					row.tags ?? [],
 					row.sha === currentHeadSha,
-					row.type === 'stash-node',
+					row.kind === 'stash',
 				);
 				if (freshShas.has(row.sha)) {
 					// Fresh rows are raw — run the full processor (contexts, emojify, avatar). Reused rows keep
@@ -1627,7 +1495,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 				}
 				// Authoritative flags for every commit row (membership can shift on reused rows too — e.g. a new
 				// interior branch flips `+unique`). Stash rows carry none.
-				if (row.type !== 'stash-node') {
+				if (row.kind !== 'stash') {
 					(row.contexts ??= {}).flags = computeGraphRowContextFlags(row.sha, refs?.values(), graphCtx);
 				}
 				finalizeRowReachability(row, row.sha, refs);
@@ -2112,39 +1980,6 @@ class GraphSession implements GitGraphSession {
 		this.applyRebuild(graph, shape);
 	}
 
-	/**
-	 * R7c restart persistence. Reconstruct the prior generation from a persisted snapshot as an R6 seed
-	 * WITHOUT any git (its window/tips/reachability/stats become this session's prior `current`/`window`/
-	 * `buildShape`), then IMMEDIATELY {@link refresh} to current truth — the enumeration + tip/FF/stash gates
-	 * reconcile a stale snapshot (fast when unchanged, a full walk on any structural change). The session
-	 * handed back is ALWAYS post-refresh; the raw snapshot is never surfaced. The caller has already validated
-	 * the snapshot structurally. Returns the refresh outcome so the caller can report the restore result.
-	 */
-	async restore(
-		snapshot: GitGraphSessionSnapshot,
-		options?: { rev?: string; limit?: number; include?: { stats?: boolean } },
-		cancellation?: AbortSignal,
-	): Promise<GitGraphSessionRefreshResult> {
-		this._window = snapshot.rows;
-		this._buildShape = snapshot.buildShape;
-		this._current = buildRestoredGraph(snapshot);
-
-		// Anchor the re-walk on the window's BOTTOM commit so it spans the whole restored window (the host's
-		// rebuild-anchor discipline), matching to at least the current limit so a since-grown repo still fills a
-		// full page. Stash rows aren't real revs, so skip them when picking the anchor.
-		let anchor: string | undefined;
-		for (let i = snapshot.rows.length - 1; i >= 0; i--) {
-			const type = snapshot.rows[i].type;
-			if (type === 'commit-node' || type === 'merge-node') {
-				anchor = snapshot.rows[i].sha;
-				break;
-			}
-		}
-		const limit = Math.max(snapshot.rows.length, options?.limit ?? 0);
-
-		return this.refresh({ rev: anchor, limit: limit, include: options?.include }, cancellation);
-	}
-
 	async refresh(
 		options?: GitGraphSessionRefreshOptions,
 		cancellation?: AbortSignal,
@@ -2266,56 +2101,8 @@ class GraphSession implements GitGraphSession {
 		return true;
 	}
 
-	serialize(): GitGraphSessionSnapshot | undefined {
-		const current = this._current;
-		// Nothing worth persisting: no window yet, no build shape recorded, or no ref tips (the restore's
-		// tip-diff gate has nothing to diff — never true for the CLI provider, but guards a defensive future).
-		if (this._window.length === 0 || this._buildShape == null || current?.refTips == null) return undefined;
-
-		const [ordering, onlyFollowFirstParent] = this._buildShape.split('|');
-
-		// Cap the persisted window to a bounded top slice; a longer window persists its top with `hasMore`
-		// forced true (restore behaves as a shorter loaded window — the bottom re-pages on demand). Slicing
-		// makes a new array of the SAME row objects — no mutation of the live window.
-		const capped = this._window.length > maxPersistedGraphRows;
-		const rows = capped ? this._window.slice(0, maxPersistedGraphRows) : (this._window as GitGraphRow[]);
-		const hasMore = capped || (current.paging?.hasMore ?? false);
-
-		// Stats are immutable per sha; when capped, trim to the persisted shas (entries for dropped rows are
-		// dead weight). The reachability table is kept whole even when capped — it's proportional to distinct
-		// ref-sets (small), the persisted rows' indices stay valid, and extra sets are harmless on decode.
-		let rowsStats: [string, GitGraphRowStats][] | undefined;
-		if (current.includes?.stats === true && current.rowsStats != null && current.rowsStats.size > 0) {
-			const shas = capped ? new Set(rows.map(r => r.sha)) : undefined;
-			rowsStats = [];
-			for (const [sha, stats] of current.rowsStats) {
-				if (shas != null && !shas.has(sha)) continue;
-
-				rowsStats.push([sha, stats]);
-			}
-		}
-
-		return {
-			v: graphSessionSnapshotVersion,
-			repoPath: this.repoPath,
-			buildShape: this._buildShape,
-			ordering: ordering as 'date' | 'author-date' | 'topo',
-			onlyFollowFirstParent: onlyFollowFirstParent === 'true',
-			rows: rows,
-			refTips: [...current.refTips],
-			decorationFingerprint: current.decorationFingerprint,
-			reachability: current.reachability,
-			rowsStats: rowsStats,
-			downstreams: Array.from(current.downstreams, ([k, v]): [string, string[]] => [k, [...v]]),
-			hasMore: hasMore,
-			includesStats: current.includes?.stats === true,
-			shallow: current.shallow ?? false,
-		};
-	}
-
 	dispose(): void {
-		// No-op — the window lives entirely in memory. R7c restart persistence is host-driven: the host
-		// serializes this session (debounced + on its own dispose) and owns the storage IO.
+		// No-op — the window lives entirely in memory and dies with the session.
 	}
 
 	/** A cursor-less rebuild (full walk / fast path) IS the full window. */