@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/plus/agents/providers/gkAgentProvider.ts

@@ -1,4036 +0,0 @@
-import { readdir, readFile } from 'fs/promises';
-import { join } from 'path';
-import { gate } from '../../../utils/decorators/gate.js';
-import type { UnifiedDisposable } from '../../../utils/disposable.js';
-import { disposableInterval } from '../../../utils/disposable.js';
-import { Emitter } from '../../../utils/event.js';
-import { Logger } from '../../../utils/logger.js';
-import { arePathsEqual, normalizePath } from '../../../utils/path.js';
-import type { AgentCapabilities } from '../agentCapabilities.js';
-import {
-	agentCapabilities,
-	claudeCodeCapabilities,
-	getAgentCapabilities,
-	getAgentCapabilitiesByProviderId,
-	resolveCanonicalHookEvent,
-	resolveCanonicalToolName,
-} from '../agentCapabilities.js';
-import { prepareStoredPrompt } from '../sanitizePrompt.js';
-import {
-	classifyPermissionKind,
-	deriveStatusFromEvent,
-	describeToolInput,
-	extractPlanSummary,
-	extractQuestionDetails,
-	getToolFilePath,
-	getToolReadPath,
-	isProcessAlive,
-	rehydrateSubagents,
-} from '../stateMachine.js';
-import type {
-	AgentProviderCallbacks,
-	AgentSession,
-	AgentSessionHistoryItem,
-	AgentSessionHistoryOptions,
-	AgentSessionHistoryResult,
-	AgentSessionPhase,
-	AgentSessionProvider,
-	AgentSessionResumeOutcome,
-	AgentSessionResumeTarget,
-	AgentSessionStatus,
-	LiveAgentSession,
-	PendingPermission,
-	PendingPermissionKind,
-	PermissionDecision,
-	PermissionSuggestion,
-} from '../types.js';
-import { getPhaseForStatus } from '../types.js';
-import type { EndedTranscriptDetails } from './claudeCodeTranscript.js';
-import { ClaudeCodeTranscriptReader } from './claudeCodeTranscript.js';
-
-interface AgentSessionEvent {
-	/** The originating agent's NATIVE hook event name, relayed verbatim by the CLI — NOT yet a
-	 *  canonical `AgentHookEvent`. Resolve it through {@link resolveCanonicalHookEvent} before
-	 *  switching on it. */
-	event: string;
-	sessionId: string;
-	/** `gk ai hook` client id of the originating host (`claude-code`, `codex`, …) — NOT
-	 *  `AgentSession.providerId`. Absent on older CLIs. */
-	providerId?: string;
-	cwd: string;
-	/** The agent's launch directory, captured first-hand by the CLI and preserved across events.
-	 *  Optional — older CLIs don't send it, in which case consumers fall back to deriving it from
-	 *  the first-seen `cwd`. */
-	initialCwd?: string;
-	pid?: number;
-	source?: string;
-	model?: string;
-	reason?: string;
-	toolName?: string;
-	agentId?: string;
-	agentType?: string;
-	planFile?: string;
-	notificationType?: string;
-	sessionName?: string;
-	prompt?: string;
-	firstPrompt?: string;
-	toolInput?: Record<string, unknown>;
-	permissionSuggestions?: PermissionSuggestion[];
-	hookInput?: Record<string, unknown>;
-	/** CLI-resolved worktree roots for this session's cwd visits, newest last — same shape as
-	 *  {@link SessionFileData.cwdTimeline}. The CLI runs `rev-parse` at hook time and includes this
-	 *  on every event, even though it isn't part of the raw hook payload. */
-	cwdTimeline?: { cwd: string; worktree?: string; at?: string }[];
-}
-
-interface PermissionResponse {
-	hookSpecificOutput: {
-		hookEventName: 'PermissionRequest';
-		decision: {
-			behavior: PermissionDecision;
-			updatedPermissions?: PermissionSuggestion[];
-		};
-	};
-}
-
-interface PendingPermissionEntry {
-	/** All connections waiting on this ask — duplicate deliveries (CLI retry after its 60s
-	 *  response-header timeout) attach here and settle together. */
-	resolvers: { resolve(response: PermissionResponse): void; reject(reason: Error): void }[];
-	toolName: string;
-	toolDescription: string;
-	/** From `hookInput.tool_use_id` when the CLI surfaces it; identity gate for stale-clearing. */
-	toolUseId?: string;
-	/** Serialized tool_input, for duplicate-delivery detection when `toolUseId` is absent. */
-	toolInputJson?: string;
-}
-
-interface SessionBookkeeping {
-	activeToolCount: number;
-	pendingPermission?: PendingPermission;
-	/** Refcount of in-flight file-mutating tool calls per absolute path. Keyed by path (not
-	 *  `tool_use_id`) because the GK CLI hook payload doesn't reliably surface `tool_use_id` —
-	 *  refcounting per path is order-independent and tolerant of out-of-order Pre/Post pairs. */
-	currentFileCounts: Map<string, number>;
-	/** Per-path cooldown timers scheduled when a path's refcount hits zero, so back-to-back
-	 *  Edit/Write to the same path doesn't flicker the WIP decoration. A fresh Pre on the same
-	 *  path cancels its pending clear. */
-	pendingFileClears: Map<string, NodeJS.Timeout>;
-	/** Refcount of in-flight read-only file tool calls (Read/NotebookRead) per absolute path.
-	 *  Mirrors {@link currentFileCounts} so consumers can distinguish "looking at" from "working
-	 *  on". */
-	currentReadCounts: Map<string, number>;
-	/** Per-path cooldown timers for reads — same semantics as {@link pendingFileClears}, keeps a
-	 *  recently-read file visible briefly after the read completes. */
-	pendingReadClears: Map<string, NodeJS.Timeout>;
-	/** Epoch-ms timestamps of the last `PreToolUse` for each kind, per absolute path. Stamped on
-	 *  every Pre; the per-path `edit`/`read` slot survives through the cooldown window and is
-	 *  dropped only when the corresponding count map drops the path. Serialized into
-	 *  `AgentSession.fileActivity` as `editedAt = now - timestamp.edit` (relative ms), so the
-	 *  webview can compute heat decay without dealing with host clock skew. */
-	lastTouchedAt: Map<string, { edit?: number; read?: number }>;
-	/** Set to true when `resolveGitInfo` for the session's current cwd returned `undefined`
-	 *  (cwd is not a git repo). Prevents the `ensureSession` retry from firing forever on
-	 *  every subsequent hook event. Cleared when the session's cwd changes (re-resolution
-	 *  warranted) or on resetBookkeeping (Stop/SessionStart). */
-	gitInfoUnresolvable: boolean;
-	/** Set while the session's `worktreePath` came from the CLI (an event's `cwdTimeline`, or a poll
-	 *  record's). The CLI resolves the worktree for the exact cwd at hook time; the local probe answers
-	 *  for whichever repo the host registry matches, which for a nested cwd can be the parent worktree.
-	 *  While set, `resolveGitInfo` keeps the seated value instead of overwriting it. Cleared when the
-	 *  cwd moves without the CLI explaining the new location — attribution goes back to the probe. */
-	cliSeatedWorktree?: boolean;
-	/** Phase that immediately preceded the current one, with its original `phaseSince`. Used by
-	 *  `resolvePhaseSince` to restore continuity when phase oscillates back within a short
-	 *  window (e.g., Stop → idle → working after a continuation crosses the debounce). */
-	priorPhase?: { phase: AgentSessionPhase; phaseSince: Date };
-	/** Set once the reconciliation poll has seen this session's durable `ended` record. Gates
-	 *  ended-session removal: a session the live `SessionEnd` path just transitioned is never
-	 *  reconcile-removed by an already-in-flight poll that legitimately missed it — only after a poll
-	 *  has confirmed the CLI still lists it. */
-	polledAtLeastOnce?: boolean;
-	/** The durable record's cwd that a live listing superseded when a resume moved the session
-	 *  elsewhere. While the record still reports this exact cwd, a poll that no longer finds the
-	 *  session in the live listing must not re-seat the row (or trust the record's `endedAt`) —
-	 *  the record predates the resume. Cleared when the record's cwd changes (the CLI caught up). */
-	supersededRecordCwd?: string;
-	/** Set once an ended session's transcript has been read on demand (via
-	 *  `resolveEndedSessionDetails`). Terminal transcripts don't change, so the read happens at
-	 *  most once regardless of how many times the row is opened. */
-	endedDetailsResolved?: boolean;
-}
-
-const staleCheckIntervalMs = 15 * 60 * 1000; // 15 minutes
-/** Minimum spacing between gated reconciliation polls while NOTHING is running. The quarter-hourly
- *  tick exists to reap agents that died without a `SessionEnd`; with no live session there's nothing
- *  to reap, leaving only terminal-history reconciliation and the CLI's retention sweep — both fine
- *  hourly. Window startup polls ungated, so this never delays a fresh window. */
-const idleReconcileIntervalMs = 60 * 60 * 1000; // 1 hour
-/** How long a freshly-ended row is protected from absence-based removal. The CLI persists the
- *  ended record (atomic temp+rename) BEFORE broadcasting the hook event, so a poll that starts after
- *  we mark a row ended will list it — this guards only against that ordering changing on the CLI
- *  side, where the cost of being wrong is an ended row silently vanishing. */
-const endedRemovalGraceMs = 30 * 1000; // 30 seconds
-/** How long the machine-global archived-session id list (fetched via a separate `--status archived`
- *  CLI query) is cached. `listSessionHistory` asks for it once per worktree on panel open, so without
- *  this a multi-worktree graph spawns N identical CLI processes. `archiveSession` invalidates the
- *  cache, so a just-archived row never lingers under "Past". */
-const archivedSessionIdsCacheTtlMs = 10 * 1000; // 10 seconds
-/** Ended sessions defer git + transcript resolution (a 30-day cold-start would otherwise fan out
- *  hundreds of probes). Exception: sessions ended within this window still surface on WIP rows /
- *  branch cards, which match strictly by resolved `worktreePath` — so their git info is resolved
- *  eagerly at poll time (a handful), keeping the older tail lazy. Mirrors the 24h WIP-row window. */
-const recentEndedGitResolveThresholdMs = 24 * 60 * 60 * 1000; // 24 hours
-/** Default cooldown between PostToolUse and dropping the file from `fileActivity`. Held long
- *  enough that the treemap activity overlay can render a decay tail well past the moment the tool
- *  call completed. The host may override per-call via `AgentProviderCallbacks.getActivityDecayMs`
- *  (driven by the user's `gitlens.graph.experimental.visualizations.activityDecay` setting). */
-const defaultActivityDecayMs = 5 * 60 * 1000; // 5 minutes
-
-/** Grace period before `Stop` commits to `idle`. Long enough to absorb a same-turn continuation
- *  (hook-driven re-prompt, IPC event reordering, auto-resume); short enough that legitimate idle
- *  is visible promptly. */
-const stopToIdleDebounceMs = 750;
-
-/** If a phase transitions away and then back within this window, restore the prior `phaseSince`
- *  so the displayed elapsed time doesn't snap to 0 on transient oscillations. Slightly longer
- *  than `stopToIdleDebounceMs` so a continuation that just barely crosses the debounce still
- *  restores continuity. */
-const phaseSinceRestoreWindowMs = 2000;
-
-interface SessionFileData {
-	sessionId: string;
-	/** `gk ai hook` client id of the owning host — see {@link AgentSessionEvent.providerId}. */
-	providerId?: string;
-	/** The owning agent's NATIVE hook event name — see {@link AgentSessionEvent.event}. */
-	event: string;
-	/** The agent's RAW hook payload for {@link event}, relayed verbatim by the CLI — same field the
-	 *  live path reads off {@link AgentSessionEvent.hookInput}. The poll needs it because some agents
-	 *  encode an event's meaning in the payload rather than its name (OpenCode's `session.status`),
-	 *  and {@link resolveCanonicalHookEvent} can't canonicalize those without being handed it. */
-	hookInput?: Record<string, unknown>;
-	cwd: string;
-	/** CLI-provided launch directory; absent on older CLIs (fall back to `cwd`). */
-	initialCwd?: string;
-	/** Worktree roots (`git rev-parse --show-toplevel`) the CLI resolved for this session's cwd
-	 *  visits, newest last. Absent on older CLIs. Lets us read `worktreePath` straight from the
-	 *  durable store — so ended sessions attach to branch cards / WIP rows / the resume picker at
-	 *  any age without a git probe (the CLI already ran `rev-parse` at hook time). */
-	cwdTimeline?: { cwd: string; worktree?: string; at?: string }[];
-	worktrees?: string[];
-	pid: number;
-	toolName?: string | null;
-	agentId?: string | null;
-	agentType?: string | null;
-	source?: string | null;
-	model?: string | null;
-	updatedAt: string;
-	subagents?: { agentId: string; agentType: string }[];
-	planFile?: string | null;
-	sessionName?: string | null;
-	prompt?: string | null;
-	firstPrompt?: string | null;
-	/** CLI durable-session lifecycle status. Absent on legacy files → treated as `active`. `ended`
-	 *  records are surfaced as terminal `ended` sessions; `archived` is excluded by the query. */
-	status?: 'active' | 'ended' | 'archived';
-	/** Why the session ended (`session-end`, `rotated`, `stale`, `dead-pid`, `pid-zero-idle`,
-	 *  `archived`). Present only on `ended`/`archived` records. */
-	endReason?: string;
-	/** RFC3339 timestamp the session ended; used as `lastActivity`/`phaseSince` for ended rows. */
-	endedAt?: string;
-}
-
-/** The session's current worktree root from the CLI's durable record — the last cwd-visit's resolved
- *  worktree, falling back to the last distinct worktree seen. `undefined` on older CLIs that don't
- *  record it, so the caller resolves git the slow way instead. */
-function worktreeRootFromData(data: SessionFileData): string | undefined {
-	const fromTimeline = data.cwdTimeline?.at(-1)?.worktree;
-	if (fromTimeline) return fromTimeline;
-
-	return data.worktrees?.at(-1) || undefined;
-}
-
-/** The CLI resolves the worktree for `event.cwd` at hook time and includes it on every event —
- *  using its answer seats `worktreePath` synchronously, closing the in-flight-probe window where
- *  a session that just moved would otherwise still show its previous worktree until `resolveGitInfo`
- *  catches up. Scans from the end for the timeline entry matching the event's current cwd. */
-function worktreeFromEvent(event: AgentSessionEvent): string | undefined {
-	const timeline = event.cwdTimeline;
-	if (timeline == null) return undefined;
-
-	for (let i = timeline.length - 1; i >= 0; i--) {
-		const entry = timeline[i];
-		if (entry.cwd === event.cwd) return entry.worktree || undefined;
-	}
-
-	return undefined;
-}
-
-/** Reorders `paths` so each distinct (already-normalized) value is positioned by its LAST
- *  occurrence — an earlier occurrence of a value that recurs later is dropped, and the value's one
- *  remaining slot sits where that last occurrence falls. Implemented via delete-then-reinsert into
- *  a `Map`: re-inserting a key after deleting it moves it to the end of `Map` iteration order,
- *  which is exactly "this value's position is its most recent occurrence". */
-function orderByLastOccurrence(paths: readonly string[]): string[] {
-	const seen = new Map<string, true>();
-	for (const path of paths) {
-		seen.delete(path);
-		seen.set(path, true);
-	}
-	return [...seen.keys()];
-}
-
-/** Distinct, normalized, non-empty `worktree` values from a `cwdTimeline`, ordered by recency —
- *  positioned by each path's LAST occurrence in the (chronological) timeline, so a path the
- *  session returns to later sorts after one it doesn't. `undefined` when the timeline is absent or
- *  names no worktree — callers should NOT overwrite an existing `visitedWorktreePaths` with an
- *  empty array in that case. */
-function visitedFromTimeline(
-	timeline: { cwd: string; worktree?: string; at?: string }[] | undefined,
-): string[] | undefined {
-	if (timeline == null) return undefined;
-
-	const paths: string[] = [];
-	for (const entry of timeline) {
-		if (!entry.worktree) continue;
-
-		paths.push(normalizePath(entry.worktree));
-	}
-	if (paths.length === 0) return undefined;
-
-	return orderByLastOccurrence(paths);
-}
-
-/** Unions `adds` (each an array or a single path, `undefined` skipped) into `existing`, normalizing
- *  every path, and reorders the result by recency: every add — including one that names a path
- *  already in `existing` — moves that path to the end, same "last occurrence wins the slot" rule
- *  {@link orderByLastOccurrence} applies to a single timeline. Adds arrive in chronological order at
- *  every call site (timeline-derived paths first, the current `worktreePath` folded last), so the
- *  current worktree normally ends up last.
- *
- *  **Reference-stability contract — load-bearing**: returns `existing` BY REFERENCE, unchanged,
- *  when the resulting sequence is element-for-element identical to `existing`. Callers
- *  (`ensureSession`'s identity gate) rely on this to avoid firing spurious change events on every
- *  hook event / poll cycle when the visited set hasn't actually changed — re-processing an
- *  unchanged timeline plus the same current worktree reproduces the identical sequence (each path
- *  "moves" to the same slot it already occupies), so the comparison below still holds. */
-function unionVisited(
-	existing: readonly string[] | undefined,
-	...adds: (string | readonly string[] | undefined)[]
-): readonly string[] | undefined {
-	const combined = existing != null ? [...existing] : [];
-	for (const add of adds) {
-		if (add == null) continue;
-
-		const values = typeof add === 'string' ? [add] : add;
-		for (const value of values) {
-			if (!value) continue;
-
-			combined.push(normalizePath(value));
-		}
-	}
-
-	const next = orderByLastOccurrence(combined);
-	if (existing != null && next.length === existing.length && next.every((path, i) => path === existing[i])) {
-		return existing;
-	}
-	return next.length > 0 ? next : undefined;
-}
-
-/** Peer-merge variant of {@link unionVisited}: same normalize-and-dedupe, but APPEND-ONLY —
- *  `existing`'s order is preserved and any path the peer names that we don't already have is
- *  appended in the peer's own order. A peer's order can't be trusted as fresher than ours without
- *  timestamps, so peer input never reorders what we already hold. Returns `existing` BY REFERENCE
- *  when nothing new is added — same rationale as {@link unionVisited}. */
-function unionVisitedAppendOnly(
-	existing: readonly string[] | undefined,
-	...adds: (string | readonly string[] | undefined)[]
-): readonly string[] | undefined {
-	const next = new Set(existing ?? []);
-	let grew = false;
-	for (const add of adds) {
-		if (add == null) continue;
-
-		const values = typeof add === 'string' ? [add] : add;
-		for (const value of values) {
-			if (!value) continue;
-
-			const normalized = normalizePath(value);
-			if (!next.has(normalized)) {
-				next.add(normalized);
-				grew = true;
-			}
-		}
-	}
-	return grew ? [...next] : existing;
-}
-
-/** The event's tool name, translated from the agent's native vocabulary into the canonical (Claude
- *  Code) one. Prefers the raw `hookInput.tool_name` passthrough and falls back to the projected
- *  top-level field for older CLIs. Everything downstream — `describeToolInput`,
- *  `classifyPermissionKind`, `getToolFilePath`, `getToolReadPath`, and the display detail — expects
- *  canonical names, and Claude Code has no alias table, so its names pass through untouched. */
-function canonicalToolNameFromEvent(capabilities: AgentCapabilities, event: AgentSessionEvent): string | undefined {
-	const native = (event.hookInput?.tool_name as string | undefined) ?? event.toolName;
-	return native != null ? resolveCanonicalToolName(capabilities, native) : undefined;
-}
-
-/** Whether GitLens can actually answer a blocking permission ask from this agent. Two conditions,
- *  deliberately separate: the agent must support blocking hooks at all, AND the response we build
- *  must be one it understands. {@link PermissionResponse} is Claude-shaped
- *  (`hookSpecificOutput.hookEventName: 'PermissionRequest'`), so an agent that supports blocking
- *  hooks but expects a different envelope stays observe-only until per-agent response builders land
- *  — at which point the second clause is what gets deleted. */
-function canAnswerBlockingPermission(capabilities: AgentCapabilities): boolean {
-	return capabilities.supportsBlockingPermissions && capabilities.hookClientId === 'claude-code';
-}
-
-/** Synthesizes an unresolvable ask for a `permission_requested` row that has no routable
- *  `PendingPermission` — a non-blocking `Notification`/`PermissionRequest` tail, or a
- *  poll-discovered live/revived row. None of these hold a blocking hook entry to route an
- *  Allow/Deny through, so the card must show what the agent is waiting on without offering
- *  actions the host can't fulfill. */
-function synthesizeUnresolvableAsk(toolName: string | null | undefined, planFilePath?: string): PendingPermission {
-	if (toolName != null) {
-		const kind = classifyPermissionKind(toolName);
-		return {
-			kind: kind,
-			toolName: toolName,
-			toolDescription: toolName,
-			// A plan ask with no body at least links the plan the agent wrote, so the card can offer
-			// View Plan instead of a bare tool name.
-			planFilePath: kind === 'plan' ? planFilePath : undefined,
-			resolvable: false,
-		};
-	}
-
-	return {
-		kind: 'elicitation',
-		toolName: 'Input Required',
-		toolDescription: 'Waiting for input',
-		resolvable: false,
-	};
-}
-
-/** JSON.stringify with object keys recursively sorted — array order is preserved. `tool_input`
- *  can arrive with different key order (or via the top-level fallback field) between deliveries;
- *  canonicalizing makes input equality reliable across those variations. */
-function stableStringify(value: unknown): string {
-	return JSON.stringify(value, (_key, val: unknown) => {
-		if (val == null || typeof val !== 'object' || Array.isArray(val)) return val;
-
-		const sorted: Record<string, unknown> = {};
-		for (const key of Object.keys(val).sort()) {
-			sorted[key] = (val as Record<string, unknown>)[key];
-		}
-		return sorted;
-	});
-}
-
-/** Field-wise equality for the ask a `permission_requested` row publishes. `updateSessionStatus`
- *  compares it before short-circuiting so a second ask arriving while the row is already
- *  `permission_requested` (a non-blocking tail for a different tool) still reaches subscribers. */
-function isSameAsk(a: PendingPermission | undefined, b: PendingPermission | undefined): boolean {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-
-	return (
-		a.kind === b.kind &&
-		a.toolName === b.toolName &&
-		a.toolDescription === b.toolDescription &&
-		a.toolInputDescription === b.toolInputDescription &&
-		a.resolvable === b.resolvable &&
-		a.planFilePath === b.planFilePath &&
-		a.planSummary === b.planSummary &&
-		a.questionText === b.questionText &&
-		a.questionCount === b.questionCount
-	);
-}
-
-interface DiscoveryFile {
-	token: string;
-	address: string;
-	port?: number;
-	workspacePaths?: string[];
-}
-
-interface SessionContext {
-	/** The owning agent's descriptor — the source of a created session's `providerId`/`providerName`.
-	 *  Omitted only by the deferred-commit paths (the `Stop → idle` timer, a permission resolve),
-	 *  which run against a row that already exists. */
-	capabilities?: AgentCapabilities;
-	pid?: number;
-	workspacePath?: string;
-	isInWorkspace?: boolean;
-	cwd?: string;
-	/** CLI-provided launch directory (authoritative when present). */
-	initialCwd?: string;
-	planFile?: string;
-	sessionName?: string;
-	/** The model the session is running, from the hook event. */
-	model?: string;
-	/** CLI-resolved worktree root for the current cwd (authoritative when present). */
-	worktreePath?: string;
-	/** Distinct worktree roots observed via this event's cwdTimeline. */
-	visitedWorktreePaths?: string[];
-}
-
-type SerializedAgentSession = Omit<AgentSession, 'lastActivity' | 'phaseSince' | 'subagents'> & {
-	lastActivity: string;
-	phaseSince: string;
-	subagents?: (Omit<AgentSession, 'lastActivity' | 'phaseSince'> & {
-		lastActivity: string;
-		phaseSince: string;
-	})[];
-};
-
-/** Normalize a workspace path to GitLens canonical form (forward slashes, lower-case drive letter
- *  on Windows). Comparisons throughout the home view assume this form, but `_workspacePaths` and
- *  peer-session `workspacePath` values originate from `Uri.fsPath`, which on Windows uses
- *  backslashes and preserves drive-letter casing. Without this, `session.workspacePath ===
- *  repository.path` always fails on Windows. */
-function normalizeWorkspacePath(value: string | null | undefined): string | undefined {
-	return value ? normalizePath(value) : undefined;
-}
-
-type FileActivityEntry = NonNullable<AgentSession['fileActivity']>[number];
-
-/** Structural comparison of two `fileActivity` arrays — same set of paths, same kinds present,
- *  same `reading`/`editing` flags. Ignores numeric timestamp values because those drift between
- *  every call (Date.now() advances) even when nothing has actually changed. Used to gate event
- *  firing: timestamps still get refreshed via the `_sessions[]` write, but a fire only happens
- *  when the structural shape changed. Treats `undefined` and `[]` as equal. */
-function fileActivityStructurallyEqual(
-	a: readonly FileActivityEntry[] | undefined,
-	b: readonly FileActivityEntry[] | undefined,
-): boolean {
-	const aLen = a?.length ?? 0;
-	const bLen = b?.length ?? 0;
-	if (aLen !== bLen) return false;
-	if (aLen === 0) return true;
-
-	const byPath = new Map<string, FileActivityEntry>();
-	for (const entry of a!) {
-		byPath.set(entry.path, entry);
-	}
-	for (const entry of b!) {
-		const other = byPath.get(entry.path);
-		if (other == null) return false;
-		if ((entry.readAt != null) !== (other.readAt != null)) return false;
-		if ((entry.editedAt != null) !== (other.editedAt != null)) return false;
-		if ((entry.reading ?? false) !== (other.reading ?? false)) return false;
-		if ((entry.editing ?? false) !== (other.editing ?? false)) return false;
-	}
-	return true;
-}
-
-/**
- * Maps what `claude agents --json` reports for a live session onto `AgentSessionStatus`, per Claude's
- * documented agent-view vocabulary.
- *
- * `kind: 'interactive'` entries carry `status` while their process is alive, plus `waitingFor` when
- * that status is `waiting` — `'permission prompt'` is the one value with a distinct status of its own
- * here, since a permission request is a different kind of block from an ordinary question.
- *
- * `kind: 'background'` entries carry `state` instead: `working` / `blocked` / `done` / `failed` /
- * `stopped`, where `blocked` IS the documented "needs input" state.
- *
- * Returns `undefined` for a background session in a TERMINAL state. `--json` lists background
- * sessions "still working or blocked even when their process has exited", so a listing is not by
- * itself proof of life — without this, a genuinely finished session would be resurrected as `idle`,
- * which is the opposite of the bug this mapping exists to fix. Callers must not treat such an entry
- * as live: ended-record paths trust the durable record, while active discovery/repair paths skip or
- * remove the stale active row.
- *
- * Anything unrecognized degrades to `'idle'` rather than guessing a working/waiting phase.
- */
-/** Resolves a non-terminal listing override for an `ended` record. `undefined` means "let the ended
- *  record stand": either the listing doesn't mention this session, or its background state is
- *  terminal (see {@link statusFromLiveSession}). Active-record paths inspect the entry separately
- *  because they must distinguish absence (unknown; keep record status) from terminal (skip/remove). */
-function liveOverrideFor(
-	liveSessions: ReadonlyMap<string, LiveAgentSession> | undefined,
-	sessionId: string,
-): { live: LiveAgentSession; status: AgentSessionStatus } | undefined {
-	const live = liveSessions?.get(sessionId);
-	if (live == null) return undefined;
-
-	const status = statusFromLiveSession(live);
-	return status != null ? { live: live, status: status } : undefined;
-}
-
-function statusFromLiveSession(live: {
-	status?: string;
-	state?: string;
-	waitingFor?: string;
-}): AgentSessionStatus | undefined {
-	switch (live.status) {
-		case 'waiting':
-			return live.waitingFor === 'permission prompt' ? 'permission_requested' : 'waiting';
-		case 'busy':
-			return 'thinking';
-	}
-
-	switch (live.state) {
-		case 'blocked':
-			return 'waiting';
-		case 'working':
-			return 'thinking';
-		case 'done':
-		case 'failed':
-		case 'stopped':
-			return undefined;
-	}
-
-	return 'idle';
-}
-
-/** True when a CLI invocation failed because it didn't recognize a flag/command. `--status` and the
- *  active-only `list-sessions` default shipped together (gk 3.1.69); an older CLI rejects `--status`
- *  and returns all sessions unfiltered, so the flagless retry is the correct legacy equivalent. */
-function isUnknownFlagError(ex: unknown): boolean {
-	const message = ex instanceof Error ? ex.message : String(ex);
-	return /unknown (?:flag|shorthand flag|command)/i.test(message);
-}
-
-export class GkAgentProvider implements AgentSessionProvider {
-	/** Identifies the PROVIDER, not an agent: this one hosts every `gk ai hook` client GitLens has
-	 *  a descriptor for. A session's own agent identity lives on {@link AgentSession.providerId}
-	 *  (`claudeCode`, `codex`, …), sourced from {@link AgentCapabilities} — never from here. */
-	readonly id = 'gkAgents';
-	readonly name = 'Coding Agents';
-	readonly icon = 'robot';
-	readonly agentProviderIds: readonly string[] = agentCapabilities.map(c => c.providerId);
-
-	private readonly _onDidChangeSessions = new Emitter<void>();
-	readonly onDidChangeSessions = this._onDidChangeSessions.event;
-
-	private _sessions: AgentSession[] = [];
-	private _ipcStarted = false;
-	private _disposed = false;
-	private _handlerDisposables: UnifiedDisposable[] = [];
-	private readonly _pendingPermissions = new Map<string, PendingPermissionEntry>();
-	/** `sessionId -> cwd currently being probed`, and the newest cwd requested while that probe runs.
-	 *  A probe's answer is only valid for the cwd it was started with, so a session that moves
-	 *  mid-flight must supersede rather than dedupe — otherwise the older lookup lands last and
-	 *  overwrites the newer location with the directory the session already left. */
-	private readonly _resolveGitInfoInFlight = new Map<string, string>();
-	private readonly _resolveGitInfoPending = new Map<string, string>();
-	/** Short-TTL cache of the machine-global archived-session id list. Holds the in-flight promise so
-	 *  concurrent per-worktree `getPastSessions` calls share one CLI spawn; `archiveSession` clears it. */
-	private _archivedSessionIdsCache: { promise: Promise<string[]>; at: number } | undefined;
-	private readonly _sessionBookkeeping = new Map<string, SessionBookkeeping>();
-	/** Per-session timers for the deferred `Stop → idle` commit. The handle is cleared (and the
-	 *  transition cancelled) by any non-idle status update arriving before the timer fires. */
-	private readonly _pendingIdleTimers = new Map<string, NodeJS.Timeout>();
-	private _workspacePaths: string[] = [];
-	private _staleCheckTimer: UnifiedDisposable | undefined;
-	/** When the last poll actually ran (gated or not) — paces the idle cadence above. */
-	private _lastSyncAt = 0;
-	/** Whether agent hooks are installed, pushed by the host via {@link setHooksInstalled}.
-	 *  Fail-open (`true`) until the first push lands so a fresh window with real hooks isn't
-	 *  suppressed on its first ticks. Gates the reconciliation poll in {@link syncSessions}. */
-	private _hooksInstalled = true;
-	/** Whether the CLI supports `list-sessions --status` (and with it the durable ended-session
-	 *  store). Optimistic until the poll's flagless fallback proves otherwise. When unsupported,
-	 *  ended rows are untenable — no poll can ever confirm or archive one — so `SessionEnd`
-	 *  reverts to removing the session and reconciliation drops any ended stragglers. */
-	private _statusFilterSupported = true;
-	protected _transcriptReader: ClaudeCodeTranscriptReader = new ClaudeCodeTranscriptReader();
-	private _terminalGeneration = 0;
-	/** Ended-transcript detail results, cached forever per window — an ended transcript is
-	 *  immutable, so once resolved it never needs a second read. Keyed by session id. */
-	private readonly _sessionDetailsCache = new Map<string, Promise<EndedTranscriptDetails | undefined>>();
-
-	constructor(private readonly callbacks: AgentProviderCallbacks) {}
-
-	get sessions(): readonly AgentSession[] {
-		return this._sessions;
-	}
-
-	get terminalGeneration(): number {
-		return this._terminalGeneration;
-	}
-
-	/** Single choke point for every terminal transition — a session ending, being removed on end
-	 *  (legacy path), being pruned, or a fresh ended record being discovered. Bumps the generation
-	 *  the host's history queries validate against (a transition mid-query means the answer may be
-	 *  missing a session) and drops the transcript listing caches, whose warm entries may predate
-	 *  the transcript the transition just left behind. */
-	private noteTerminalTransition(): void {
-		this._terminalGeneration++;
-		this._transcriptReader.invalidateListings();
-	}
-
-	start(workspacePaths: string[]): void {
-		this._workspacePaths = workspacePaths.map(p => normalizePath(p));
-		void this.ensureIpcServer();
-	}
-
-	stop(): void {
-		// IPC server stays up intentionally — hooks fire even when the window is unfocused
-	}
-
-	sync(): Promise<void> {
-		return this.syncSessions();
-	}
-
-	updateWorkspacePaths(workspacePaths: string[]): void {
-		this._workspacePaths = workspacePaths.map(p => normalizePath(p));
-
-		let changed = false;
-		for (let i = 0; i < this._sessions.length; i++) {
-			const s = this._sessions[i];
-			const nextWorkspacePath = s.cwd != null ? this.resolveWorkspacePath(s.cwd) : undefined;
-			const nextIsInWorkspace = nextWorkspacePath != null;
-			let subagentsChanged = false;
-			const subagents = s.subagents?.map(sub => {
-				const subNextWorkspacePath = sub.cwd != null ? this.resolveWorkspacePath(sub.cwd) : nextWorkspacePath;
-				const subNextIsInWorkspace = sub.cwd != null ? subNextWorkspacePath != null : nextIsInWorkspace;
-				if (sub.isInWorkspace === subNextIsInWorkspace && sub.workspacePath === subNextWorkspacePath) {
-					return sub;
-				}
-
-				subagentsChanged = true;
-				return { ...sub, isInWorkspace: subNextIsInWorkspace, workspacePath: subNextWorkspacePath };
-			});
-			if (s.isInWorkspace !== nextIsInWorkspace || s.workspacePath !== nextWorkspacePath || subagentsChanged) {
-				this._sessions[i] = {
-					...s,
-					isInWorkspace: nextIsInWorkspace,
-					workspacePath: nextWorkspacePath,
-					subagents: subagents,
-				};
-				changed = true;
-			}
-		}
-		if (changed) {
-			this._onDidChangeSessions.fire();
-		}
-
-		if (!this._ipcStarted) {
-			// IPC wasn't bootstrapped yet — start it. ensureIpcServer publishes with the
-			// current `_workspacePaths`.
-			void this.ensureIpcServer();
-		} else {
-			// Re-publish so the agents discovery file reflects the new workspacePaths.
-			this.callbacks.ipc
-				.publishAgents(this._workspacePaths)
-				.catch((ex: unknown) => Logger.error(ex, 'GkAgentProvider.updateWorkspacePaths: publishAgents failed'));
-		}
-	}
-
-	setHooksInstalled(installed: boolean): void {
-		const wasOff = !this._hooksInstalled;
-		this._hooksInstalled = installed;
-		// On a fresh off→on transition, reconcile immediately rather than waiting up to a full
-		// interval — picks up any session that was already running before hooks were installed.
-		// This is a deliberate discovery pass (like the cold-start bootstrap), not a routine tick:
-		// hooks were just off, so the live path couldn't have seen these sessions and anything we
-		// find here is expected, not drift. Run it ungated so it neither skips nor reports drift
-		// telemetry (an ungated `syncSessions()` always polls and never emits `onSyncDiscrepancy`).
-		if (installed && wasOff) {
-			void this.syncSessions();
-		}
-	}
-
-	/** Reads Claude history from its transcript store and tracked terminal records. The exact project
-	 *  directory preserves legacy sessions that predate the CLI's durable records. Recent ended
-	 *  records add an authoritative worktree-to-session association, so their ids are also recovered
-	 *  from other project directories when Claude left the transcript behind after a cwd/worktree
-	 *  move. A tracked record with no readable transcript remains visible and archivable, but does not
-	 *  advertise Resume. Archive filtering stays provider-local so ids from another harness cannot
-	 *  suppress Claude rows. `requireResume` drops the transcript-less tracked records, leaving only
-	 *  rows that carry a resume action — and a `total` counting only those. */
-	async listSessionHistory(cwd: string, options?: AgentSessionHistoryOptions): Promise<AgentSessionHistoryResult> {
-		const resumeOnly = options?.requireResume === true;
-		// No launcher means no row can carry resume, so a resume-only query has nothing to return.
-		if (resumeOnly && this.callbacks.resumeSession == null) return { sessions: [], total: 0 };
-
-		const archivedSessionIds = new Set(await this.getArchivedSessionIds());
-		const excludeSessionIds = new Set(options?.excludeSessionIds);
-		for (const id of archivedSessionIds) {
-			excludeSessionIds.add(id);
-		}
-
-		const trackedEndedSessions: AgentSession[] = [];
-		const endedSessionIds = new Set<string>();
-		for (const session of this._sessions) {
-			if (
-				session.status === 'ended' &&
-				session.worktreePath != null &&
-				arePathsEqual(session.worktreePath, cwd) &&
-				!excludeSessionIds.has(session.id)
-			) {
-				// A tracked record's own row carries archive but no resume; its id still drives transcript
-				// recovery below, which does produce a resumable row when the transcript moved with it.
-				if (!resumeOnly) {
-					trackedEndedSessions.push(session);
-				}
-				// Only an agent whose sessions can be resumed feeds transcript recovery. The reader is
-				// Claude-transcript-specific, so another agent's id could only ever miss — but stating it
-				// keeps the resume capability the reason, rather than leaving it to a coincidence of which
-				// store the reader happens to read.
-				if (getAgentCapabilitiesByProviderId(session.providerId)?.supportsResume !== false) {
-					endedSessionIds.add(session.id);
-				}
-			}
-		}
-
-		const [direct, recovered] = await Promise.all([
-			this._transcriptReader.listSessions(cwd, {
-				limit: options?.limit,
-				excludeSessionIds: excludeSessionIds,
-			}),
-			this._transcriptReader.listSessionsByIds(endedSessionIds, {
-				limit: options?.limit,
-				excludeCwd: cwd,
-			}),
-		]);
-
-		const historyById = new Map<string, AgentSessionHistoryItem>();
-		const addTranscript = (session: (typeof direct.sessions)[number], resumeCwd: string): void => {
-			if (excludeSessionIds.has(session.sessionId)) return;
-
-			const disposition = archivedSessionIds.has(session.sessionId) ? 'archived' : 'ended';
-			const resumeActions = this.callbacks.resumeSession != null ? { resume: { cwd: resumeCwd } } : {};
-			historyById.set(session.sessionId, {
-				id: session.sessionId,
-				// The reader only reads Claude Code's transcript store, so every row it produces is
-				// Claude's by construction.
-				providerId: claudeCodeCapabilities.providerId,
-				disposition: disposition,
-				actions: disposition === 'ended' ? { ...resumeActions, archive: true } : resumeActions,
-				lastActivity: new Date(session.lastActivityMs),
-				titles: session.titles,
-				lastPrompt: session.lastPrompt,
-			});
-		};
-		for (const session of direct.sessions) {
-			addTranscript(session, cwd);
-		}
-		for (const session of recovered.sessions) {
-			addTranscript(session, session.cwd);
-		}
-
-		for (const session of trackedEndedSessions) {
-			if (historyById.has(session.id)) continue;
-
-			historyById.set(session.id, {
-				id: session.id,
-				providerId: session.providerId,
-				disposition: 'ended',
-				actions: { archive: true },
-				lastActivity: session.lastActivity,
-				name: session.name,
-				titles: session.transcriptTitles,
-				firstPrompt: session.firstPrompt,
-				lastPrompt: session.lastPrompt,
-			});
-		}
-
-		const history = [...historyById.values()].sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
-		const limited = options?.limit != null && options.limit > 0 ? history.slice(0, options.limit) : history;
-
-		return { sessions: limited, total: Math.max(direct.total + recovered.total, history.length) };
-	}
-
-	resumeSession(
-		sessionId: string,
-		cwd: string,
-		target: AgentSessionResumeTarget,
-		name?: string,
-	): Promise<AgentSessionResumeOutcome | false> {
-		return this.callbacks.resumeSession?.(sessionId, cwd, target, name) ?? Promise.resolve(false);
-	}
-
-	dispose(): void {
-		this._disposed = true;
-		this.stop();
-		this._staleCheckTimer?.dispose();
-		this._staleCheckTimer = undefined;
-		for (const d of this._handlerDisposables) {
-			d.dispose();
-		}
-		this._handlerDisposables = [];
-		for (const pending of this._pendingPermissions.values()) {
-			this.rejectAllPending(pending, new Error('Provider disposed'));
-		}
-		this._pendingPermissions.clear();
-		for (const bk of this._sessionBookkeeping.values()) {
-			this.cancelPendingFileClears(bk);
-			this.cancelPendingReadClears(bk);
-		}
-		for (const timer of this._pendingIdleTimers.values()) {
-			clearTimeout(timer);
-		}
-		this._pendingIdleTimers.clear();
-		this._sessionBookkeeping.clear();
-		if (this._ipcStarted) {
-			void this.callbacks.ipc.unpublishAgents();
-			this._ipcStarted = false;
-		}
-		this._onDidChangeSessions.dispose();
-	}
-
-	[Symbol.dispose](): void {
-		this.dispose();
-	}
-
-	@gate<typeof GkAgentProvider.prototype.ensureIpcServer>()
-	private async ensureIpcServer(): Promise<void> {
-		if (this._ipcStarted || this._disposed) return;
-
-		// Register handlers before any async work so blocking permission requests aren't delayed.
-		const handlers: UnifiedDisposable[] = [
-			this.callbacks.ipc.registerHandler('agents/session', (request, searchParams) => {
-				if (request != null) {
-					const isBlocking = searchParams.get('blocking') === 'true';
-					return this.handleSessionEvent(request as AgentSessionEvent, isBlocking);
-				}
-				return Promise.resolve();
-			}),
-			this.callbacks.ipc.registerHandler('agents/sessions/list', () =>
-				Promise.resolve(
-					// Exclude terminal `ended` rows: an older-version peer has no `ended` phase and
-					// would import them as phantom "idle" sessions. Our own poll surfaces ended sessions
-					// independently, so peers never need them from here.
-					this._sessions
-						.filter(s => s.status !== 'ended')
-						.map(s => ({
-							...s,
-							lastActivity: s.lastActivity.toISOString(),
-							phaseSince: s.phaseSince.toISOString(),
-							subagents: s.subagents?.map(sub => ({
-								...sub,
-								lastActivity: sub.lastActivity.toISOString(),
-								phaseSince: sub.phaseSince.toISOString(),
-							})),
-						})),
-				),
-			),
-			this.callbacks.ipc.registerHandler('agents/sessions/open', async request => {
-				const sessionId = (request as { sessionId?: string } | undefined)?.sessionId;
-				if (!sessionId || this.callbacks.openSessionInClaudeExtension == null) {
-					return { opened: false };
-				}
-
-				try {
-					await this.callbacks.openSessionInClaudeExtension(sessionId);
-					return { opened: true };
-				} catch (ex) {
-					Logger.warn(
-						`GkAgentProvider.agents/sessions/open: ${ex instanceof Error ? ex.message : String(ex)}`,
-					);
-					return { opened: false };
-				}
-			}),
-		];
-
-		try {
-			await this.callbacks.ipc.publishAgents(this._workspacePaths);
-		} catch (ex) {
-			// Unwind so a retry can re-register without hitting "already registered".
-			for (const d of handlers) {
-				d.dispose();
-			}
-			Logger.error(ex, 'GkAgentProvider.ensureIpcServer');
-			return;
-		}
-
-		// `publishAgents` no-ops silently if the IPC server failed to start; don't seal
-		// retries in that case — the next call should re-attempt.
-		if (this.callbacks.ipc.port == null) {
-			for (const d of handlers) {
-				d.dispose();
-			}
-			return;
-		}
-
-		if (this._disposed) {
-			for (const d of handlers) {
-				d.dispose();
-			}
-			return;
-		}
-
-		this._handlerDisposables = handlers;
-		this._ipcStarted = true;
-
-		try {
-			await this.syncSessions();
-			if (this._disposed) return;
-
-			void this.querySiblingWindowSessions();
-
-			this._staleCheckTimer?.dispose();
-			this._staleCheckTimer = disposableInterval(
-				() => void this.syncSessions({ gate: true }),
-				staleCheckIntervalMs,
-			);
-		} catch (ex) {
-			Logger.error(ex, 'GkAgentProvider.ensureIpcServer');
-		}
-	}
-
-	private handleSessionEvent(event: AgentSessionEvent, isBlocking: boolean): Promise<PermissionResponse | void> {
-		// The CLI broadcasts every AI host's events to every listener, stamped with its `gk ai hook`
-		// client id. Absent = `claude-code`: older CLIs don't stamp it, and no other client existed
-		// then. A client we hold no descriptor for is dropped — the CLI supports more than this table
-		// does, and we can't interpret an agent whose vocabulary we don't know. A dropped blocking
-		// request gets no decision, so the CLI waits out its own hook timeout, which is correct: we
-		// must not answer for an agent we don't track.
-		const hookClientId = event.providerId ?? 'claude-code';
-		const capabilities = getAgentCapabilities(hookClientId);
-		if (capabilities == null) {
-			Logger.debug(`GkAgentProvider.handleSessionEvent: ignoring ${event.event} from ${hookClientId}`);
-			return Promise.resolve();
-		}
-
-		// The CLI relays each agent's native event name verbatim, so translate before doing anything
-		// else. An unresolvable name must never reach the switch below: it would match no case while
-		// still having created/updated a row, and for a blocking delivery would answer nothing while
-		// looking handled.
-		const hookEvent = resolveCanonicalHookEvent(capabilities, event.event, event.hookInput);
-		if (hookEvent == null) {
-			Logger.debug(
-				`GkAgentProvider.handleSessionEvent: ignoring unmapped event ${event.event} from ${hookClientId}`,
-			);
-			return Promise.resolve();
-		}
-
-		const toolName = canonicalToolNameFromEvent(capabilities, event);
-		const workspacePath = this.resolveWorkspacePath(event.cwd);
-		const eventContext: SessionContext = {
-			capabilities: capabilities,
-			pid: event.pid,
-			workspacePath: workspacePath,
-			isInWorkspace: workspacePath != null,
-			cwd: event.cwd,
-			initialCwd: event.initialCwd,
-			planFile: event.planFile,
-			sessionName: event.sessionName,
-			model: event.model,
-			worktreePath: worktreeFromEvent(event),
-			visitedWorktreePaths: visitedFromTimeline(event.cwdTimeline),
-		};
-		const tag = this.sessionTag(event.sessionId, event.sessionName ?? 'unnamed');
-		// Log the native name alongside the canonical one — a mapping mistake is otherwise invisible.
-		const eventTag = event.event === hookEvent ? hookEvent : `${hookEvent}(${event.event})`;
-
-		if (hookEvent === 'SessionStart' || hookEvent === 'SessionEnd') {
-			Logger.info(`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}`);
-		} else {
-			Logger.debug(
-				`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}${toolName ? ` tool=${toolName}` : ''}${event.agentId ? ` agent=${event.agentId}` : ''}${event.notificationType ? ` type=${event.notificationType}` : ''}`,
-			);
-		}
-
-		switch (hookEvent) {
-			case 'SessionStart': {
-				const wasNew = this._sessions.findIndex(s => s.id === event.sessionId) < 0;
-				const { index } = this.ensureSession(event.sessionId, eventContext);
-
-				if (wasNew) {
-					// ensureSession created the session at 'idle' already. Just refresh pid if
-					// the event carries one — bookkeeping was implicitly clean.
-					this.resetBookkeeping(event.sessionId);
-					if (event.pid != null) {
-						const prev = this._sessions[index];
-						if (prev.pid !== event.pid) {
-							this._sessions[index] = { ...prev, pid: event.pid };
-						}
-					}
-				} else {
-					const prev = this._sessions[index];
-					if (prev.status === 'ended') {
-						// Resuming a terminal session reuses its id, so a SessionStart on an ended
-						// row IS the resume signal — revive it to a live `idle` row (clearing the
-						// ended/archivable state) with clean bookkeeping that endSession tore
-						// down. The next real event advances it out of idle. A `SessionStart` arrives on
-						// THIS window's hook flow, so the resume is locally owned now: clear the peer
-						// ownership carried over from the terminal record, and take the resume's pid
-						// (never the old terminal/reused one — retaining it would let dispatch focus a
-						// stale or unrelated process).
-						this._sessions[index] = {
-							...prev,
-							status: 'idle',
-							phase: 'idle',
-							phaseSince: new Date(),
-							lastActivity: new Date(),
-							pid: event.pid,
-							isPeerOwned: undefined,
-						};
-						this.resetBookkeeping(event.sessionId);
-					} else if (event.pid != null && event.pid !== prev.pid) {
-						// SessionStart for a live session we already track is almost always a CLI
-						// replay (resume/reconnect/hook re-init). Don't clobber live state — the next
-						// real event re-establishes status. Refresh pid only.
-						this._sessions[index] = { ...prev, pid: event.pid, lastActivity: new Date() };
-					}
-				}
-
-				this._onDidChangeSessions.fire();
-				void this.resolveTranscriptTitles(event.sessionId, event.cwd);
-				this.callbacks.onSessionStarted?.(capabilities.providerId);
-				break;
-			}
-
-			case 'SessionEnd': {
-				const pending = this._pendingPermissions.get(event.sessionId);
-				if (pending != null) {
-					this.rejectAllPending(pending, new Error('Session ended'));
-					this._pendingPermissions.delete(event.sessionId);
-				}
-				this.cancelPendingIdleTransition(event.sessionId);
-
-				const index = this._sessions.findIndex(s => s.id === event.sessionId);
-				if (index >= 0) {
-					if (this._statusFilterSupported) {
-						// Transition to a terminal `ended` row rather than removing it — ended
-						// sessions stay visible (de-emphasized) until archived or 30-day-purged by the CLI.
-						this.endSession(index, new Date());
-					} else {
-						// Legacy CLI (no `--status` durable store): an ended row could never be
-						// poll-confirmed nor archived, so keep the pre-ended remove-on-end behavior.
-						this._sessions.splice(index, 1);
-						const bk = this._sessionBookkeeping.get(event.sessionId);
-						if (bk != null) {
-							this.cancelPendingFileClears(bk);
-							this.cancelPendingReadClears(bk);
-						}
-						this._sessionBookkeeping.delete(event.sessionId);
-						this._transcriptReader.forget(event.sessionId);
-						this.noteTerminalTransition();
-					}
-					this._onDidChangeSessions.fire();
-				} else {
-					// SessionEnd for a session we no longer track (already pruned/removed, or a duplicate
-					// end): still clear any bookkeeping timers + transcript cache the row left behind, so
-					// they don't leak. The tracked branches above already tear this down themselves.
-					const bk = this._sessionBookkeeping.get(event.sessionId);
-					if (bk != null) {
-						this.cancelPendingFileClears(bk);
-						this.cancelPendingReadClears(bk);
-					}
-					this._sessionBookkeeping.delete(event.sessionId);
-					this._transcriptReader.forget(event.sessionId);
-					// Untracked or not, a session just reached a terminal state and finalized its
-					// transcript — an in-flight history query must not accept an answer that predates it.
-					this.noteTerminalTransition();
-				}
-				this.callbacks.onSessionEnded?.(capabilities.providerId);
-				break;
-			}
-
-			case 'UserPromptSubmit': {
-				const { index, changed } = this.ensureSession(event.sessionId, eventContext);
-				// Seated metadata (location, model, name) has to reach subscribers even when the prompt
-				// turns out to be synthetic and the status update below never runs.
-				if (changed) {
-					this._onDidChangeSessions.fire();
-				}
-
-				const cleaned = prepareStoredPrompt(event.prompt);
-				// A `UserPromptSubmit` whose payload sanitizes to nothing is harness-synthetic
-				// (e.g. background-bash <task-notification>, slash-command stdout echo). Treat it
-				// as informational so it doesn't flip the session to `thinking` or wipe a pending
-				// permission when no real user activity occurred.
-				if (!cleaned) break;
-
-				const existing = this._sessions[index];
-				this._sessions[index] = {
-					...existing,
-					lastPrompt: cleaned,
-					firstPrompt: existing.firstPrompt ?? prepareStoredPrompt(event.firstPrompt),
-				};
-				this.clearStalePermission(event.sessionId, 'UserPromptSubmit');
-				this.updateSessionStatus(event.sessionId, 'thinking', eventContext);
-				break;
-			}
-
-			case 'PreToolUse': {
-				const bk = this.getBookkeeping(event.sessionId);
-				bk.activeToolCount++;
-				const filesChanged = this.trackToolUseFile(event.sessionId, event, capabilities);
-				const readsChanged = this.trackToolUseRead(event.sessionId, event, capabilities);
-				// Resolve a rich `Bash(grep …)`-style detail via the same tool_input passthrough the
-				// PermissionRequest handler uses, so working sessions surface what their tool is
-				// actually doing — not just the bare tool name. Falls back to bare name when no
-				// toolInput is available (older CLI / unhandled tool).
-				const toolInput =
-					(event.hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
-				const statusDetail =
-					toolInput != null && toolName ? describeToolInput(toolName, toolInput) : toolName || undefined;
-				// Capture pre-update status so we can tell whether the upcoming updateSessionStatus
-				// will fire on its own — needed to avoid dropping fileActivity changes when the
-				// session is already in tool_use (back-to-back tool calls).
-				const sessionIndex = this._sessions.findIndex(s => s.id === event.sessionId);
-				const prevStatus = sessionIndex >= 0 ? this._sessions[sessionIndex].status : undefined;
-				const prevDetail = sessionIndex >= 0 ? this._sessions[sessionIndex].statusDetail : undefined;
-				const statusWillFire = prevStatus !== 'tool_use' || prevDetail !== statusDetail;
-				this.updateSessionStatus(event.sessionId, 'tool_use', {
-					...eventContext,
-					statusDetail: statusDetail,
-				});
-				if ((filesChanged || readsChanged) && !statusWillFire) {
-					this._onDidChangeSessions.fire();
-				}
-				break;
-			}
-
-			case 'PostToolUse':
-			case 'PostToolUseFailure': {
-				this.clearStalePermission(event.sessionId, hookEvent, this.settledByFromEvent(event, capabilities));
-				const bk = this.getBookkeeping(event.sessionId);
-				bk.activeToolCount = Math.max(0, bk.activeToolCount - 1);
-				// Cooldown the file-edit decoration instead of dropping it immediately, so a quick
-				// follow-up Edit/Write to the same path doesn't blink. The deferred clear fires its
-				// own change event when it expires. The immediate re-sync inside each flips
-				// `editing`/`reading` off the moment refcount hits zero, though — capture whether that
-				// changed the published list so we fire it ourselves when the status update below short-
-				// circuits (a parallel tool is still in flight, so activeToolCount stays > 0).
-				const filesChanged = this.scheduleClearToolUseFile(event.sessionId, event, capabilities);
-				const readsChanged = this.scheduleClearToolUseRead(event.sessionId, event, capabilities);
-				if (bk.activeToolCount === 0) {
-					// updateSessionStatus short-circuits without firing when status+detail are unchanged
-					// (already 'thinking' with no detail) — which would drop the editing/reading flag-flip
-					// above and leave a stale live pulse. Capture whether it will fire on its own and, if
-					// not, fire explicitly — mirrors the PreToolUse / PermissionDenied guards.
-					const idx = this._sessions.findIndex(s => s.id === event.sessionId);
-					const statusWillFire =
-						idx < 0 ||
-						this._sessions[idx].status !== 'thinking' ||
-						this._sessions[idx].statusDetail != null;
-					this.updateSessionStatus(event.sessionId, 'thinking', eventContext);
-					if ((filesChanged || readsChanged) && !statusWillFire) {
-						this._onDidChangeSessions.fire();
-					}
-				} else if (filesChanged || readsChanged) {
-					this._onDidChangeSessions.fire();
-				}
-				break;
-			}
-
-			case 'Stop':
-			case 'StopFailure': {
-				const pending = this._pendingPermissions.get(event.sessionId);
-				if (pending != null) {
-					this.rejectAllPending(pending, new Error('Session stopped'));
-					this._pendingPermissions.delete(event.sessionId);
-				}
-				// Turn ended: stop the "live" pulse but keep the per-operation decay tail fading over
-				// the configured window (anchored at each tool's completion, not at the turn end). A full
-				// reset here would wipe the tail the instant the agent finishes a response.
-				this.settleBookkeeping(event.sessionId);
-				// Apply Stop's metadata synchronously so we don't carry stale context through the
-				// debounce window — any in-window mutations (e.g. CwdChanged) survive when the
-				// timer fires. ensureSession doesn't fire on metadata-only updates of existing
-				// sessions, so fire here to match the original Stop-handler's UI-update semantics.
-				const { changed } = this.ensureSession(event.sessionId, eventContext);
-				if (changed) {
-					this._onDidChangeSessions.fire();
-				}
-				// Defer the status change — if the agent continues within the debounce window
-				// (hook-driven re-prompt, IPC reordering, auto-resume), the next non-idle event
-				// cancels this and we never flick through idle.
-				this.scheduleIdleTransition(event.sessionId);
-				break;
-			}
-
-			case 'PreCompact':
-				this.updateSessionStatus(event.sessionId, 'compacting', eventContext);
-				break;
-
-			case 'PostCompact':
-				this.updateSessionStatus(event.sessionId, 'thinking', eventContext);
-				break;
-
-			case 'Notification':
-				switch (event.notificationType) {
-					case 'idle_prompt':
-						// No-op — session is already idle from the preceding stop/session-start event
-						break;
-					case 'permission_prompt':
-						this.updateSessionStatus(event.sessionId, 'permission_requested', {
-							...eventContext,
-							statusDetail: toolName,
-							pendingPermission: synthesizeUnresolvableAsk(
-								toolName,
-								// Plan-kind body: prefer the session's planFile, fall back to the event's
-								// — mirrors the blocking path.
-								this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile,
-							),
-						});
-						break;
-					case 'elicitation_dialog':
-						// An MCP elicitation, not a tool permission — `toolName` names the elicitation, so
-						// classifying it as a tool ask would mislabel the card. Same shape the `Elicitation`
-						// hook produces.
-						this.updateSessionStatus(event.sessionId, 'permission_requested', {
-							...eventContext,
-							statusDetail: toolName,
-							pendingPermission: {
-								kind: 'elicitation',
-								toolName: toolName ?? 'Input Required',
-								toolDescription: toolName ?? 'Waiting for input',
-								resolvable: false,
-							},
-						});
-						break;
-					default:
-						// auth_success, unknown, or missing: no status change, just update timestamp
-						break;
-				}
-				break;
-
-			case 'PermissionRequest': {
-				// hookInput is the raw passthrough; fall back to top-level fields for older CLI versions.
-				const hookInput = event.hookInput;
-				const toolInput = (hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
-				// An agent whose asks we can't answer falls through to the observe-only branch below,
-				// which publishes the same card marked `resolvable: false`. Registering a pending entry
-				// for it would promise an Allow/Deny this window can never route.
-				if (canAnswerBlockingPermission(capabilities) && isBlocking && toolInput != null) {
-					const askToolName = toolName ?? '';
-					const toolDescription = describeToolInput(askToolName, toolInput);
-					const toolInputDescription = (toolInput.description as string | undefined) || undefined;
-					const kind: PendingPermissionKind = classifyPermissionKind(askToolName);
-					const toolUseId = hookInput?.tool_use_id as string | undefined;
-					const toolInputJson = stableStringify(toolInput);
-
-					return new Promise<PermissionResponse>((resolve, reject) => {
-						const existing = this._pendingPermissions.get(event.sessionId);
-						// Same identity as `settledByFromEvent`'s comparisons: `toolUseId` when both sides
-						// have one, else toolName + canonical input.
-						const isDuplicateDelivery =
-							existing != null &&
-							((existing.toolUseId != null && toolUseId != null && existing.toolUseId === toolUseId) ||
-								(existing.toolUseId == null &&
-									toolUseId == null &&
-									existing.toolName === askToolName &&
-									existing.toolInputJson === toolInputJson));
-
-						if (isDuplicateDelivery) {
-							// Duplicate delivery of the same ask (CLI retry after its 60s response-header
-							// timeout) — attach instead of replacing so both connections settle together.
-							// Nothing about the display changes, so skip rebuilding it below. Accepted
-							// residual: two independent, identical, concurrent asks are byte-for-byte
-							// indistinguishable on the wire and coalesce the same way, receiving one
-							// decision — evicting instead would falsely deny a live ask.
-							existing.resolvers.push({ resolve: resolve, reject: reject });
-							return;
-						}
-
-						if (existing != null) {
-							Logger.debug(
-								`GkAgentProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`,
-							);
-							this.resolveAllPending(existing, {
-								hookSpecificOutput: {
-									hookEventName: 'PermissionRequest',
-									decision: { behavior: 'deny' },
-								},
-							});
-						}
-
-						this._pendingPermissions.set(event.sessionId, {
-							resolvers: [{ resolve: resolve, reject: reject }],
-							toolName: askToolName,
-							toolDescription: toolDescription,
-							toolUseId: toolUseId,
-							toolInputJson: toolInputJson,
-						});
-
-						// Plan-kind body: prefer the existing session's planFile (set via SessionStart/
-						// PostToolUse) and fall back to the event's planFile for cold-start cases.
-						const planFilePath =
-							kind === 'plan'
-								? (this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile)
-								: undefined;
-						const planSummary = kind === 'plan' ? extractPlanSummary(toolInput) : undefined;
-						const questionDetails = kind === 'question' ? extractQuestionDetails(toolInput) : undefined;
-
-						const permission: PendingPermission = {
-							kind: kind,
-							toolName: askToolName,
-							toolDescription: toolDescription,
-							toolInputDescription: toolInputDescription,
-							suggestions:
-								(hookInput?.permission_suggestions as PermissionSuggestion[] | undefined) ??
-								event.permissionSuggestions,
-							planFilePath: planFilePath,
-							planSummary: planSummary,
-							questionText: questionDetails?.text,
-							questionCount: questionDetails?.count,
-						};
-						this.updateSessionWithPermission(event.sessionId, permission, eventContext);
-					});
-				}
-
-				{
-					// Mirror the blocking payload's shape so the ask renders identically either way —
-					// just unresolvable, since no blocking hook entry exists to route an answer through.
-					const kind = toolName != null ? classifyPermissionKind(toolName) : undefined;
-					// Plan-kind body: same session-first preference as the blocking path.
-					const planFilePath =
-						kind === 'plan'
-							? (this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile)
-							: undefined;
-					// Same body extraction as the blocking path — surfaces render `questionText`/
-					// `planSummary` in place of the tool description, so omitting them would show a
-					// generic "awaiting" card for a question the input actually carries.
-					const questionDetails =
-						kind === 'question' && toolInput != null ? extractQuestionDetails(toolInput) : undefined;
-					const synthesized: PendingPermission =
-						kind != null && toolName != null && toolInput != null
-							? {
-									kind: kind,
-									toolName: toolName,
-									toolDescription: describeToolInput(toolName, toolInput),
-									toolInputDescription: (toolInput.description as string | undefined) || undefined,
-									planFilePath: planFilePath,
-									planSummary: kind === 'plan' ? extractPlanSummary(toolInput) : undefined,
-									questionText: questionDetails?.text,
-									questionCount: questionDetails?.count,
-									resolvable: false,
-								}
-							: synthesizeUnresolvableAsk(toolName, planFilePath);
-					this.updateSessionStatus(event.sessionId, 'permission_requested', {
-						...eventContext,
-						statusDetail: toolName,
-						pendingPermission: synthesized,
-					});
-				}
-				break;
-			}
-
-			case 'PermissionDenied': {
-				this.clearStalePermission(
-					event.sessionId,
-					'PermissionDenied',
-					this.settledByFromEvent(event, capabilities),
-				);
-				const bk = this.getBookkeeping(event.sessionId);
-				bk.activeToolCount = Math.max(0, bk.activeToolCount - 1);
-				const filesChanged = this.untrackToolUseFile(event.sessionId, event, capabilities);
-				const readsChanged = this.untrackToolUseRead(event.sessionId, event, capabilities);
-				// When a parallel tool is still active the next status equals the current one and
-				// updateSessionStatus short-circuits — without an explicit fire, the dropped path
-				// would never reach subscribers (treemap activity overlay, WIP decoration).
-				const nextStatus = bk.activeToolCount > 0 ? 'tool_use' : 'thinking';
-				const sessionIndex = this._sessions.findIndex(s => s.id === event.sessionId);
-				const prevStatus = sessionIndex >= 0 ? this._sessions[sessionIndex].status : undefined;
-				const statusWillFire = prevStatus !== nextStatus;
-				this.updateSessionStatus(event.sessionId, nextStatus, eventContext);
-				if ((filesChanged || readsChanged) && !statusWillFire) {
-					this._onDidChangeSessions.fire();
-				}
-				break;
-			}
-
-			case 'Elicitation': {
-				const bk = this.getBookkeeping(event.sessionId);
-				bk.pendingPermission = {
-					kind: 'elicitation',
-					toolName: toolName ?? 'Input Required',
-					toolDescription: toolName ?? 'Waiting for input',
-					// `Elicitation` arrives on a non-blocking hook, so no entry exists for
-					// `resolvePermission` to answer — the user responds in the agent's own session.
-					resolvable: false,
-				};
-				this.updateSessionStatus(event.sessionId, 'permission_requested', {
-					...eventContext,
-					statusDetail: toolName,
-				});
-				break;
-			}
-
-			case 'ElicitationResult': {
-				const bk = this.getBookkeeping(event.sessionId);
-				bk.pendingPermission = undefined;
-				this.updateSessionStatus(
-					event.sessionId,
-					bk.activeToolCount > 0 ? 'tool_use' : 'thinking',
-					eventContext,
-				);
-				break;
-			}
-
-			case 'CwdChanged':
-				if (event.cwd) {
-					// Route through `ensureSession`: it owns the whole location transition — timeline
-					// seat (or handing attribution back to the probe when the CLI didn't explain the
-					// move), workspacePath/isInWorkspace recompute, the unresolvable-flag clear, and
-					// the probe gating. Writing `cwd` directly here left `cliSeatedWorktree` set, so
-					// the probe's answer for the new cwd could never replace the stale seated one.
-					const { changed } = this.ensureSession(event.sessionId, eventContext);
-					if (changed) {
-						this._onDidChangeSessions.fire();
-					}
-				}
-				break;
-
-			case 'SubagentStart': {
-				const { index: parentIdx } = this.ensureSession(event.sessionId, eventContext);
-				const parent = this._sessions[parentIdx];
-				if (event.agentId) {
-					const now = new Date();
-					const subagent: AgentSession = {
-						id: event.agentId,
-						providerId: capabilities.providerId,
-						providerName: capabilities.displayName,
-						name: event.agentType ?? 'Subagent',
-						status: 'thinking',
-						phase: 'working',
-						phaseSince: now,
-						lastActivity: now,
-						isSubagent: true,
-						parentId: event.sessionId,
-						isInWorkspace: workspacePath != null,
-					};
-					const existingSubs = parent.subagents ? [...parent.subagents] : [];
-					existingSubs.push(subagent);
-					this._sessions[parentIdx] = { ...parent, subagents: existingSubs };
-					this._onDidChangeSessions.fire();
-				}
-				break;
-			}
-
-			case 'SubagentStop': {
-				const { index: parentIdx } = this.ensureSession(event.sessionId, eventContext);
-				const parentSession = this._sessions[parentIdx];
-				if (parentSession.subagents != null && event.agentId) {
-					const filtered = parentSession.subagents.filter(s => s.id !== event.agentId);
-					if (filtered.length !== parentSession.subagents.length) {
-						this._sessions[parentIdx] = {
-							...parentSession,
-							subagents: filtered.length > 0 ? filtered : undefined,
-						};
-						this._onDidChangeSessions.fire();
-					}
-				}
-				break;
-			}
-
-			case 'TeammateIdle':
-			case 'TaskCompleted':
-			case 'InstructionsLoaded':
-			case 'ConfigChange':
-			case 'WorktreeCreate':
-			case 'WorktreeRemove':
-				// Not yet handled — intentional no-op.
-				break;
-		}
-
-		return Promise.resolve();
-	}
-
-	private sessionTag(sessionId: string, name?: string): string {
-		return name != null
-			? `[session=${sessionId.substring(0, 8)}(${name})]`
-			: `[session=${sessionId.substring(0, 8)}]`;
-	}
-
-	/** The owning agent's descriptor for a tracked session, resolved from the session's own
-	 *  `providerId`. `undefined` when the session isn't tracked (pruned/archived since) or carries a
-	 *  `providerId` the descriptor table doesn't know — callers pick their own fallback rather than
-	 *  silently assuming Claude Code. */
-	private getSessionCapabilities(sessionId: string): AgentCapabilities | undefined {
-		const session = this._sessions.find(s => s.id === sessionId);
-		return session != null ? getAgentCapabilitiesByProviderId(session.providerId) : undefined;
-	}
-
-	/** Whether the session's agent leaves a transcript on disk for {@link ClaudeCodeTranscriptReader}
-	 *  to tail. Fails OPEN when no descriptor resolves, so an unknown/absent `providerId` can never
-	 *  suppress the Claude path this reader exists for. */
-	private supportsTranscripts(sessionId: string): boolean {
-		return this.getSessionCapabilities(sessionId)?.supportsTranscripts ?? true;
-	}
-
-	private getBookkeeping(sessionId: string): SessionBookkeeping {
-		let bk = this._sessionBookkeeping.get(sessionId);
-		if (bk == null) {
-			bk = {
-				activeToolCount: 0,
-				currentFileCounts: new Map(),
-				pendingFileClears: new Map(),
-				currentReadCounts: new Map(),
-				pendingReadClears: new Map(),
-				lastTouchedAt: new Map(),
-				gitInfoUnresolvable: false,
-			};
-			this._sessionBookkeeping.set(sessionId, bk);
-		}
-		return bk;
-	}
-
-	/** Returns the active decay window in milliseconds — the cooldown between PostToolUse and
-	 *  dropping the path from the bookkeeping. Reads through the host callback every time so a
-	 *  setting change takes effect on the next Pre/Post pair without re-wiring (existing timers
-	 *  keep their original timeout — acceptable since they're short-lived relative to the setting). */
-	private get activityDecayMs(): number {
-		return this.callbacks.getActivityDecayMs?.() ?? defaultActivityDecayMs;
-	}
-
-	/** Locates the *parent* session id that owns the given session id — returns the id itself when
-	 *  it matches a top-level session, otherwise the `id` of the parent that holds it under
-	 *  `subagents[]`. Returns `undefined` when neither match (session no longer exists). Used to
-	 *  route per-session bookkeeping changes to the right top-level `syncSessionFileActivity` call.
-	 *  Tool events are parent-keyed (the CLI sends a sub-agent's tool events under the parent id),
-	 *  so the `subagents[]` branch is a defensive fallback for any other-keyed caller. */
-	private findOwningParentId(sessionId: string): string | undefined {
-		for (const s of this._sessions) {
-			if (s.id === sessionId) return s.id;
-
-			if (s.subagents != null) {
-				for (const sub of s.subagents) {
-					if (sub.id === sessionId) return s.id;
-				}
-			}
-		}
-		return undefined;
-	}
-
-	private resetBookkeeping(sessionId: string): void {
-		const bk = this.getBookkeeping(sessionId);
-		bk.activeToolCount = 0;
-		bk.pendingPermission = undefined;
-		this.cancelPendingFileClears(bk);
-		bk.currentFileCounts.clear();
-		this.cancelPendingReadClears(bk);
-		bk.currentReadCounts.clear();
-		bk.lastTouchedAt.clear();
-		bk.gitInfoUnresolvable = false;
-		// `cliSeatedWorktree` deliberately survives: SessionStart seats the worktree via
-		// `ensureSession` BEFORE resetting bookkeeping, and an unexplained cwd move clears it anyway.
-		const parentId = this.findOwningParentId(sessionId);
-		if (parentId != null) {
-			this.syncSessionFileActivity(parentId);
-		}
-	}
-
-	/** Turn-end settle (Stop): the agent finished its turn, so nothing is "live" anymore — but
-	 *  the per-operation decay tail must survive. Heat fades over {@link activityDecayMs} measured
-	 *  from when each *tool* finished (the PostToolUse cooldown), NOT from when the turn ends, so a
-	 *  Stop must not cancel those cooldowns or clear `lastTouchedAt`. We only reset turn-scoped
-	 *  state and force-finish any path whose PostToolUse never arrived before Stop: drop its
-	 *  refcount to 0 (flipping `editing`/`reading` off so the pulse stops) and schedule the same
-	 *  decay eviction a normal completion would. Contrast {@link resetBookkeeping}, which hard-
-	 *  wipes everything for SessionStart/SessionEnd (the agent is gone, not merely between turns). */
-	private settleBookkeeping(sessionId: string): void {
-		const bk = this.getBookkeeping(sessionId);
-		bk.activeToolCount = 0;
-		bk.pendingPermission = undefined;
-		// Allow git re-resolution next turn (matches the prior reset-on-Stop intent).
-		bk.gitInfoUnresolvable = false;
-		for (const [path, count] of bk.currentFileCounts) {
-			if (count > 0) {
-				bk.currentFileCounts.set(path, 0);
-				this.scheduleFileDecayEviction(bk, sessionId, path);
-			}
-		}
-		for (const [path, count] of bk.currentReadCounts) {
-			if (count > 0) {
-				bk.currentReadCounts.set(path, 0);
-				this.scheduleReadDecayEviction(bk, sessionId, path);
-			}
-		}
-		const parentId = this.findOwningParentId(sessionId);
-		if (parentId != null && this.syncSessionFileActivity(parentId)) {
-			this._onDidChangeSessions.fire();
-		}
-	}
-
-	private cancelPendingFileClears(bk: SessionBookkeeping): void {
-		for (const timer of bk.pendingFileClears.values()) {
-			clearTimeout(timer);
-		}
-		bk.pendingFileClears.clear();
-	}
-
-	private cancelPendingReadClears(bk: SessionBookkeeping): void {
-		for (const timer of bk.pendingReadClears.values()) {
-			clearTimeout(timer);
-		}
-		bk.pendingReadClears.clear();
-	}
-
-	/** Extracts the targeted file path from a PreToolUse/PostToolUse event. Tries the raw
-	 *  `hookInput.tool_input` passthrough first, falls back to the projected `event.toolInput`
-	 *  for older CLI versions that only fill the top-level fields. Treats an empty-object
-	 *  `hookInput.tool_input` as missing — `??` would have kept it (truthy) and shadowed a
-	 *  populated `event.toolInput`. */
-	private getEventFilePath(event: AgentSessionEvent, capabilities: AgentCapabilities): string | undefined {
-		const toolName = canonicalToolNameFromEvent(capabilities, event);
-		if (toolName == null) return undefined;
-
-		const rawHookInput = event.hookInput?.tool_input as Record<string, unknown> | undefined;
-		const hookInputPopulated = rawHookInput != null && Object.keys(rawHookInput).length > 0;
-		const toolInput = hookInputPopulated ? rawHookInput : event.toolInput;
-		return getToolFilePath(toolName, toolInput);
-	}
-
-	/** Stamps the per-path/per-kind `lastTouchedAt[kind]` to the current epoch ms. Stamped on every
-	 *  PreToolUse for the matching kind so `serializeFileActivity` can emit `readAt`/`editedAt` as
-	 *  a relative `now - timestamp` delta. */
-	private stampLastTouched(bk: SessionBookkeeping, filePath: string, kind: 'read' | 'edit'): void {
-		const existing = bk.lastTouchedAt.get(filePath);
-		const next: { edit?: number; read?: number } = existing != null ? { ...existing } : {};
-		next[kind] = Date.now();
-		bk.lastTouchedAt.set(filePath, next);
-	}
-
-	/** Drops the `lastTouchedAt[kind]` slot for `filePath`, and the whole entry when neither kind
-	 *  remains. Mirrors the cooldown-timer eviction in `scheduleClear*` — once the path is gone
-	 *  from the count map for that kind, its timestamp is no longer load-bearing. */
-	private clearLastTouched(bk: SessionBookkeeping, filePath: string, kind: 'read' | 'edit'): void {
-		const existing = bk.lastTouchedAt.get(filePath);
-		if (existing == null) return;
-		if (existing[kind] == null) return;
-
-		const next: { edit?: number; read?: number } = { ...existing, [kind]: undefined };
-		if (next.edit == null && next.read == null) {
-			bk.lastTouchedAt.delete(filePath);
-		} else {
-			bk.lastTouchedAt.set(filePath, next);
-		}
-	}
-
-	/** Records that a file-mutating tool call is in flight against `filePath` so consumers can
-	 *  highlight the path. Refcounts per path — keyed by path (not `tool_use_id`, which the GK CLI
-	 *  doesn't reliably surface) so parallel calls bump the count and Post/Pre order doesn't matter.
-	 *  Returns whether the parent's published `fileActivity` actually changed so callers can fire
-	 *  when the surrounding {@link updateSessionStatus} short-circuits. */
-	private trackToolUseFile(sessionId: string, event: AgentSessionEvent, capabilities: AgentCapabilities): boolean {
-		const filePath = this.getEventFilePath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		// A fresh Pre during a pending Post-cooldown means the file is live again — cancel the
-		// scheduled clear so the deferred drop doesn't run after the new tool already finished.
-		const pendingClear = bk.pendingFileClears.get(filePath);
-		if (pendingClear != null) {
-			clearTimeout(pendingClear);
-			bk.pendingFileClears.delete(filePath);
-		}
-		bk.currentFileCounts.set(filePath, (bk.currentFileCounts.get(filePath) ?? 0) + 1);
-		this.stampLastTouched(bk, filePath, 'edit');
-		return this.syncSessionFileActivityForChild(sessionId);
-	}
-
-	/** Decrements the in-flight refcount for a finished tool call's file. While the count stays
-	 *  above zero (overlapping parallel calls) the path remains marked. When the count drops to
-	 *  zero, leaves the entry in place at count `0` and schedules a {@link activityDecayMs}
-	 *  cooldown before actually dropping it — so a recently-edited file lingers as a decay tail
-	 *  on the treemap. A Pre arriving during cooldown cancels the timer and bumps the count back
-	 *  above zero. Returns whether the parent's published `fileActivity` changed (i.e. `editing`
-	 *  flipped off) so the PostToolUse caller can fire when its `updateSessionStatus` short-
-	 *  circuits (a parallel tool still in flight keeps activeToolCount > 0). */
-	private scheduleClearToolUseFile(
-		sessionId: string,
-		event: AgentSessionEvent,
-		capabilities: AgentCapabilities,
-	): boolean {
-		const filePath = this.getEventFilePath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		const count = bk.currentFileCounts.get(filePath);
-		// A duplicate / out-of-order Post during cooldown (count is already 0) would drive the
-		// refcount negative and schedule a second timer — ignore those so the cooldown stays
-		// authoritative until either its timer fires or a fresh Pre bumps the count back up.
-		if (count == null || count <= 0) return false;
-
-		const next = count - 1;
-		bk.currentFileCounts.set(filePath, next);
-		// Re-sync so `editing` drops from `true` to `undefined` the moment refcount hits zero —
-		// the cooldown only governs when the path itself leaves the snapshot, not when the
-		// "live" boolean flips off.
-		const changed = this.syncSessionFileActivityForChild(sessionId);
-		if (next > 0) return changed;
-
-		// Refcount just hit zero — keep the path in `currentFileCounts` for the cooldown window,
-		// then drop it.
-		this.scheduleFileDecayEviction(bk, sessionId, filePath);
-		return changed;
-	}
-
-	/** Schedules (replacing any prior timer) the {@link activityDecayMs} cooldown that finally
-	 *  drops `filePath` from the edit bookkeeping once it has fully decayed. Shared by the
-	 *  PostToolUse cooldown path and the Stop settle ({@link settleBookkeeping}); the path stays
-	 *  in `currentFileCounts` at count 0 meanwhile so its `editedAt` keeps aging on the client. */
-	private scheduleFileDecayEviction(bk: SessionBookkeeping, sessionId: string, filePath: string): void {
-		const existing = bk.pendingFileClears.get(filePath);
-		if (existing != null) {
-			clearTimeout(existing);
-		}
-
-		const timer = setTimeout(() => {
-			if (this._disposed) return;
-
-			const cur = this._sessionBookkeeping.get(sessionId);
-			if (cur == null) return;
-
-			cur.pendingFileClears.delete(filePath);
-			// Re-check: a Pre during cooldown bumped the count and cancelled this timer, but a
-			// concurrent reset could have cleared everything — bail in either case.
-			if ((cur.currentFileCounts.get(filePath) ?? 0) > 0) return;
-
-			cur.currentFileCounts.delete(filePath);
-			this.clearLastTouched(cur, filePath, 'edit');
-			if (this.syncSessionFileActivityForChild(sessionId)) {
-				this._onDidChangeSessions.fire();
-			}
-		}, this.activityDecayMs);
-		bk.pendingFileClears.set(filePath, timer);
-	}
-
-	/** Drops a tracked tool call's file immediately (no cooldown). Used for PermissionDenied,
-	 *  where the tool never ran — keeping the "live" badge would be misleading.
-	 *  Returns whether the published list changed. */
-	private untrackToolUseFile(sessionId: string, event: AgentSessionEvent, capabilities: AgentCapabilities): boolean {
-		const filePath = this.getEventFilePath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		const count = bk.currentFileCounts.get(filePath);
-		if (count == null) return false;
-		if (count > 1) {
-			bk.currentFileCounts.set(filePath, count - 1);
-			return this.syncSessionFileActivityForChild(sessionId);
-		}
-
-		const pending = bk.pendingFileClears.get(filePath);
-		if (pending != null) {
-			clearTimeout(pending);
-			bk.pendingFileClears.delete(filePath);
-		}
-		bk.currentFileCounts.delete(filePath);
-		this.clearLastTouched(bk, filePath, 'edit');
-		return this.syncSessionFileActivityForChild(sessionId);
-	}
-
-	/** Mirror of {@link getEventFilePath} for read-only file tools. */
-	private getEventReadPath(event: AgentSessionEvent, capabilities: AgentCapabilities): string | undefined {
-		const toolName = canonicalToolNameFromEvent(capabilities, event);
-		if (toolName == null) return undefined;
-
-		const rawHookInput = event.hookInput?.tool_input as Record<string, unknown> | undefined;
-		const hookInputPopulated = rawHookInput != null && Object.keys(rawHookInput).length > 0;
-		const toolInput = hookInputPopulated ? rawHookInput : event.toolInput;
-		return getToolReadPath(toolName, toolInput);
-	}
-
-	/** Refcount mirror of {@link trackToolUseFile} for read-only file tools. */
-	private trackToolUseRead(sessionId: string, event: AgentSessionEvent, capabilities: AgentCapabilities): boolean {
-		const filePath = this.getEventReadPath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		const pendingClear = bk.pendingReadClears.get(filePath);
-		if (pendingClear != null) {
-			clearTimeout(pendingClear);
-			bk.pendingReadClears.delete(filePath);
-		}
-		bk.currentReadCounts.set(filePath, (bk.currentReadCounts.get(filePath) ?? 0) + 1);
-		this.stampLastTouched(bk, filePath, 'read');
-		return this.syncSessionFileActivityForChild(sessionId);
-	}
-
-	/** Cooldown mirror of {@link scheduleClearToolUseFile} for read-only file tools. Returns
-	 *  whether the parent's published `fileActivity` changed (i.e. `reading` flipped off). */
-	private scheduleClearToolUseRead(
-		sessionId: string,
-		event: AgentSessionEvent,
-		capabilities: AgentCapabilities,
-	): boolean {
-		const filePath = this.getEventReadPath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		const count = bk.currentReadCounts.get(filePath);
-		// Same guard as scheduleClearToolUseFile — duplicate / out-of-order Posts during cooldown
-		// would otherwise drive the refcount negative and stack up redundant clear timers.
-		if (count == null || count <= 0) return false;
-
-		const next = count - 1;
-		bk.currentReadCounts.set(filePath, next);
-		// Re-sync so `reading` drops to `undefined` the moment refcount hits zero.
-		const changed = this.syncSessionFileActivityForChild(sessionId);
-		if (next > 0) return changed;
-
-		this.scheduleReadDecayEviction(bk, sessionId, filePath);
-		return changed;
-	}
-
-	/** Read-class mirror of {@link scheduleFileDecayEviction}. */
-	private scheduleReadDecayEviction(bk: SessionBookkeeping, sessionId: string, filePath: string): void {
-		const existing = bk.pendingReadClears.get(filePath);
-		if (existing != null) {
-			clearTimeout(existing);
-		}
-
-		const timer = setTimeout(() => {
-			if (this._disposed) return;
-
-			const cur = this._sessionBookkeeping.get(sessionId);
-			if (cur == null) return;
-
-			cur.pendingReadClears.delete(filePath);
-			if ((cur.currentReadCounts.get(filePath) ?? 0) > 0) return;
-
-			cur.currentReadCounts.delete(filePath);
-			this.clearLastTouched(cur, filePath, 'read');
-			if (this.syncSessionFileActivityForChild(sessionId)) {
-				this._onDidChangeSessions.fire();
-			}
-		}, this.activityDecayMs);
-		bk.pendingReadClears.set(filePath, timer);
-	}
-
-	/** Immediate-drop mirror of {@link untrackToolUseFile} for read-only file tools. */
-	private untrackToolUseRead(sessionId: string, event: AgentSessionEvent, capabilities: AgentCapabilities): boolean {
-		const filePath = this.getEventReadPath(event, capabilities);
-		if (filePath == null) return false;
-
-		const bk = this.getBookkeeping(sessionId);
-		const count = bk.currentReadCounts.get(filePath);
-		if (count == null) return false;
-		if (count > 1) {
-			bk.currentReadCounts.set(filePath, count - 1);
-			return this.syncSessionFileActivityForChild(sessionId);
-		}
-
-		const pending = bk.pendingReadClears.get(filePath);
-		if (pending != null) {
-			clearTimeout(pending);
-			bk.pendingReadClears.delete(filePath);
-		}
-		bk.currentReadCounts.delete(filePath);
-		this.clearLastTouched(bk, filePath, 'read');
-		return this.syncSessionFileActivityForChild(sessionId);
-	}
-
-	/** Convenience wrapper that resolves the parent for a possibly-sub-agent session id, then calls
-	 *  {@link syncSessionFileActivity}. Tool-call handlers call this without knowing whether the
-	 *  session is a top-level or sub-agent session. Returns `false` when the session isn't found
-	 *  (already pruned / unknown peer id). */
-	private syncSessionFileActivityForChild(sessionId: string): boolean {
-		const parentId = this.findOwningParentId(sessionId);
-		if (parentId == null) return false;
-		return this.syncSessionFileActivity(parentId);
-	}
-
-	/** Rebuilds the parent session's `fileActivity` array from its bookkeeping and writes it onto
-	 *  the session in place. Returns whether the *structural* shape changed (paths/kinds/flags) —
-	 *  timestamps are always refreshed regardless, but a fire is gated on structural change so
-	 *  non-meaningful drift doesn't churn the wire.
-	 *
-	 *  No separate sub-agent rollup is needed: the GK CLI keys a sub-agent's tool events under its
-	 *  PARENT session id (with `agentId` set), so they accumulate in the parent's own bookkeeping
-	 *  directly and are already reflected here. Sub-agent serialized objects carry no `fileActivity`. */
-	private syncSessionFileActivity(parentSessionId: string): boolean {
-		const index = this._sessions.findIndex(s => s.id === parentSessionId);
-		if (index < 0) return false;
-
-		const parent = this._sessions[index];
-		if (parent.status === 'ended') return false;
-
-		const parentBk = this._sessionBookkeeping.get(parentSessionId);
-
-		type Contrib = { editCount: number; readCount: number; editAt?: number; readAt?: number };
-		const merged = new Map<string, Contrib>();
-
-		const contributeFrom = (bk: SessionBookkeeping | undefined): void => {
-			if (bk == null) return;
-
-			for (const [path, count] of bk.currentFileCounts) {
-				let entry = merged.get(path);
-				if (entry == null) {
-					entry = { editCount: 0, readCount: 0 };
-					merged.set(path, entry);
-				}
-				entry.editCount += count;
-				const ts = bk.lastTouchedAt.get(path)?.edit;
-				if (ts != null && (entry.editAt == null || ts > entry.editAt)) {
-					entry.editAt = ts;
-				}
-			}
-			for (const [path, count] of bk.currentReadCounts) {
-				let entry = merged.get(path);
-				if (entry == null) {
-					entry = { editCount: 0, readCount: 0 };
-					merged.set(path, entry);
-				}
-				entry.readCount += count;
-				const ts = bk.lastTouchedAt.get(path)?.read;
-				if (ts != null && (entry.readAt == null || ts > entry.readAt)) {
-					entry.readAt = ts;
-				}
-			}
-		};
-
-		contributeFrom(parentBk);
-
-		const now = Date.now();
-		let next: FileActivityEntry[] | undefined;
-		if (merged.size > 0) {
-			next = [];
-			for (const [path, contrib] of merged) {
-				const entry: FileActivityEntry = { path: path };
-				if (contrib.editAt != null) {
-					entry.editedAt = Math.max(0, now - contrib.editAt);
-				}
-				if (contrib.readAt != null) {
-					entry.readAt = Math.max(0, now - contrib.readAt);
-				}
-				if (contrib.editCount > 0) {
-					entry.editing = true;
-				}
-				if (contrib.readCount > 0) {
-					entry.reading = true;
-				}
-				next.push(entry);
-			}
-		}
-
-		const changed = !fileActivityStructurallyEqual(parent.fileActivity, next);
-		// Always replace so timestamps reflect the latest serialization, even when the structural
-		// shape is unchanged (so a downstream fire from anywhere else carries fresh `sinceMs`).
-		this._sessions[index] = { ...parent, fileActivity: next };
-		return changed;
-	}
-
-	/** Defer the `Stop → idle` commit. If the agent produces a non-idle event within
-	 *  `stopToIdleDebounceMs`, `cancelPendingIdleTransition` (called from `updateSessionStatus`)
-	 *  cancels this and the session stays in its prior phase — no working → idle → working flicker.
-	 *
-	 *  Intentionally takes no context: the caller is expected to apply any event metadata
-	 *  synchronously before scheduling. Carrying Stop-time context into the timer would let
-	 *  in-window metadata mutations (e.g. `CwdChanged` updating `_sessions[i].cwd` directly)
-	 *  get reverted when the deferred commit replays the stale context through `ensureSession`. */
-	private scheduleIdleTransition(sessionId: string): void {
-		this.cancelPendingIdleTransition(sessionId);
-		const timer = setTimeout(() => {
-			this._pendingIdleTimers.delete(sessionId);
-			// Session may have been removed (SessionEnd, prune) during the window, or ended by a
-			// poll/SessionEnd that raced this timer — reviving a terminal row to idle would zombie it.
-			const idx = this._sessions.findIndex(s => s.id === sessionId);
-			if (idx < 0 || this._sessions[idx].status === 'ended') return;
-
-			this.updateSessionStatus(sessionId, 'idle');
-		}, stopToIdleDebounceMs);
-		this._pendingIdleTimers.set(sessionId, timer);
-	}
-
-	private cancelPendingIdleTransition(sessionId: string): void {
-		const timer = this._pendingIdleTimers.get(sessionId);
-		if (timer == null) return;
-
-		clearTimeout(timer);
-		this._pendingIdleTimers.delete(sessionId);
-	}
-
-	/** Stable phase-since: if we're oscillating back into the phase we were just in (within a
-	 *  short window), restore its original timestamp so the displayed elapsed time doesn't snap
-	 *  to 0. Otherwise records the current phase as the new "prior" and returns `now`. */
-	private resolvePhaseSince(
-		sessionId: string,
-		prevPhase: AgentSessionPhase,
-		prevPhaseSince: Date,
-		newPhase: AgentSessionPhase,
-	): Date {
-		if (prevPhase === newPhase) return prevPhaseSince;
-
-		const bk = this.getBookkeeping(sessionId);
-		const now = new Date();
-
-		if (bk.priorPhase?.phase === newPhase && now.getTime() - prevPhaseSince.getTime() < phaseSinceRestoreWindowMs) {
-			const restored = bk.priorPhase.phaseSince;
-			bk.priorPhase = { phase: prevPhase, phaseSince: prevPhaseSince };
-			return restored;
-		}
-
-		bk.priorPhase = { phase: prevPhase, phaseSince: prevPhaseSince };
-		return now;
-	}
-
-	/** Extracts the ask identity a settlement event refers to. `PostToolUse`/`PermissionDenied`
-	 *  carry `hookInput.tool_use_id` and `hookInput.tool_input` in production; the top-level
-	 *  `event.toolName`/`event.toolInput` are the older-CLI fallback. Input is canonicalized so key
-	 *  order (or arriving via the fallback field instead of `hookInput`) doesn't defeat comparison. */
-	private settledByFromEvent(
-		event: AgentSessionEvent,
-		capabilities: AgentCapabilities,
-	): {
-		toolUseId?: string;
-		toolName?: string;
-		toolInputJson?: string;
-	} {
-		const hookInput = event.hookInput;
-		const toolInput = (hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
-		return {
-			toolUseId: hookInput?.tool_use_id as string | undefined,
-			// Canonical, because the registered ask's `toolName` is canonical too — comparing a native
-			// name against it would look like an identity mismatch and strand the ask.
-			toolName: canonicalToolNameFromEvent(capabilities, event),
-			toolInputJson: toolInput != null ? stableStringify(toolInput) : undefined,
-		};
-	}
-
-	private resolveAllPending(entry: PendingPermissionEntry, response: PermissionResponse): void {
-		for (const resolver of entry.resolvers) {
-			resolver.resolve(response);
-		}
-	}
-
-	private rejectAllPending(entry: PendingPermissionEntry, reason: Error): void {
-		for (const resolver of entry.resolvers) {
-			resolver.reject(reason);
-		}
-	}
-
-	// Called when a pending permission was resolved outside GitLens (e.g. via the CLI terminal).
-	// The 'deny' response is a safe no-op since the tool has already run or been denied upstream.
-	// `settledBy` identifies the ask the settling event actually refers to — out-of-order/duplicate
-	// hook deliveries (PostToolUse for an unrelated tool, a PermissionDenied for an already-evicted
-	// earlier ask) must never deny a still-live blocking ask just because it shares a session id.
-	// `PermissionDenied` itself only ever fires after Claude Code's auto-mode classifier denies a
-	// tool call — never as an echo of a deny a `PermissionRequest` response sent.
-	private clearStalePermission(
-		sessionId: string,
-		reason: string,
-		settledBy?: { toolUseId?: string; toolName?: string; toolInputJson?: string },
-	): void {
-		const bk = this.getBookkeeping(sessionId);
-		const pending = this._pendingPermissions.get(sessionId);
-
-		if (pending != null) {
-			if (settledBy != null) {
-				let mismatch = false;
-
-				if (pending.toolUseId != null && settledBy.toolUseId != null) {
-					// Rule 1: both sides identified — the only trustworthy comparison. `PermissionDenied`/
-					// `PostToolUse` hookInput DOES carry `tool_use_id`, but `PermissionRequest` never does,
-					// so `pending` never actually has one — this branch only engages if a future CLI adds
-					// it to requests too. The asymmetry is deliberate, not a gap to close.
-					mismatch = pending.toolUseId !== settledBy.toolUseId;
-				} else if (pending.toolName === '') {
-					// Rule 2: no identity was captured at registration (degraded payload) — nothing to
-					// gate on, so clear unconditionally rather than stranding the ask forever.
-					mismatch = false;
-				} else {
-					// Rule 3: name must match; when both sides have input, it must match too. A
-					// PostToolUse for a different invocation of the same tool (different input) leaves
-					// the ask untouched.
-					mismatch =
-						settledBy.toolName !== pending.toolName ||
-						(pending.toolInputJson != null &&
-							settledBy.toolInputJson != null &&
-							pending.toolInputJson !== settledBy.toolInputJson);
-				}
-
-				if (mismatch) {
-					Logger.debug(
-						`GkAgentProvider.clearStalePermission: skip (identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${pending.toolUseId ?? pending.toolName} settledBy=${settledBy.toolUseId ?? settledBy.toolName ?? 'unknown'}`,
-					);
-					return;
-				}
-			}
-
-			Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
-			this.resolveAllPending(pending, {
-				hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny' } },
-			});
-			this._pendingPermissions.delete(sessionId);
-			bk.pendingPermission = undefined;
-			return;
-		}
-
-		if (bk.pendingPermission == null) return;
-
-		if (
-			settledBy?.toolName != null &&
-			bk.pendingPermission.toolName != null &&
-			settledBy.toolName !== bk.pendingPermission.toolName
-		) {
-			Logger.debug(
-				`GkAgentProvider.clearStalePermission: skip (display-only identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${bk.pendingPermission.toolName} settledBy=${settledBy.toolName}`,
-			);
-			return;
-		}
-
-		Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
-		bk.pendingPermission = undefined;
-	}
-
-	resolvePermission(
-		sessionId: string,
-		decision: PermissionDecision,
-		updatedPermissions?: PermissionSuggestion[],
-	): boolean {
-		// Explicit refusal rather than an incidental one: an agent we can't answer for never registers
-		// a pending entry, so the `pending == null` check below would already return `false` — but the
-		// caller deserves to know WHY, and the guard has to survive a future entry-registering path.
-		const capabilities = this.getSessionCapabilities(sessionId);
-		if (capabilities != null && !canAnswerBlockingPermission(capabilities)) {
-			Logger.debug(
-				`GkAgentProvider.resolvePermission: refusing ${decision} for ${this.sessionTag(sessionId)} — ${capabilities.displayName} asks are observe-only`,
-			);
-			return false;
-		}
-
-		const pending = this._pendingPermissions.get(sessionId);
-		if (pending == null) return false;
-
-		Logger.debug(
-			`GkAgentProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`,
-		);
-		this.resolveAllPending(pending, {
-			hookSpecificOutput: {
-				hookEventName: 'PermissionRequest',
-				decision: { behavior: decision, updatedPermissions: updatedPermissions },
-			},
-		});
-		this.callbacks.onPermissionResolved?.({
-			provider: capabilities?.providerId ?? claudeCodeCapabilities.providerId,
-			tool: pending.toolName,
-			decision: decision,
-		});
-		this._pendingPermissions.delete(sessionId);
-
-		const bk = this.getBookkeeping(sessionId);
-		bk.pendingPermission = undefined;
-
-		const nextStatus = bk.activeToolCount > 0 ? 'tool_use' : 'thinking';
-		this.updateSessionStatus(sessionId, nextStatus);
-		return true;
-	}
-
-	async archiveSession(sessionId: string): Promise<boolean> {
-		// Authoritative status guard: the CLI's `archive-session` ends an active session first, so a
-		// stale webview action (or a row that resumed out of `ended` since the click) must never
-		// reach the CLI — archiving is only ever valid on a terminal row. Callers gate the UI too,
-		// but this is the last line that owns live process safety. Returns `false` when refused so the
-		// host doesn't record a success telemetry event for an archive that never happened.
-		const session = this._sessions.find(s => s.id === sessionId);
-		if (session != null && session.status !== 'ended') {
-			Logger.warn(
-				`GkAgentProvider.archiveSession: refusing to archive non-ended ${this.sessionTag(sessionId)} (status=${session.status})`,
-			);
-			return false;
-		}
-
-		Logger.debug(`GkAgentProvider.archiveSession: ${this.sessionTag(sessionId)}`);
-		await this.callbacks.runCLICommand(['ai', 'hook', 'archive-session', sessionId, '--json']);
-		// Invalidate the archived-id cache so the next `getPastSessions` re-fetches and excludes this id.
-		this._archivedSessionIdsCache = undefined;
-		// Optimistically drop it — archived sessions are excluded from the `active,ended` poll, so the
-		// next reconciliation confirms the removal regardless.
-		const index = this._sessions.findIndex(s => s.id === sessionId);
-		if (index >= 0) {
-			this._sessions.splice(index, 1);
-			this._sessionBookkeeping.delete(sessionId);
-			this._transcriptReader.forget(sessionId);
-			this._onDidChangeSessions.fire();
-		}
-		return true;
-	}
-
-	/** Lists the ids of sessions the CLI has archived, so callers (the "Past" transcript listing) can
-	 *  exclude them — the tracked row is gone, but the transcript on disk survives and would otherwise
-	 *  resurface there. Resolves to `[]` on any error, including a CLI too old to support the
-	 *  `archived` status filter. */
-	async getArchivedSessionIds(): Promise<string[]> {
-		const cached = this._archivedSessionIdsCache;
-		if (cached != null && Date.now() - cached.at < archivedSessionIdsCacheTtlMs) {
-			return cached.promise;
-		}
-
-		const promise = this.fetchArchivedSessionIds();
-		this._archivedSessionIdsCache = { promise: promise, at: Date.now() };
-		return promise;
-	}
-
-	private async fetchArchivedSessionIds(): Promise<string[]> {
-		try {
-			const output = await this.callbacks.runCLICommand([
-				'ai',
-				'hook',
-				'list-sessions',
-				'--status',
-				'archived',
-				'--json',
-			]);
-			const sessions = JSON.parse(output) as SessionFileData[];
-			return sessions.map(s => s.sessionId).filter(id => id.length > 0);
-		} catch {
-			return [];
-		}
-	}
-
-	resolveEndedSessionDetails(sessionId: string): void {
-		const session = this._sessions.find(s => s.id === sessionId);
-		// Only ended sessions defer resolution; live sessions resolve eagerly on discovery.
-		if (session?.status !== 'ended') return;
-
-		// The durable store drops the prompt (and only ever carries an auto-slug name) for most ended
-		// sessions, so read the terminal transcript once on demand to recover a real title + the
-		// first/last prompt. Both the git probe and transcript read sit under the guard so repeated
-		// opens don't re-probe git or re-read a possibly-large file.
-		const bk = this.getBookkeeping(sessionId);
-		if (bk.endedDetailsResolved) return;
-
-		bk.endedDetailsResolved = true;
-
-		if (session.cwd) {
-			void this.resolveGitInfo(sessionId, session.cwd);
-		}
-		// Git identity resolves for every agent; the transcript read is Claude-only (see
-		// `resolveTranscriptTitles`).
-		if (this.supportsTranscripts(sessionId)) {
-			void this.applyEndedTranscriptDetails(sessionId, session.cwd);
-		}
-	}
-
-	/** No `_sessions` gate, unlike {@link resolveEndedSessionDetails} — must work for a
-	 *  transcript-only id this window never tracked live (past-session-sheet callers). */
-	async resolveSessionDetails(sessionId: string, cwd?: string): Promise<EndedTranscriptDetails | undefined> {
-		// The reader only reads Claude Code's store, so an agent that leaves no transcript can only
-		// ever miss here. Reachable rather than theoretical: an ended session of ANY agent becomes a
-		// Past row, and opening its sheet routes here by `providerId`. `supportsTranscripts` fails
-		// open, so the transcript-only ids this method exists for — untracked, therefore capability-
-		// less, and Claude's by construction since only its store produces them — still resolve.
-		if (!this.supportsTranscripts(sessionId)) return undefined;
-
-		let cached = this._sessionDetailsCache.get(sessionId);
-		if (cached == null) {
-			cached = this._transcriptReader.resolveEndedDetails(sessionId, cwd).catch((ex: unknown) => {
-				// A read error (transient I/O, permissions) is not terminal state — drop the cache
-				// entry so a later call retries. A resolved `undefined` IS terminal (no transcript on
-				// disk) and stays cached.
-				this._sessionDetailsCache.delete(sessionId);
-				throw ex;
-			});
-			this._sessionDetailsCache.set(sessionId, cached);
-		}
-
-		try {
-			return await cached;
-		} catch {
-			return undefined;
-		}
-	}
-
-	private async applyEndedTranscriptDetails(sessionId: string, cwd: string | undefined): Promise<void> {
-		let details;
-		try {
-			details = await this._transcriptReader.resolveEndedDetails(sessionId, cwd);
-		} catch {
-			// A read error (transient I/O, permissions) is not terminal state — clear the once-only
-			// guard so a later open retries. A `undefined` result IS terminal (no transcript on disk),
-			// so it keeps the guard and never re-scans.
-			const bk = this._sessionBookkeeping.get(sessionId);
-			if (bk != null) {
-				bk.endedDetailsResolved = false;
-			}
-			return;
-		}
-		if (details == null) return;
-
-		const index = this._sessions.findIndex(s => s.id === sessionId);
-		if (index < 0) return;
-
-		const session = this._sessions[index];
-		// The session may have been archived/removed while we were reading.
-		if (session.status !== 'ended') return;
-
-		const { titles } = details;
-		const nextTitles =
-			titles.custom != null || titles.ai != null || titles.agent != null
-				? { custom: titles.custom, ai: titles.ai, agent: titles.agent }
-				: session.transcriptTitles;
-		// Durable-store prompts (full text) win over the transcript's (CLI-truncated) copy; only
-		// backfill from the transcript when the field is empty.
-		const nextFirstPrompt = session.firstPrompt ?? prepareStoredPrompt(details.firstPrompt);
-		const nextLastPrompt = session.lastPrompt ?? prepareStoredPrompt(details.lastPrompt);
-
-		const titlesChanged =
-			nextTitles?.custom !== session.transcriptTitles?.custom ||
-			nextTitles?.ai !== session.transcriptTitles?.ai ||
-			nextTitles?.agent !== session.transcriptTitles?.agent;
-		if (!titlesChanged && nextFirstPrompt === session.firstPrompt && nextLastPrompt === session.lastPrompt) {
-			return;
-		}
-
-		this._sessions[index] = {
-			...session,
-			transcriptTitles: nextTitles,
-			firstPrompt: nextFirstPrompt,
-			lastPrompt: nextLastPrompt,
-		};
-		this._onDidChangeSessions.fire();
-	}
-
-	private matchesWorkspace(workspacePath: string | undefined): boolean {
-		if (!workspacePath) return false;
-
-		// `_workspacePaths` is normalized; normalize the input so prefix comparisons work
-		// regardless of whether the caller passed a raw `fsPath` (CLI hook cwd, peer-session
-		// workspacePath) or an already-normalized path.
-		const normalized = normalizePath(workspacePath);
-		return this._workspacePaths.some(
-			p => normalized === p || normalized.startsWith(`${p}/`) || p.startsWith(`${normalized}/`),
-		);
-	}
-
-	private resolveWorkspacePath(cwd: string | undefined): string | undefined {
-		if (!cwd) return undefined;
-
-		const normalized = normalizePath(cwd);
-		return this._workspacePaths.find(
-			p => normalized === p || normalized.startsWith(`${p}/`) || p.startsWith(`${normalized}/`),
-		);
-	}
-
-	private updateSessionWithPermission(
-		sessionId: string,
-		permission: PendingPermission,
-		context?: SessionContext,
-	): void {
-		// A pending permission is a working/waiting transition — cancel any deferred Stop → idle
-		// commit so the session doesn't briefly flip to idle before showing the prompt.
-		this.cancelPendingIdleTransition(sessionId);
-
-		// The full event context, not just the pid: a blocking ask can be the first event of a
-		// session, and a row created here with no location would sit unattributed for the whole block.
-		const { index } = this.ensureSession(sessionId, context);
-
-		const prev = this._sessions[index];
-		const newPhase = getPhaseForStatus('permission_requested');
-		this.getBookkeeping(sessionId).pendingPermission = permission;
-		this._sessions[index] = {
-			...prev,
-			status: 'permission_requested',
-			phase: newPhase,
-			phaseSince: this.resolvePhaseSince(sessionId, prev.phase, prev.phaseSince, newPhase),
-			statusDetail: permission.toolDescription,
-			pendingPermission: permission,
-			lastActivity: new Date(),
-		};
-		this._onDidChangeSessions.fire();
-	}
-
-	private updateSessionStatus(
-		sessionId: string,
-		status: AgentSessionStatus,
-		options?: SessionContext & { statusDetail?: string; pendingPermission?: PendingPermission },
-	): void {
-		// Any non-idle status update implicitly cancels a deferred Stop → idle commit. The
-		// timer is owned here so the schedule/cancel pair is uniformly enforced regardless of
-		// which event path produced the next status.
-		if (status !== 'idle') {
-			this.cancelPendingIdleTransition(sessionId);
-		}
-
-		const { index, changed: metadataChanged } = this.ensureSession(sessionId, options);
-
-		const prev = this._sessions[index];
-		const bk = this.getBookkeeping(sessionId);
-
-		// If a permission/elicitation is pending, preserve permission_requested state.
-		// Tool counts and other bookkeeping are still updated by callers before this
-		// method, but the visible status remains locked until the wait is explicitly
-		// resolved.
-		if (bk.pendingPermission != null && status !== 'permission_requested') {
-			this._sessions[index] = { ...prev, lastActivity: new Date() };
-			if (metadataChanged) {
-				this._onDidChangeSessions.fire();
-			}
-			return;
-		}
-
-		const statusDetail = options?.statusDetail;
-		// Resolved before the short-circuit: a second ask can arrive while the row already sits at
-		// `permission_requested`, and comparing only status+detail would publish the first ask forever.
-		const nextPendingPermission =
-			status === 'permission_requested' ? (bk.pendingPermission ?? options?.pendingPermission) : undefined;
-		if (
-			prev.status === status &&
-			prev.statusDetail === statusDetail &&
-			isSameAsk(prev.pendingPermission, nextPendingPermission)
-		) {
-			if (metadataChanged) {
-				this._onDidChangeSessions.fire();
-			}
-			return;
-		}
-
-		const newPhase = getPhaseForStatus(status);
-		this._sessions[index] = {
-			...prev,
-			status: status,
-			phase: newPhase,
-			phaseSince: this.resolvePhaseSince(sessionId, prev.phase, prev.phaseSince, newPhase),
-			statusDetail: statusDetail,
-			pendingPermission: nextPendingPermission,
-			lastActivity: new Date(),
-		};
-		this._onDidChangeSessions.fire();
-
-		if (status === 'thinking' || status === 'tool_use' || status === 'compacting') {
-			const sessionCwd = this._sessions[index].cwd;
-			if (sessionCwd != null) {
-				this.callbacks.onBranchAgentActivity?.(sessionCwd);
-			}
-		}
-
-		// On a fresh transition into idle, recheck transcript titles — Claude typically (re-)writes
-		// `ai-title` right after finishing a response, so this is the prime moment to pick it up.
-		// Tail-read caching makes repeated checks cheap.
-		if (status === 'idle' && prev.status !== 'idle') {
-			void this.resolveTranscriptTitles(sessionId, this._sessions[index].cwd);
-		}
-	}
-
-	private ensureSession(sessionId: string, context?: SessionContext): { index: number; changed: boolean } {
-		const {
-			capabilities,
-			pid,
-			workspacePath,
-			isInWorkspace,
-			cwd,
-			initialCwd,
-			planFile,
-			sessionName,
-			model,
-			worktreePath,
-			visitedWorktreePaths,
-		} = context ?? {};
-
-		let index = this._sessions.findIndex(s => s.id === sessionId);
-		if (index < 0) {
-			const now = new Date();
-			// Same worktree-derived fallback as the update branch below: a session created with a
-			// scratch cwd but a CLI-seated worktree still belongs to that worktree's workspace.
-			const createdWorkspacePath = workspacePath ?? this.resolveWorkspacePath(worktreePath);
-			// Identity comes from the owning agent's descriptor, never from the provider — Claude's
-			// `providerId` stays the `claudeCode` the descriptor encodes. The fallback covers the
-			// deferred-commit paths (see `SessionContext.capabilities`), which only ever run against a
-			// row that already exists; reaching it would mean a row created outside every event path.
-			const identity = capabilities ?? claudeCodeCapabilities;
-			index = this._sessions.length;
-			this._sessions.push({
-				id: sessionId,
-				providerId: identity.providerId,
-				providerName: identity.displayName,
-				name: sessionName || undefined,
-				status: 'idle',
-				phase: getPhaseForStatus('idle'),
-				phaseSince: now,
-				pid: pid,
-				lastActivity: now,
-				isSubagent: false,
-				workspacePath: createdWorkspacePath,
-				cwd: cwd,
-				initialCwd: initialCwd ?? cwd,
-				planFile: planFile,
-				isInWorkspace: createdWorkspacePath != null ? true : (isInWorkspace ?? false),
-				model: model,
-				worktreePath: worktreePath != null ? normalizePath(worktreePath) : undefined,
-				visitedWorktreePaths: unionVisited(undefined, visitedWorktreePaths, worktreePath),
-			});
-			Logger.debug(
-				`GkAgentProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`,
-			);
-			if (worktreePath != null) {
-				this.getBookkeeping(sessionId).cliSeatedWorktree = true;
-			}
-			this._onDidChangeSessions.fire();
-
-			if (cwd != null) {
-				void this.resolveGitInfo(sessionId, cwd);
-			}
-			void this.resolveTranscriptTitles(sessionId, cwd);
-			return { index: index, changed: true };
-		}
-
-		const existing = this._sessions[index];
-		const updatedPid = pid != null && existing.pid == null ? pid : existing.pid;
-		const updatedPlanFile = planFile ?? existing.planFile;
-		const updatedName = sessionName || existing.name;
-		const updatedModel = model || existing.model;
-		const updatedCwd = cwd ?? existing.cwd;
-		// Prefer the CLI's authoritative `initialCwd` (the true launch dir it captured first-hand,
-		// even for sessions that started before this window opened); otherwise keep whatever we
-		// already captured, and only as a last resort backfill from the current cwd (older CLIs that
-		// don't send `initialCwd`, or a cold-create before any cwd was known). Comparing live `cwd`
-		// against `initialCwd` is how consumers detect launch-vs-current drift, so it stays stable.
-		const updatedInitialCwd = initialCwd ?? existing.initialCwd ?? cwd;
-		// The CLI resolves this at hook time and sends it on every event — authoritative when
-		// present, so it seats ahead of the `resolveGitInfo` probe below (which still fills
-		// `commonPath` and remains the fallback for older CLIs that don't send `cwdTimeline`).
-		const updatedWorktreePath = worktreePath != null ? normalizePath(worktreePath) : existing.worktreePath;
-		const updatedVisitedWorktreePaths = unionVisited(
-			existing.visitedWorktreePaths,
-			visitedWorktreePaths,
-			updatedWorktreePath,
-		);
-		// Workspace membership follows the ATTRIBUTION, not the raw cwd: a scratch-dir excursion
-		// (cwd in /tmp, worktree kept) stays in-workspace via its worktree, while a genuine move to
-		// a repo outside the workspace honestly drops membership when events carry a cwd.
-		const updatedWorkspacePath =
-			workspacePath ??
-			this.resolveWorkspacePath(updatedWorktreePath) ??
-			(cwd == null ? existing.workspacePath : undefined);
-		const updatedIsInWorkspace = cwd == null ? existing.isInWorkspace : updatedWorkspacePath != null;
-
-		const cwdMoved = cwd != null && updatedCwd !== existing.cwd;
-		const worktreeMoved =
-			updatedWorktreePath != null &&
-			existing.worktreePath != null &&
-			updatedWorktreePath !== existing.worktreePath;
-
-		// The CLI explaining the location owns attribution; a move it didn't explain hands it back to
-		// the probe.
-		if (worktreePath != null) {
-			this.getBookkeeping(sessionId).cliSeatedWorktree = true;
-		} else if (cwdMoved) {
-			this.getBookkeeping(sessionId).cliSeatedWorktree = false;
-		}
-
-		let changed = false;
-		if (
-			updatedPid !== existing.pid ||
-			updatedWorkspacePath !== existing.workspacePath ||
-			updatedIsInWorkspace !== existing.isInWorkspace ||
-			updatedPlanFile !== existing.planFile ||
-			updatedName !== existing.name ||
-			updatedModel !== existing.model ||
-			updatedCwd !== existing.cwd ||
-			updatedInitialCwd !== existing.initialCwd ||
-			updatedWorktreePath !== existing.worktreePath ||
-			updatedVisitedWorktreePaths !== existing.visitedWorktreePaths
-		) {
-			this._sessions[index] = {
-				...existing,
-				name: updatedName,
-				model: updatedModel,
-				pid: updatedPid,
-				workspacePath: updatedWorkspacePath,
-				cwd: updatedCwd,
-				initialCwd: updatedInitialCwd,
-				planFile: updatedPlanFile,
-				isInWorkspace: updatedIsInWorkspace,
-				worktreePath: updatedWorktreePath,
-				visitedWorktreePaths: updatedVisitedWorktreePaths,
-				// A worktree move can cross repos, and the spread would otherwise carry the old repo
-				// identity forward — which consumers prefer over the new worktree, pinning the card to
-				// the wrong repo. Drop it; the probe below refills it. Mirrors the poll's ended-record
-				// re-seat.
-				commonPath: worktreeMoved ? undefined : existing.commonPath,
-			};
-			changed = true;
-		}
-
-		// Re-fire `resolveGitInfo` if the session is missing either `worktreePath` or `commonPath`.
-		// Peer-synced sessions arrive with `worktreePath` already set (from the peer that owns the
-		// hook flow) but may lack `commonPath` if the peer was running pre-commonPath code; this
-		// gives us a chance to fill it in locally. Idempotent — `resolveGitInfo` only mutates the
-		// session when one of `cwd`/`worktreePath`/`commonPath` actually changes. The
-		// `gitInfoUnresolvable` bookkeeping flag (see `SessionBookkeeping`) is set once
-		// `resolveGitInfo` confirms the cwd isn't a git repo, preventing a retry storm on every
-		// hook event for non-git-repo cwds. The flag is cleared on cwd change (`CwdChanged`) and
-		// on `resetBookkeeping` (Stop/SessionStart) so re-resolution can happen when warranted.
-		// A cwd move re-resolves too. `worktreePath`/`commonPath` are resolved from whichever cwd was
-		// seen first, so an agent that moves between worktrees would otherwise stay pinned to its
-		// launch repo — attaching to the wrong WIP row and leaving its real worktree showing no
-		// agents at all. `CwdChanged` covers the move the CLI announces; this covers an ordinary
-		// event that simply arrives carrying a new cwd.
-		//
-		// A cwd the CLI already attributed to the same worktree needs no probe at all — that's the
-		// common case (an agent `cd`-ing around inside its own tree), and probing it would spawn a git
-		// call per hook event for an answer we already have. A first seat (no prior worktree) still
-		// counts as a location change: the move may be out of a non-git dir whose probe latched
-		// `gitInfoUnresolvable`, and `commonPath` still needs the probe.
-		//
-		// A worktree move is a location change on its own, even with the SAME cwd (cwdTimeline
-		// updated, cwd unchanged) — the `commonPath` drop above (`worktreeMoved ? undefined : …`)
-		// needs the probe to refill it, and without `worktreeMoved` here nothing else would fire it.
-		const locationNeedsProbe =
-			worktreeMoved || (cwdMoved && (worktreePath == null || existing.worktreePath == null));
-		if (locationNeedsProbe) {
-			this.getBookkeeping(sessionId).gitInfoUnresolvable = false;
-		}
-
-		if (
-			cwd != null &&
-			(locationNeedsProbe || existing.worktreePath == null || existing.commonPath == null) &&
-			!this.getBookkeeping(sessionId).gitInfoUnresolvable
-		) {
-			void this.resolveGitInfo(sessionId, cwd);
-		}
-
-		return { index: index, changed: changed };
-	}
-
-	private async resolveGitInfo(sessionId: string, cwd: string): Promise<void> {
-		const resolveGitInfo = this.callbacks.resolveGitInfo;
-		if (resolveGitInfo == null) return;
-
-		// Dedupe concurrent calls for the same session — every hook event (PreToolUse, PostToolUse,
-		// UserPromptSubmit, etc.) flows through `ensureSession`, which retries `resolveGitInfo`
-		// whenever `commonPath`/`worktreePath` is missing. Without this guard a non-git-repo cwd
-		// would spawn a fresh git probe per hook event. The `gitInfoUnresolvable` bookkeeping flag
-		// (set below when `info == null`) is the long-lived suppressor across hook events; this
-		// in-flight set only dedupes concurrent overlapping probes within a single resolution.
-		//
-		// Keyed by cwd as well: a probe for the SAME cwd is genuinely redundant, but one for a
-		// different cwd (a missed `CwdChanged` corrected off the durable record, say) must not be
-		// swallowed — the in-flight answer describes the old directory. Record it as pending so the
-		// running probe hands off to it, and discard the stale answer below.
-		const inFlightCwd = this._resolveGitInfoInFlight.get(sessionId);
-		if (inFlightCwd != null) {
-			if (inFlightCwd !== cwd) {
-				this._resolveGitInfoPending.set(sessionId, cwd);
-			}
-			return;
-		}
-
-		this._resolveGitInfoInFlight.set(sessionId, cwd);
-		try {
-			let info: Awaited<ReturnType<typeof resolveGitInfo>> | undefined;
-			let failed = false;
-			try {
-				info = await resolveGitInfo(cwd);
-			} catch {
-				// A transient git/spawn failure, distinct from a confirmed "not a repo" (`info ==
-				// null` below). Must not latch `gitInfoUnresolvable` — the next hook event retries
-				// via `ensureSession`'s `commonPath == null` check.
-				failed = true;
-				info = undefined;
-			}
-
-			const index = this._sessions.findIndex(s => s.id === sessionId);
-			if (index < 0) return;
-
-			// Superseded while we were probing: this answer describes a directory the session has
-			// already left, so applying it would undo the newer location. Drop it — the `finally`
-			// below re-runs for the newest cwd.
-			if (this._resolveGitInfoPending.has(sessionId)) return;
-
-			if (failed) return;
-
-			const session = this._sessions[index];
-
-			// `workspacePath` stays as the matched workspace folder (or undefined). Repo identity
-			// flows through `commonPath`, populated here from `info.repoRoot` at the same step as
-			// `worktreePath` — both available together from `resolveGitInfo`, much earlier than the
-			// follow-on worktree-name refresh (which needs `getWorktrees()` on the parent repo).
-			//
-			// When `info == null` (cwd is not inside any git repo), set the `gitInfoUnresolvable`
-			// bookkeeping flag so subsequent `ensureSession`/peer-sync retry checks skip re-firing.
-			// We deliberately do NOT write a tombstone onto the session DTO — keeping `commonPath`
-			// as `undefined` (a) keeps the wire-shape unambiguous for peers, (b) lets consumers
-			// safely treat undefined as "no repo identity", and (c) means peers can still attempt
-			// their own local resolution. The flag is cleared on cwd change (`CwdChanged`) and on
-			// `resetBookkeeping` so re-resolution happens when warranted (e.g. user runs `git init`
-			// followed by a new session start).
-			if (info == null) {
-				this.getBookkeeping(sessionId).gitInfoUnresolvable = true;
-
-				// The cwd itself isn't a repo, but a CLI-seated worktree (from `cwdTimeline`, see
-				// `worktreeFromEvent`) may still name one — e.g. a scratch cwd like `/tmp/x` whose
-				// session the CLI attributed to a real worktree. Probe the worktree root inline, in
-				// the same in-flight window, so a scratch cwd doesn't leave `commonPath` permanently
-				// unresolved.
-				let worktreeInfo: Awaited<ReturnType<typeof resolveGitInfo>> | undefined;
-				let liveIndex = index;
-				let liveSession = session;
-				if (session.worktreePath != null && session.worktreePath !== cwd && session.commonPath == null) {
-					try {
-						worktreeInfo = await resolveGitInfo(session.worktreePath);
-					} catch {
-						worktreeInfo = undefined;
-					}
-
-					// Re-find and re-read after this second await, for both the success and
-					// fall-through writes below — the array can have been reassigned/spliced (e.g.
-					// `pruneDeadSessions`), or the session's own fields updated, while the probe ran.
-					liveIndex = this._sessions.findIndex(s => s.id === sessionId);
-					if (liveIndex < 0) return;
-
-					if (this._resolveGitInfoPending.has(sessionId)) return;
-
-					liveSession = this._sessions[liveIndex];
-				}
-
-				if (worktreeInfo != null) {
-					const worktreeFirstResolve = liveSession.initialCommonPath == null;
-					this._sessions[liveIndex] = {
-						...liveSession,
-						cwd: cwd,
-						commonPath: worktreeInfo.repoRoot,
-						initialWorktreePath: worktreeFirstResolve
-							? liveSession.worktreePath
-							: liveSession.initialWorktreePath,
-						initialCommonPath: worktreeFirstResolve ? worktreeInfo.repoRoot : liveSession.initialCommonPath,
-						visitedWorktreePaths: unionVisited(liveSession.visitedWorktreePaths, liveSession.worktreePath),
-					};
-					this._onDidChangeSessions.fire();
-					return;
-				}
-
-				if (cwd !== liveSession.cwd) {
-					this._sessions[liveIndex] = { ...liveSession, cwd: cwd };
-					this._onDidChangeSessions.fire();
-				}
-				return;
-			}
-
-			// A CLI-seated worktree wins over the probe's answer (see `cliSeatedWorktree`): the CLI
-			// resolved it for this exact cwd, while the probe can name the parent worktree for a nested
-			// one. `commonPath` always comes from the probe — the CLI doesn't resolve repo identity.
-			const effectiveWorktreePath =
-				this.getBookkeeping(sessionId).cliSeatedWorktree && session.worktreePath != null
-					? session.worktreePath
-					: info.worktreePath;
-
-			// Capture the worktree/commonPath at the first successful resolve so consumers can
-			// detect drift (e.g. an agent that `cd`'d into a sibling worktree after launch). Gated
-			// on `initialCommonPath` — captured together with `initialWorktreePath` so a first
-			// resolve where `info.worktreePath` happens to be undefined doesn't leave the latter
-			// open to a later overwrite. Once set, never overwritten.
-			const firstResolve = session.initialCommonPath == null;
-			const updatedInitialWorktreePath = firstResolve ? effectiveWorktreePath : session.initialWorktreePath;
-			const updatedInitialCommonPath = firstResolve ? info.repoRoot : session.initialCommonPath;
-
-			if (
-				cwd !== session.cwd ||
-				effectiveWorktreePath !== session.worktreePath ||
-				info.repoRoot !== session.commonPath ||
-				updatedInitialWorktreePath !== session.initialWorktreePath ||
-				updatedInitialCommonPath !== session.initialCommonPath
-			) {
-				this._sessions[index] = {
-					...session,
-					cwd: cwd,
-					worktreePath: effectiveWorktreePath,
-					commonPath: info.repoRoot,
-					initialWorktreePath: updatedInitialWorktreePath,
-					initialCommonPath: updatedInitialCommonPath,
-					visitedWorktreePaths: unionVisited(session.visitedWorktreePaths, effectiveWorktreePath),
-				};
-				this._onDidChangeSessions.fire();
-			}
-		} finally {
-			this._resolveGitInfoInFlight.delete(sessionId);
-
-			// Hand off to the newest cwd requested while this probe ran, so a move that arrived
-			// mid-flight still resolves instead of being dropped by the dedupe.
-			const pendingCwd = this._resolveGitInfoPending.get(sessionId);
-			if (pendingCwd != null) {
-				this._resolveGitInfoPending.delete(sessionId);
-				void this.resolveGitInfo(sessionId, pendingCwd);
-			}
-		}
-	}
-
-	private async resolveTranscriptTitles(sessionId: string, cwd: string | undefined): Promise<void> {
-		// The reader only understands Claude Code's `~/.claude/projects/**` JSONL store, so for any
-		// other agent this would be a guaranteed-miss directory scan on every event and poll.
-		if (!this.supportsTranscripts(sessionId)) return;
-
-		let titles;
-		try {
-			titles = await this._transcriptReader.resolve(sessionId, cwd);
-		} catch {
-			return;
-		}
-		if (titles == null) return;
-
-		const index = this._sessions.findIndex(s => s.id === sessionId);
-		if (index < 0) return;
-
-		const session = this._sessions[index];
-		const prev = session.transcriptTitles;
-		if (prev?.custom === titles.custom && prev?.ai === titles.ai && prev?.agent === titles.agent) return;
-
-		this._sessions[index] = {
-			...session,
-			transcriptTitles: { custom: titles.custom, ai: titles.ai, agent: titles.agent },
-		};
-		this._onDidChangeSessions.fire();
-	}
-
-	/** Transitions the session at `index` to the terminal `ended` state in place: keeps the row,
-	 *  stamps `endedAt` as its activity time, clears transient state (statusDetail, pendingPermission,
-	 *  subagents), and tears down its bookkeeping/timers. Shared by the live `SessionEnd` path and the
-	 *  poll backstop for a `SessionEnd` the live path missed. Does not fire change events — the caller
-	 *  batches those. */
-	private endSession(index: number, endedAt: Date): void {
-		const prev = this._sessions[index];
-		this._sessions[index] = {
-			...prev,
-			status: 'ended',
-			phase: 'ended',
-			phaseSince: endedAt,
-			lastActivity: endedAt,
-			statusDetail: undefined,
-			pendingPermission: undefined,
-			subagents: undefined,
-		};
-		// Terminal teardown, owned here so every caller gets it — the live `SessionEnd` path does
-		// this before calling us, but the poll's missed-SessionEnd transition doesn't: reject any
-		// in-flight permission promise (otherwise a blocking request leaks until dispose) and cancel a
-		// pending Stop→idle timer (otherwise it fires inside its window and revives this row to a
-		// live zombie).
-		const pending = this._pendingPermissions.get(prev.id);
-		if (pending != null) {
-			this.rejectAllPending(pending, new Error('Session ended'));
-			this._pendingPermissions.delete(prev.id);
-		}
-		this.cancelPendingIdleTransition(prev.id);
-
-		const bk = this._sessionBookkeeping.get(prev.id);
-		if (bk != null) {
-			this.cancelPendingFileClears(bk);
-			this.cancelPendingReadClears(bk);
-		}
-		this._sessionBookkeeping.delete(prev.id);
-		this._transcriptReader.forget(prev.id);
-		this.noteTerminalTransition();
-	}
-
-	private pruneDeadSessions(): boolean {
-		const kept: AgentSession[] = [];
-		const removedIds: string[] = [];
-		for (const s of this._sessions) {
-			// Ended sessions are terminal and durable — their PID is usually dead by design, so
-			// liveness pruning must never drop them (they leave only via poll reconciliation).
-			if (s.status === 'ended') {
-				kept.push(s);
-				continue;
-			}
-
-			// An agent that multiplexes concurrent sessions in one process (Codex) reports the SAME
-			// pid for all of them, so the pid answers "is the host process alive", not "is this
-			// session alive" — in both directions. A live shared process would pin every session it
-			// ever hosted, and a dead one would reap live siblings along with the finished session.
-			// Neither is recoverable here, so pid liveness is not evidence for these rows at all:
-			// keep them and let the paths that DO identify a session end them — a `SessionEnd`, or the
-			// poll seeing the CLI's durable `ended` record (which the CLI writes for a stale session
-			// of its own accord). The CLI takes the same position: for `pidSharingClients` a pid-only
-			// match is a guess, so it keeps such an end revivable.
-			if (getAgentCapabilitiesByProviderId(s.providerId)?.sharesPids === true) {
-				kept.push(s);
-				continue;
-			}
-
-			// A session blocking on us for a permission decision is by definition alive,
-			// even if `kill(pid, 0)` says otherwise (e.g. transient EPERM/ESRCH). Dropping
-			// it here loses pendingPermission and lastPrompt; the next syncSessions then
-			// re-adds it as a stale shell with `permission_requested` status but no detail.
-			if (s.pid == null || isProcessAlive(s.pid) || this._pendingPermissions.has(s.id)) {
-				kept.push(s);
-			} else {
-				removedIds.push(s.id);
-			}
-		}
-		if (removedIds.length === 0) return false;
-
-		this._sessions = kept;
-		for (const id of removedIds) {
-			const pending = this._pendingPermissions.get(id);
-			if (pending != null) {
-				this.rejectAllPending(pending, new Error('Session pruned'));
-				this._pendingPermissions.delete(id);
-			}
-			this.cancelPendingIdleTransition(id);
-			// Cancel any in-flight decay-eviction timers before dropping the bookkeeping (mirrors
-			// SessionEnd). A Stopped-then-killed session reaches here with armed cooldown timers
-			// (settleBookkeeping leaves them running), so without this they'd leak until they fire.
-			const bk = this._sessionBookkeeping.get(id);
-			if (bk != null) {
-				this.cancelPendingFileClears(bk);
-				this.cancelPendingReadClears(bk);
-			}
-			this._sessionBookkeeping.delete(id);
-			this._transcriptReader.forget(id);
-		}
-		this.noteTerminalTransition();
-		Logger.debug(
-			`GkAgentProvider.syncSessions: removed ${removedIds.length} stale session(s): ${removedIds.map(id => id.substring(0, 8)).join(', ')}`,
-		);
-		return true;
-	}
-
-	protected async syncSessions(options?: { gate?: boolean }): Promise<void> {
-		// Recurring (gated) calls skip the CLI spawn when there's nothing to reconcile: no tracked
-		// sessions AND no installed hooks. Sessions only ever appear via the IPC push path or a peer,
-		// so an empty list with hooks off means no agents are reachable here. We still poll whenever
-		// sessions exist — that's the only local backstop for pruning agents that die without firing
-		// `SessionEnd`, and it keeps us correct even if hook detection is stale/wrong. The bootstrap
-		// call in `ensureIpcServer` passes no options, so cold-start discovery always runs.
-		// Deliberately counts ALL tracked sessions, ended included. An ended row is something
-		// we have to reconcile — it's removed only when the CLI stops listing it (archived from
-		// another window, or aged out) — and this poll is the sole mechanism that does so. It's also
-		// what triggers the CLI's own 30-day retention sweep, which runs on `list-sessions` and
-		// nothing else: no timer, no daemon. Gating it out to save a spawn wouldn't avoid work, it
-		// would strand the rows on screen AND the records on disk until the window reloads.
-		if (options?.gate && this._sessions.length === 0 && !this._hooksInstalled) return;
-
-		// Narrowly: hooks off AND nothing running, i.e. we hold only terminal history. There's no
-		// dying process to reap and no live state to correct — just rows to reconcile and the
-		// retention sweep to trigger, neither of which needs quarter-hourly resolution. Back the
-		// cadence off rather than stopping (window startup polls ungated, so a reload is current).
-		// Hooks ON keeps the full cadence deliberately: there the tick is also the backstop for a
-		// session whose hook events never reached our IPC server.
-		if (
-			options?.gate &&
-			!this._hooksInstalled &&
-			!this._sessions.some(s => s.status !== 'ended') &&
-			Date.now() - this._lastSyncAt < idleReconcileIntervalMs
-		) {
-			return;
-		}
-
-		// Stamped BEFORE the CLI call so the reconciliation below can tell "this poll's snapshot was
-		// taken after we ended the row" from "an in-flight poll that predates it" — see the
-		// ended-removal filter.
-		const pollStartedAt = Date.now();
-		this._lastSyncAt = pollStartedAt;
-
-		let sessions: SessionFileData[];
-		try {
-			let output: string;
-			try {
-				// `--status active,ended` surfaces both live sessions and the CLI's durable ended records
-				// (excluding `archived`). Newer CLIs default `list-sessions` to active-only, so the flag
-				// is required to see ended sessions at all.
-				output = await this.callbacks.runCLICommand([
-					'ai',
-					'hook',
-					'list-sessions',
-					'--status',
-					'active,ended',
-					'--json',
-				]);
-				this._statusFilterSupported = true;
-			} catch (ex) {
-				// Only retry on an unknown-flag error — a pre-3.1.69 CLI rejects `--status` but returns
-				// all sessions unfiltered, so the flagless call is the correct legacy equivalent. Real
-				// failures (CLI missing, spawn error) rethrow to the prune-and-return handler below.
-				if (!isUnknownFlagError(ex)) throw ex;
-
-				this._statusFilterSupported = false;
-				output = await this.callbacks.runCLICommand(['ai', 'hook', 'list-sessions', '--json']);
-			}
-			sessions = JSON.parse(output) as SessionFileData[];
-		} catch (ex) {
-			// Expected whenever the CLI is missing or still installing, so not an error — but log it:
-			// every session in the window silently stops reconciling until the next tick, and without
-			// this the symptom ("no agents anywhere") is indistinguishable from having no agents.
-			Logger.debug(
-				`GkAgentProvider.syncSessions: poll skipped — ${ex instanceof Error ? ex.message : String(ex)}`,
-			);
-			if (this.pruneDeadSessions()) {
-				this._onDidChangeSessions.fire();
-			}
-			return;
-		}
-
-		// Snapshot what the live IPC path had already tracked, so we can detect drift between it and
-		// what the poll returns. Ideally they match exactly — any difference means the live push path
-		// missed an add (poll discovers it) or a teardown (poll no longer reports a session we track).
-		// Drift is measured over *live* sessions only; ended sessions are durable history, so their
-		// absence from `polledAlive` is expected and must not skew the discrepancy signal.
-		//
-		// Both maps carry the owning agent's `providerId` per session so the report below can be split
-		// per agent: the two paths' reliability differs by agent (one may never reach the live path at
-		// all), and one pooled number would average that away into noise.
-		const trackedLiveBefore = new Map(
-			this._sessions.filter(s => s.status !== 'ended').map(s => [s.id, s.providerId] as const),
-		);
-		const polledAlive = new Map<string, string>();
-		// Every id the poll returned (live *and* ended). Drives ended-session reconciliation:
-		// a tracked ended session absent from this set was archived/purged by the CLI.
-		const polledIds = new Set<string>();
-		// Accumulates ids already tracked or added during this poll, so the membership check is O(1)
-		// and duplicate ids within a single response are only added once.
-		const known = new Set(this._sessions.map(s => s.id));
-
-		// The CLI's durable store never revives a resumed session — once it moves a record to its
-		// `ended` store, nothing moves it back, so a record reporting `ended` isn't proof the session
-		// is over. The listing also repairs the two active-record cases that have no fresher hook state:
-		// first discovery and synthesized, unresolvable permission asks. Fetched once per poll (not per
-		// row); the host caches the underlying `claude agents --json` invocation behind a short TTL, so
-		// this doesn't spawn a process per session.
-		const liveSessions = await this.callbacks.getLiveAgentSessions?.();
-
-		let changed = false;
-		const discoveredByAgent = new Map<string, number>();
-		const noteDiscovered = (providerId: string): void => {
-			discoveredByAgent.set(providerId, (discoveredByAgent.get(providerId) ?? 0) + 1);
-		};
-		/** Ids kept alive against a stale `ended` record. Logged below — this path has no other
-		 *  observability, and "the agent isn't showing up" is otherwise indistinguishable from
-		 *  "the listing never ran". */
-		const keptAlive: string[] = [];
-
-		for (const data of sessions) {
-			if (!data.sessionId) continue;
-
-			// A record from a client we hold no descriptor for (the CLI supports more than this table
-			// does). Must stay ahead of `polledIds`/`polledAlive`: an id in either would skew ended-row
-			// reconciliation and the `onSyncDiscrepancy` drift signal below. Absent = `claude-code`,
-			// matching the live path — older CLIs don't stamp it.
-			const capabilities = getAgentCapabilities(data.providerId ?? 'claude-code');
-			if (capabilities == null) continue;
-
-			// The record's `event` is the agent's native name. Canonicalize it so `deriveStatusFromEvent`
-			// sees a vocabulary it knows — an unmapped native name falls through to `data.event`, which
-			// that function's `default` already resolves to `idle`. Deliberately NOT a skip: unlike the
-			// live path, nothing here switches exhaustively on the name, and dropping the record would
-			// hide a real session whose last event simply has no canonical analogue.
-			//
-			// `data.hookInput` must be passed: an agent whose event name alone can't determine the
-			// canonical event (OpenCode's `session.status`) is resolved from the payload, so withholding
-			// it makes those names permanently unresolvable on this path — and the poll is the only way
-			// a pre-existing session enters after a window reload.
-			const canonicalEvent = resolveCanonicalHookEvent(capabilities, data.event, data.hookInput) ?? data.event;
-			// Same translation for the record's tool name — `classifyPermissionKind` and the display
-			// detail expect canonical names.
-			const polledToolName =
-				data.toolName != null ? resolveCanonicalToolName(capabilities, data.toolName) : undefined;
-
-			const effectiveStatus = data.status ?? 'active';
-
-			// Archived records are excluded by the `active,ended` query; guard anyway.
-			if (effectiveStatus === 'archived') continue;
-
-			if (effectiveStatus === 'ended') {
-				polledIds.add(data.sessionId);
-				const endedDate = new Date(data.endedAt ?? data.updatedAt);
-				const override = liveOverrideFor(liveSessions, data.sessionId);
-				const liveCwd = override?.live.cwd;
-				const currentCwd = liveCwd ?? data.cwd;
-				const liveCwdMoved = liveCwd != null && liveCwd !== data.cwd;
-				const recordWorktreeRoot = worktreeRootFromData(data);
-				const currentWorktreeRoot = liveCwdMoved ? undefined : recordWorktreeRoot;
-
-				const existingIndex = this._sessions.findIndex(s => s.id === data.sessionId);
-				if (existingIndex >= 0) {
-					const bookkeeping = this.getBookkeeping(data.sessionId);
-					if (liveCwdMoved) {
-						bookkeeping.supersededRecordCwd = data.cwd;
-					} else if (
-						bookkeeping.supersededRecordCwd != null &&
-						bookkeeping.supersededRecordCwd !== data.cwd
-					) {
-						// The CLI rewrote the record for the resumed run — it describes the session again.
-						bookkeeping.supersededRecordCwd = undefined;
-					}
-
-					// The record still names the cwd a resume superseded, and this poll no longer lists the
-					// session live: the resumed process exited (or died) before the CLI rewrote the record,
-					// so neither its cwd nor its `endedAt` describe where or when the session last ran.
-					const recordLocationStale = override == null && bookkeeping.supersededRecordCwd === data.cwd;
-
-					if (override != null) {
-						const { live: liveSession, status: liveStatus } = override;
-						// `claude agents --json` still lists this exact session id as live — the store's
-						// `ended` record is stale. Keep the row alive instead of ending it, and prefer the
-						// listing's pid — the record's own may already be dead, or reused. Background sessions
-						// carry no pid at all, so fall back to whatever pid the row already has.
-						//
-						// The listing establishes LIVENESS, not status. It's a poll SAMPLE of a value that flips
-						// many times per turn, so adopting it every poll stamps a row back to `idle` moments after
-						// a hook event moved it to `tool_use`/`thinking` — the row then reads idle almost always
-						// and working almost never. Hook events are strictly fresher, so the sample is only taken
-						// when the row has nothing better: it was ended, and this poll is what revives it.
-						const trackedSession = this._sessions[existingIndex];
-						// The listing's pid, or none. Never fall back to the pid we already hold: the listing
-						// omits one only for background sessions, which have no process of their own, and the
-						// pid on the row is the dead one whose exit produced the `ended` record. Carrying it
-						// onto a live row makes `pruneDeadSessions` reap the row later in this same poll.
-						const nextPid = liveSession.pid;
-						const revived = trackedSession.status === 'ended';
-						const nextStatus = revived ? liveStatus : trackedSession.status;
-						if (
-							trackedSession.status !== nextStatus ||
-							trackedSession.pid !== nextPid ||
-							trackedSession.endReason != null ||
-							trackedSession.endedAt != null
-						) {
-							this._sessions[existingIndex] = {
-								...trackedSession,
-								status: nextStatus,
-								phase: getPhaseForStatus(nextStatus),
-								// Only re-stamp the phase/activity clocks on the revive itself; otherwise a poll
-								// keeps resetting them under a row whose status it didn't change.
-								phaseSince: revived ? new Date(pollStartedAt) : trackedSession.phaseSince,
-								lastActivity: revived ? new Date(pollStartedAt) : trackedSession.lastActivity,
-								pid: nextPid,
-								statusDetail: revived ? undefined : trackedSession.statusDetail,
-								endReason: undefined,
-								endedAt: undefined,
-							};
-							changed = true;
-						}
-						keptAlive.push(`${data.sessionId.substring(0, 8)}:${nextStatus}`);
-						polledAlive.set(data.sessionId, capabilities.providerId);
-					} else if (this._sessions[existingIndex].status !== 'ended') {
-						// Already tracked, and Claude no longer lists it as live. If the live path missed the
-						// SessionEnd (e.g. `/clear` kept the PID alive under a new id), transition it to
-						// ended now — otherwise a live-status row would linger as a zombie, since
-						// pruneDeadSessions can't reap a live PID.
-						// The record's `endedAt` can predate activity this window already observed — a
-						// superseded record after a cwd move, or a same-cwd resume the CLI hasn't rewritten
-						// the record for yet — so never move the row's clock backward.
-						const { lastActivity } = this._sessions[existingIndex];
-						this.endSession(
-							existingIndex,
-							lastActivity.getTime() > endedDate.getTime() ? lastActivity : endedDate,
-						);
-						changed = true;
-					}
-
-					// Re-seat the row on its current location. The durable record is authoritative for a
-					// terminal session, but an independent Claude listing can prove that record stale and
-					// supply the resumed process's current cwd. Keep the prior worktree attribution until
-					// the live cwd's git probe confirms a replacement — a resumed session can legitimately
-					// sit in scratch space — but never let a later poll move it back to the ended record's
-					// directory. A record already known superseded stays ignored until the CLI rewrites it,
-					// so the row survives the resumed process exiting before that write lands. Prompts get a
-					// hole-fill from the record below when nothing has been set yet; titles keep their own
-					// on-demand transcript resolution, which holds richer values than the record does.
-					const existing = this._sessions[existingIndex];
-					const cwdChanged = !recordLocationStale && currentCwd !== existing.cwd;
-					// Pre-`cwdTimeline` records carry no worktree data. If the cwd moved, whatever we hold
-					// is no longer trustworthy — it may point into a different repo entirely — so drop it
-					// rather than leave the card filed under the wrong branch, and re-resolve below. A cwd
-					// supplied by the live listing is different: preserve the old attribution as a fallback
-					// until the current cwd's probe succeeds.
-					const nextWorktreePath = recordLocationStale
-						? existing.worktreePath
-						: currentWorktreeRoot != null
-							? normalizePath(currentWorktreeRoot)
-							: cwdChanged && !liveCwdMoved
-								? undefined
-								: existing.worktreePath;
-					const worktreeMoved = nextWorktreePath !== existing.worktreePath;
-					if (cwdChanged || worktreeMoved) {
-						const workspacePath = this.resolveWorkspacePath(currentCwd);
-						this._sessions[existingIndex] = {
-							...existing,
-							cwd: currentCwd,
-							initialCwd: existing.initialCwd ?? data.initialCwd ?? data.cwd,
-							worktreePath: nextWorktreePath,
-							workspacePath: workspacePath,
-							isInWorkspace: workspacePath != null,
-							// A worktree move can cross repos, and the spread would otherwise carry the old
-							// repo identity forward — which consumers PREFER over the freshly-resolved
-							// worktree metadata, pinning the card to the wrong repo. Drop it and let the
-							// host backfill from the new worktree.
-							commonPath: worktreeMoved ? undefined : existing.commonPath,
-							visitedWorktreePaths: unionVisited(
-								existing.visitedWorktreePaths,
-								visitedFromTimeline(data.cwdTimeline),
-								data.worktrees,
-								nextWorktreePath,
-							),
-						};
-						changed = true;
-
-						// Nothing in the record to re-seat it with (older CLI), or the record names a
-						// NEW worktree the drop above just cleared `commonPath` for — either way, resolve
-						// the cwd once rather than leaving the row location-less until some later event
-						// happens to change `cwd`/`worktreePath` again (a same-worktree poll afterward
-						// skips this branch entirely, since `worktreeMoved` goes false).
-						if (liveCwdMoved || nextWorktreePath == null || worktreeMoved) {
-							this.getBookkeeping(data.sessionId).cliSeatedWorktree = currentWorktreeRoot != null;
-							void this.resolveGitInfo(data.sessionId, currentCwd);
-						}
-					}
-
-					// Prompts backfill-only: the record's prompt/firstPrompt sanitized the same way the
-					// discovery path does. Never overwrites a value the hook path or a transcript resolve
-					// already set.
-					const currentSession = this._sessions[existingIndex];
-					const nextLastPrompt = currentSession.lastPrompt ?? prepareStoredPrompt(data.prompt ?? undefined);
-					const nextFirstPrompt =
-						currentSession.firstPrompt ?? prepareStoredPrompt(data.firstPrompt ?? undefined);
-					if (
-						nextLastPrompt !== currentSession.lastPrompt ||
-						nextFirstPrompt !== currentSession.firstPrompt
-					) {
-						this._sessions[existingIndex] = {
-							...currentSession,
-							lastPrompt: nextLastPrompt,
-							firstPrompt: nextFirstPrompt,
-						};
-						changed = true;
-					}
-
-					const nextBookkeeping = this.getBookkeeping(data.sessionId);
-					nextBookkeeping.polledAtLeastOnce = true;
-					// `endSession` above drops the bookkeeping entry, but the latch has to outlive that
-					// transition — otherwise the next poll finds none and re-seats the row onto the very
-					// record this one already knew was superseded.
-					nextBookkeeping.supersededRecordCwd = bookkeeping.supersededRecordCwd;
-					continue;
-				}
-
-				known.add(data.sessionId);
-				const workspacePath = this.resolveWorkspacePath(currentCwd);
-
-				if (override != null) {
-					const { live: liveSession, status: liveStatus } = override;
-					// This window is learning about the session for the first time via its `ended`
-					// record, but `claude agents --json` still lists it as live — same override as the
-					// tracked branch above, just pushing a fresh row instead of updating one in place. The
-					// listing's cwd is current; the ended record's worktree remains only as a fallback until
-					// the live cwd's git probe resolves it.
-					this._sessions.push({
-						id: data.sessionId,
-						providerId: capabilities.providerId,
-						providerName: capabilities.displayName,
-						name: data.sessionName || undefined,
-						status: liveStatus,
-						phase: getPhaseForStatus(liveStatus),
-						phaseSince: new Date(pollStartedAt),
-						// Listing's pid or none — never the record's, which is the dead process whose exit
-						// wrote the `ended` record (see the tracked branch above).
-						pid: liveSession.pid,
-						lastActivity: new Date(pollStartedAt),
-						isSubagent: false,
-						workspacePath: workspacePath,
-						worktreePath: recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
-						visitedWorktreePaths: unionVisited(
-							undefined,
-							visitedFromTimeline(data.cwdTimeline),
-							data.worktrees,
-							recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
-						),
-						cwd: currentCwd,
-						initialCwd: data.initialCwd ?? data.cwd,
-						planFile: data.planFile ?? undefined,
-						isInWorkspace: workspacePath != null,
-						lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
-						firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
-						model: data.model ?? undefined,
-					});
-					this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
-					this.getBookkeeping(data.sessionId).cliSeatedWorktree = currentWorktreeRoot != null;
-					if (liveCwdMoved) {
-						// Latch the cwd this listing superseded, so a later poll that no longer finds the
-						// session live doesn't re-seat the row back onto the not-yet-rewritten record.
-						this.getBookkeeping(data.sessionId).supersededRecordCwd = data.cwd;
-					}
-					changed = true;
-					noteDiscovered(capabilities.providerId);
-					keptAlive.push(`${data.sessionId.substring(0, 8)}:${liveStatus}`);
-					polledAlive.set(data.sessionId, capabilities.providerId);
-					if (liveCwdMoved || recordWorktreeRoot == null) {
-						void this.resolveGitInfo(data.sessionId, currentCwd);
-					}
-					void this.resolveTranscriptTitles(data.sessionId, currentCwd);
-					continue;
-				}
-
-				this._sessions.push({
-					id: data.sessionId,
-					providerId: capabilities.providerId,
-					providerName: capabilities.displayName,
-					name: data.sessionName || undefined,
-					status: 'ended',
-					phase: 'ended',
-					phaseSince: endedDate,
-					pid: data.pid,
-					lastActivity: endedDate,
-					isSubagent: false,
-					workspacePath: workspacePath,
-					// Read straight from the CLI's durable record so ended sessions attach to branch
-					// cards / WIP rows / the resume picker at any age, no git probe.
-					worktreePath: recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
-					visitedWorktreePaths: unionVisited(
-						undefined,
-						visitedFromTimeline(data.cwdTimeline),
-						data.worktrees,
-						recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
-					),
-					cwd: data.cwd,
-					initialCwd: data.initialCwd ?? data.cwd,
-					planFile: data.planFile ?? undefined,
-					isInWorkspace: workspacePath != null,
-					lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
-					firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
-					model: data.model ?? undefined,
-					endReason: data.endReason ?? undefined,
-					endedAt: data.endedAt != null ? new Date(data.endedAt).getTime() : undefined,
-					// Subagents are meaningless once terminal.
-					subagents: undefined,
-				});
-				this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
-				changed = true;
-				this.noteTerminalTransition();
-				// Titles/prompts still resolve lazily via resolveEndedSessionDetails (a 30-day
-				// cold-start must not fan out transcript reads). worktreePath comes from the record
-				// above; only fall back to an eager git probe when the record predates that CLI field,
-				// and only for the recent (WIP-window) tail so the fallback stays bounded.
-				if (
-					recordWorktreeRoot == null &&
-					data.cwd &&
-					Date.now() - endedDate.getTime() < recentEndedGitResolveThresholdMs
-				) {
-					void this.resolveGitInfo(data.sessionId, data.cwd);
-				}
-				continue;
-			}
-
-			// Active / legacy (absent-status) path — only genuinely-live processes are discoverable.
-			if (!data.pid || !isProcessAlive(data.pid)) continue;
-
-			polledAlive.set(data.sessionId, capabilities.providerId);
-			polledIds.add(data.sessionId);
-
-			if (known.has(data.sessionId)) {
-				// Already tracked.
-				const existingIndex = this._sessions.findIndex(s => s.id === data.sessionId);
-				if (existingIndex >= 0) {
-					const existing = this._sessions[existingIndex];
-					// The status the CLI's last event implies — a resumed session may already be mid-work
-					// (`PreToolUse` → tool_use, `UserPromptSubmit` → thinking), and hardcoding `idle` would
-					// mislabel active work and risk a concurrent-write resume.
-					const polledStatus = deriveStatusFromEvent(canonicalEvent);
-					const isSynthesizedAsk =
-						existing.status === 'permission_requested' && existing.pendingPermission?.resolvable === false;
-					const liveEntry = isSynthesizedAsk ? liveSessions?.get(data.sessionId) : undefined;
-					const liveStatus = liveEntry != null ? statusFromLiveSession(liveEntry) : undefined;
-					if (isSynthesizedAsk && liveEntry != null && liveStatus == null) {
-						// A terminal listing entry proves this active record is stale, even if its last event
-						// advanced after the ask. It carries no authoritative terminal timestamp/details, so
-						// remove the false live row and let the durable ended record restore it later. Run the
-						// standard terminal teardown first so no timers or caches survive the row.
-						this.endSession(existingIndex, new Date(pollStartedAt));
-						this._sessions.splice(existingIndex, 1);
-						polledAlive.delete(data.sessionId);
-						changed = true;
-						continue;
-					}
-
-					if (existing.status === 'ended') {
-						// We hold it as `ended` but the CLI now reports it as a live process (a
-						// resume the live SessionStart path missed) — revive it, the symmetric backstop
-						// to the ended-branch's live→ended transition above. Leave genuinely-live
-						// rows to the IPC path.
-						const revivedAt = new Date(data.updatedAt);
-						// Only when the record is at least as new as the end. `SessionEnd` fires
-						// while the process is still winding down, so a poll whose CLI call started
-						// BEFORE it returns a snapshot that still says "active" with a live pid — reviving
-						// off that stale record would resurrect the row, and `pruneDeadSessions` would
-						// then delete it outright once the process exits, losing the ended row.
-						if (revivedAt.getTime() < existing.phaseSince.getTime()) continue;
-
-						// The poll has no blocking hook entry for this ask (it's discovered off the CLI's
-						// durable record, not this window's IPC path) — synthesize an unresolvable one so
-						// the row shows what it's waiting on instead of an empty "Needs input" card.
-						const revivedPendingPermission =
-							polledStatus === 'permission_requested'
-								? synthesizeUnresolvableAsk(polledToolName, data.planFile ?? undefined)
-								: undefined;
-						// Seat worktreePath from the record, mirroring the ended-record re-seat above — the
-						// existing row is otherwise stuck with whatever (or nothing) it had while ended.
-						const revivedWorktreeRoot = worktreeRootFromData(data);
-						// No record worktree data (older CLI): KEEP the ended row's attribution. A
-						// resume whose cwd is scratch space (e.g. /tmp) still belongs to its worktree —
-						// re-rooting happens only when git affirmatively resolves a new one (the probe
-						// below, on success). Attribution persists until something better is known.
-						const revivedWorktreePath =
-							revivedWorktreeRoot != null ? normalizePath(revivedWorktreeRoot) : existing.worktreePath;
-						// Membership follows the attribution, mirroring `ensureSession`: cwd first, the
-						// kept worktree as the fallback for a scratch-dir resume.
-						const revivedWorkspacePath =
-							this.resolveWorkspacePath(data.cwd) ?? this.resolveWorkspacePath(revivedWorktreePath);
-						this._sessions[existingIndex] = {
-							...existing,
-							status: polledStatus,
-							phase: getPhaseForStatus(polledStatus),
-							phaseSince: revivedAt,
-							lastActivity: revivedAt,
-							// Fresh pid from the CLI, and re-classify ownership on next open rather than
-							// trusting the terminal record's `isPeerOwned`.
-							pid: data.pid,
-							isPeerOwned: undefined,
-							pendingPermission: revivedPendingPermission,
-							// The resume can be running somewhere else entirely, so take the record's
-							// location rather than leaving the row filed under where it ended.
-							cwd: data.cwd ?? existing.cwd,
-							workspacePath:
-								revivedWorkspacePath ?? (data.cwd == null ? existing.workspacePath : undefined),
-							isInWorkspace: data.cwd == null ? existing.isInWorkspace : revivedWorkspacePath != null,
-							worktreePath: revivedWorktreePath,
-							visitedWorktreePaths: unionVisited(
-								existing.visitedWorktreePaths,
-								visitedFromTimeline(data.cwdTimeline),
-								data.worktrees,
-								revivedWorktreePath,
-							),
-							// A worktree move can cross repos — drop the stale repo identity and let the
-							// probe below refill it.
-							commonPath: revivedWorktreePath !== existing.worktreePath ? undefined : existing.commonPath,
-							// No longer terminal: leaving these set makes the row read as ended to
-							// consumers that key off them.
-							endReason: undefined,
-							endedAt: undefined,
-						};
-						this.resetBookkeeping(data.sessionId);
-						// The record's worktree is the CLI's own resolution; without one the probe owns
-						// attribution again.
-						this.getBookkeeping(data.sessionId).cliSeatedWorktree = revivedWorktreeRoot != null;
-						// A revive whose worktree moved but whose cwd happens to equal the prior one still
-						// dropped `commonPath` above and needs the probe to refill it.
-						if (
-							data.cwd != null &&
-							(data.cwd !== existing.cwd || revivedWorktreePath !== existing.worktreePath)
-						) {
-							void this.resolveGitInfo(data.sessionId, data.cwd);
-						}
-						changed = true;
-					} else if (
-						existing.pendingPermission?.resolvable === false &&
-						polledStatus !== 'permission_requested' &&
-						new Date(data.updatedAt).getTime() > existing.lastActivity.getTime()
-					) {
-						// The record has moved past the ask this row still shows. Only a synthesized
-						// (`resolvable: false`) ask is repairable this way — a routable one is bookkeeping-
-						// owned and cleared by its own resolution paths, which the record can't see.
-						this._sessions[existingIndex] = {
-							...existing,
-							status: polledStatus,
-							phase: getPhaseForStatus(polledStatus),
-							phaseSince: new Date(data.updatedAt),
-							// The detail described the ask's tool; carry the record's current tool for
-							// tool_use, else clear — keeping it would show the answered ask's tool as
-							// the active one.
-							statusDetail: polledStatus === 'tool_use' ? polledToolName : undefined,
-							pendingPermission: undefined,
-							lastActivity: new Date(data.updatedAt),
-						};
-						changed = true;
-					} else if (isSynthesizedAsk) {
-						// The record never moved past the ask it froze on — the ask was resolved while no
-						// window was listening, so nothing ever advanced it — but Claude's own listing
-						// says the session has moved on. Correct the row so it heals on the next poll
-						// instead of waiting for a reload or fresh hook events. Only synthesized asks
-						// are repairable here: a routable one is bookkeeping-owned and cleared by its
-						// own resolution paths, which the listing must never preempt.
-						if (liveStatus != null && liveStatus !== 'permission_requested') {
-							this._sessions[existingIndex] = {
-								...existing,
-								status: liveStatus,
-								phase: getPhaseForStatus(liveStatus),
-								phaseSince: new Date(pollStartedAt),
-								pendingPermission: undefined,
-								statusDetail: undefined,
-							};
-							changed = true;
-						}
-					} else if (existing.transcriptTitles?.ai == null && existing.transcriptTitles?.custom == null) {
-						// A live session we discovered via the poll (another worktree/window owns its
-						// hook flow) gets none of the local IPC re-resolves (SessionStart, idle). So one
-						// discovered before Claude wrote its `ai-title` would show the repo slug forever.
-						// Re-check the transcript each poll until a real title lands — cheap: the reader
-						// tail-reads from its mtime cache and no-ops when the file hasn't grown.
-						void this.resolveTranscriptTitles(data.sessionId, data.cwd);
-					}
-				}
-				continue;
-			}
-
-			known.add(data.sessionId);
-
-			const workspacePath = this.resolveWorkspacePath(data.cwd);
-			const isInWorkspace = workspacePath != null;
-			const activityDate = new Date(data.updatedAt);
-			let status = deriveStatusFromEvent(canonicalEvent);
-			let phaseSince = activityDate;
-			// The record's last event can be arbitrarily stale — an ask answered while no window
-			// was listening (e.g. mid-reload), or a session stopped right there, never advances it,
-			// so every window start would re-seed the frozen state. Claude's own listing is
-			// authoritative for what the session is doing right now — same contract as the
-			// ended-record revival above. Absence from the listing (including its fail-soft empty
-			// map on spawn failure) keeps record-derived status: absence must never mean dead.
-			const liveEntry = liveSessions?.get(data.sessionId);
-			if (liveEntry != null) {
-				const liveStatus = statusFromLiveSession(liveEntry);
-				if (liveStatus == null) {
-					polledAlive.delete(data.sessionId);
-					continue;
-				}
-
-				if (liveStatus !== status) {
-					status = liveStatus;
-					phaseSince = new Date(pollStartedAt);
-				}
-			}
-
-			const phase = getPhaseForStatus(status);
-			// Same rationale as the revived-session branch above: no blocking hook entry exists for a
-			// poll-discovered ask, so synthesize an unresolvable one for the card.
-			const pendingPermission =
-				status === 'permission_requested'
-					? synthesizeUnresolvableAsk(polledToolName, data.planFile ?? undefined)
-					: undefined;
-			// Read straight from the CLI's durable record so the row attaches to the right branch
-			// card/WIP row immediately, no git probe — mirrors the ended-session push below.
-			const worktreeRoot = worktreeRootFromData(data);
-
-			const subagents: AgentSession[] | undefined = data.subagents?.map(sub => ({
-				id: sub.agentId,
-				providerId: capabilities.providerId,
-				providerName: capabilities.displayName,
-				name: sub.agentType ?? 'Subagent',
-				status: 'thinking',
-				phase: 'working' as const,
-				phaseSince: activityDate,
-				lastActivity: activityDate,
-				isSubagent: true,
-				parentId: data.sessionId,
-				isInWorkspace: isInWorkspace,
-			}));
-
-			this._sessions.push({
-				id: data.sessionId,
-				providerId: capabilities.providerId,
-				providerName: capabilities.displayName,
-				name: data.sessionName || undefined,
-				status: status,
-				phase: phase,
-				phaseSince: phaseSince,
-				pid: data.pid,
-				lastActivity: activityDate,
-				isSubagent: false,
-				workspacePath: workspacePath,
-				cwd: data.cwd,
-				// Prefer the CLI's launch dir; fall back to the snapshot's (possibly drifted) cwd on
-				// older CLIs that don't record it. Without this, a window that cold-starts after the
-				// agent drifted would stamp the drifted cwd as the launch dir.
-				initialCwd: data.initialCwd ?? data.cwd,
-				planFile: data.planFile ?? undefined,
-				isInWorkspace: isInWorkspace,
-				lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
-				firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
-				model: data.model ?? undefined,
-				subagents: subagents,
-				pendingPermission: pendingPermission,
-				worktreePath: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
-				visitedWorktreePaths: unionVisited(
-					undefined,
-					visitedFromTimeline(data.cwdTimeline),
-					data.worktrees,
-					worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
-				),
-			});
-			changed = true;
-			noteDiscovered(capabilities.providerId);
-
-			// The record's worktree is the CLI's own resolution — mark it seated so the probe below
-			// (still wanted for `commonPath`) can't clobber it for a nested worktree. Mirrors the
-			// revival branch above.
-			this.getBookkeeping(data.sessionId).cliSeatedWorktree = worktreeRoot != null;
-			if (data.cwd) {
-				void this.resolveGitInfo(data.sessionId, data.cwd);
-			}
-			void this.resolveTranscriptTitles(data.sessionId, data.cwd);
-		}
-
-		// The poll is authoritative for ended-session removal (archived elsewhere or 30-day-purged).
-		// Only remove ones a prior poll confirmed present — never a session the live SessionEnd path just
-		// transitioned, which an already-in-flight poll can legitimately miss (guarded by polledAtLeastOnce).
-		// On a legacy CLI (no `--status`) no poll can ever confirm an ended row, so the guard would
-		// instead pin it forever — there, absence from the poll is the confirmation.
-		const staleEnded = this._sessions.filter(
-			s =>
-				s.status === 'ended' &&
-				!polledIds.has(s.id) &&
-				(!this._statusFilterSupported ||
-					this._sessionBookkeeping.get(s.id)?.polledAtLeastOnce === true ||
-					// Or this poll's snapshot postdates the end, so its absence is authoritative.
-					// `polledAtLeastOnce` alone can never be set for a session whose record disappeared
-					// (archived from another window, or purged) before any poll observed it — and
-					// `endSession` drops the bookkeeping — so without this the row is unremovable for
-					// the window's lifetime. The timestamp answers the same question the flag was proxying:
-					// could this poll have seen it? The grace keeps a just-ended row out of reach of
-					// an absence that's really a not-yet-visible record.
-					s.phaseSince.getTime() < pollStartedAt - endedRemovalGraceMs),
-		);
-		if (staleEnded.length > 0) {
-			const staleIds = new Set(staleEnded.map(s => s.id));
-			this._sessions = this._sessions.filter(s => !staleIds.has(s.id));
-			for (const s of staleEnded) {
-				this._sessionBookkeeping.delete(s.id);
-				this._transcriptReader.forget(s.id);
-			}
-			changed = true;
-		}
-
-		if (liveSessions != null) {
-			Logger.debug(
-				`GkAgentProvider.syncSessions: Claude lists ${liveSessions.size} session(s); kept ${keptAlive.length} alive against a stale ended record${
-					keptAlive.length > 0 ? `: ${keptAlive.join(', ')}` : ''
-				}`,
-			);
-		}
-
-		if (this.pruneDeadSessions()) {
-			changed = true;
-		}
-
-		if (changed) {
-			this._onDidChangeSessions.fire();
-		}
-
-		// Report any drift between the live-synced set and the poll. Only on the recurring (gated)
-		// poll — the ungated bootstrap call runs before the live path has had a chance to receive
-		// any events, so its discoveries are expected cold-start state, not drift. `missing` counts
-		// live sessions we still track that the poll no longer reports alive (a teardown the live path
-		// missed, e.g. an agent killed without firing `SessionEnd`).
-		if (options?.gate) {
-			type Drift = { discovered: number; missing: number; polled: number; tracked: number };
-			const driftByAgent = new Map<string, Drift>();
-			const driftFor = (providerId: string): Drift => {
-				let drift = driftByAgent.get(providerId);
-				if (drift == null) {
-					drift = { discovered: 0, missing: 0, polled: 0, tracked: 0 };
-					driftByAgent.set(providerId, drift);
-				}
-				return drift;
-			};
-
-			for (const [providerId, count] of discoveredByAgent) {
-				driftFor(providerId).discovered += count;
-			}
-			for (const [id, providerId] of trackedLiveBefore) {
-				const drift = driftFor(providerId);
-				drift.tracked++;
-				if (!polledAlive.has(id)) {
-					drift.missing++;
-				}
-			}
-			for (const providerId of polledAlive.values()) {
-				driftFor(providerId).polled++;
-			}
-
-			// One report per agent, not one pooled report: the counts describe how well the live path
-			// and the poll agree, which is a per-agent property. A single agent's numbers are unchanged
-			// from the pre-multi-agent shape.
-			for (const [providerId, drift] of driftByAgent) {
-				if (drift.discovered === 0 && drift.missing === 0) continue;
-
-				this.callbacks.onSyncDiscrepancy?.({ provider: providerId, ...drift });
-			}
-		}
-	}
-
-	protected async querySiblingWindowSessions(): Promise<void> {
-		const discoveryDir = this.callbacks.ipc.agentDiscoveryDir;
-		if (discoveryDir == null) return;
-
-		let files: string[];
-		try {
-			files = await readdir(discoveryDir);
-		} catch {
-			return;
-		}
-
-		const ownPort = this.callbacks.ipc.port;
-
-		const peerBatches = await Promise.all(
-			files
-				.filter(f => f.startsWith('gitlens-ipc-server-') && f.endsWith('.json'))
-				.map(async f => this.fetchPeerSessions(join(discoveryDir, f), ownPort)),
-		);
-
-		let changed = false;
-		// Peer sessions that arrived with `cwd` but no `commonPath` (peer was running pre-
-		// commonPath code, OR the peer's own `resolveGitInfo` failed and we get to retry locally).
-		// Resolved after the merge loop so the local Repository registry is consulted only once
-		// per unique session, off the hot merge path. Keyed by id (value = cwd) so the same
-		// session appearing in multiple peer responses (or re-queued within this loop) only
-		// triggers a single backfill probe.
-		const sessionsNeedingResolve = new Map<string, string>();
-
-		for (const peerSessions of peerBatches) {
-			if (peerSessions == null) continue;
-
-			for (const peerSession of peerSessions) {
-				// Skip terminal rows a peer published: ended sessions live in the machine-global CLI
-				// store, so our own poll surfaces them with proper reconciliation. Importing them from a
-				// peer would add a row with no `polledAtLeastOnce` that our poll can't confirm — a ghost
-				// pinned for this window's lifetime if the store later drops it. (The publish endpoint
-				// filters ended rows out anyway; this also keeps a version-skewed peer's terminal claim
-				// from ending a row we still track live.)
-				if (peerSession.status === 'ended') continue;
-
-				const existing = this._sessions.find(s => s.id === peerSession.id);
-				const peerActivity = new Date(peerSession.lastActivity);
-				const peerPhaseSince = new Date(peerSession.phaseSince);
-
-				if (existing != null) {
-					// If the peer reports a different `cwd` than we last saw, the agent moved
-					// (peer fired a `CwdChanged` event we don't receive locally). Pick up the new
-					// cwd AND reset our local `gitInfoUnresolvable` flag — the new cwd might be a
-					// git repo even if the previous one wasn't.
-					const cwdChanged = peerSession.cwd != null && existing.cwd !== peerSession.cwd;
-					if (cwdChanged && this._sessionBookkeeping.get(peerSession.id)?.gitInfoUnresolvable) {
-						this.getBookkeeping(peerSession.id).gitInfoUnresolvable = false;
-					}
-
-					if (peerActivity > existing.lastActivity) {
-						const idx = this._sessions.indexOf(existing);
-						// A terminal row the peer now reports live IS a resume the peer owns. Mirror the
-						// poll/SessionStart revive paths: take the peer's pid (retaining the terminal
-						// record's dead — and possibly reused — pid would let dispatch focus an unrelated
-						// process) and mark it peer-owned so opens route through the peer's IPC.
-						const revivedFromEnded = existing.status === 'ended';
-						// Peer is the authoritative hook recipient for this session, so wipe any
-						// local bookkeeping that survived from a previous local-ownership window.
-						// Without this, refcounts/timers from a prior local-hosting stretch would
-						// resurface stale paths if ownership ever flips back to us.
-						const bk = this._sessionBookkeeping.get(peerSession.id);
-						if (bk != null) {
-							this.cancelPendingFileClears(bk);
-							this.cancelPendingReadClears(bk);
-							bk.currentFileCounts.clear();
-							bk.currentReadCounts.clear();
-							bk.lastTouchedAt.clear();
-						}
-						this._sessions[idx] = {
-							...existing,
-							status: peerSession.status,
-							phase: peerSession.phase,
-							phaseSince: peerPhaseSince,
-							statusDetail: peerSession.statusDetail,
-							lastActivity: peerActivity,
-							// A locally-routable ask wins — a blocking ask fans out to every window, so we
-							// may hold the hook entry the peer lacks. Otherwise mirror the peer's ask marked
-							// unresolvable (we have no entry to answer it), and clear it when the peer did.
-							pendingPermission:
-								this._sessionBookkeeping.get(peerSession.id)?.pendingPermission ??
-								(peerSession.pendingPermission != null
-									? { ...peerSession.pendingPermission, resolvable: false }
-									: undefined),
-							...(revivedFromEnded ? { pid: peerSession.pid, isPeerOwned: true } : undefined),
-							subagents: rehydrateSubagents(peerSession.subagents),
-							// Carry the peer's published fileActivity across so peer-window WIP
-							// decorations + treemap heatmap follow the agent. Owned by the peer (it's
-							// the hook recipient); we never originate this field for a remote session.
-							fileActivity: peerSession.fileActivity,
-							// Track the peer's resolved repo identity. The peer owns the hook flow and
-							// re-resolves both on `CwdChanged`, so a worktree move (e.g. the agent
-							// `cd`'d into a sibling worktree of the same repo — `commonPath` unchanged
-							// but `worktreePath` changed) only reaches us if we carry BOTH. Carrying
-							// `commonPath` alone froze the displayed worktree at first-discovery.
-							worktreePath: peerSession.worktreePath ?? existing.worktreePath,
-							visitedWorktreePaths: unionVisitedAppendOnly(
-								existing.visitedWorktreePaths,
-								peerSession.visitedWorktreePaths,
-							),
-							commonPath: peerSession.commonPath ?? existing.commonPath,
-							// Pick up the peer's latest cwd so our backfill probe (queued below)
-							// targets the right path. Stale-cwd locally would just re-probe the
-							// non-repo dir and hit the gitInfoUnresolvable retry guard again.
-							cwd: cwdChanged ? peerSession.cwd : existing.cwd,
-							// Launch-state fields are immutable per session: prefer whichever side
-							// already set them (peer that owns the hook flow typically sets first),
-							// and never overwrite a populated local value with the peer's.
-							initialCwd: existing.initialCwd ?? peerSession.initialCwd,
-							initialWorktreePath: existing.initialWorktreePath ?? peerSession.initialWorktreePath,
-							initialCommonPath: existing.initialCommonPath ?? peerSession.initialCommonPath,
-							// The hook path, when present, carries richer un-truncated prompts than what a
-							// peer forwards — prefer our own value over the peer's.
-							lastPrompt: existing.lastPrompt ?? peerSession.lastPrompt,
-							firstPrompt: existing.firstPrompt ?? peerSession.firstPrompt,
-							// Forward peer-discovered transcript titles. Both windows can resolve them
-							// independently against the same on-disk transcript, but only the peer's
-							// hook flow drives its updates — without this, we'd freeze the snapshot
-							// taken at first discovery.
-							transcriptTitles: peerSession.transcriptTitles ?? existing.transcriptTitles,
-						};
-						changed = true;
-					}
-				} else {
-					this._sessions.push({
-						...peerSession,
-						lastActivity: peerActivity,
-						phaseSince: peerPhaseSince,
-						// The peer owns the hook entry, so an imported ask can never be routed from here.
-						pendingPermission:
-							peerSession.pendingPermission != null
-								? { ...peerSession.pendingPermission, resolvable: false }
-								: undefined,
-						workspacePath: normalizeWorkspacePath(peerSession.workspacePath),
-						isInWorkspace: this.matchesWorkspace(peerSession.workspacePath),
-						subagents: rehydrateSubagents(peerSession.subagents),
-						// Override whatever the peer published — this is OUR ownership view: the peer
-						// (or some other window) hosts the live session, not us. Drives the dispatcher
-						// to route opens through the peer's IPC + OS-level window focus instead of
-						// calling `claude-vscode.editor.open` locally (which would just open an inert
-						// view in our window).
-						isPeerOwned: true,
-					});
-					changed = true;
-				}
-
-				// Queue a local resolveGitInfo for any peer session that arrived without a
-				// commonPath but has a cwd — we can fill it in from our own git registry. Skip
-				// if our own bookkeeping already marked this session's cwd unresolvable (we tried
-				// locally and the cwd isn't a git repo from our vantage point either).
-				const merged = this._sessions.find(s => s.id === peerSession.id);
-				if (
-					merged?.commonPath == null &&
-					merged?.cwd != null &&
-					!this.getBookkeeping(merged.id).gitInfoUnresolvable
-				) {
-					sessionsNeedingResolve.set(merged.id, merged.cwd);
-				}
-			}
-		}
-
-		if (changed) {
-			this._onDidChangeSessions.fire();
-		}
-
-		// Backfill commonPath for peer-synced sessions whose owning peer didn't populate it.
-		// `resolveGitInfo` is idempotent — only mutates + fires if it actually finds new info,
-		// so the worst case here is a few wasted git probes for unresolvable cwds.
-		for (const [id, cwd] of sessionsNeedingResolve) {
-			void this.resolveGitInfo(id, cwd);
-		}
-	}
-
-	private async fetchPeerSessions(
-		path: string,
-		ownPort: number | undefined,
-	): Promise<SerializedAgentSession[] | undefined> {
-		let discovery: DiscoveryFile;
-		try {
-			discovery = JSON.parse(await readFile(path, 'utf8')) as DiscoveryFile;
-		} catch {
-			return undefined;
-		}
-		if (ownPort != null && discovery.port === ownPort) return undefined;
-
-		try {
-			const response = await fetch(`${discovery.address}/agents/sessions/list`, {
-				method: 'POST',
-				headers: { Authorization: `Bearer ${discovery.token}`, 'Content-Type': 'application/json' },
-				body: '{}',
-				signal: AbortSignal.timeout(2000),
-			});
-			if (!response.ok) return undefined;
-			return (await response.json()) as SerializedAgentSession[];
-		} catch {
-			return undefined;
-		}
-	}
-
-	/** Find the peer GitLens window whose discovery file claims `workspacePath`, and POST to its
-	 *  `/agents/sessions/open` route to ask its Claude Code extension to open the session.
-	 *
-	 *  Resolves to `true` when at least one peer claimed the workspace AND was reachable (the POST
-	 *  completed with any HTTP status). The peer's response shape (`{ opened: boolean }`) is logged
-	 *  for diagnostics but does NOT affect the return value — an `opened: false` peer is still the
-	 *  right window for the caller to focus, since it's the window that owns the session. Resolves
-	 *  to `false` when no peer claimed the workspace OR every claimer was unreachable; the caller
-	 *  treats that as "no peer to focus" and opens a new window instead of replacing the current
-	 *  one. Best-effort: swallows scan, JSON-parse errors. */
-	async notifyPeerOpenSession(workspacePath: string, sessionId: string): Promise<boolean> {
-		const discoveryDir = this.callbacks.ipc.agentDiscoveryDir;
-		if (discoveryDir == null) return false;
-
-		const target = normalizePath(workspacePath);
-		const ownPort = this.callbacks.ipc.port;
-
-		let files: string[];
-		try {
-			files = await readdir(discoveryDir);
-		} catch {
-			return false;
-		}
-
-		const results = await Promise.all(
-			files
-				.filter(f => f.startsWith('gitlens-ipc-server-') && f.endsWith('.json'))
-				.map(async f => {
-					let discovery: DiscoveryFile;
-					try {
-						discovery = JSON.parse(await readFile(join(discoveryDir, f), 'utf8')) as DiscoveryFile;
-					} catch {
-						return false;
-					}
-					if (ownPort != null && discovery.port === ownPort) return false;
-					// Symmetric prefix containment — same shape as `matchesWorkspace()` above.
-					// Strict equality misses the common case where the dispatcher passes a `cwd`
-					// inside the peer's workspace folder (or, less commonly, a parent dir that
-					// contains the peer's workspace).
-					if (
-						!discovery.workspacePaths?.some(p => {
-							const normalized = normalizePath(p);
-							return (
-								normalized === target ||
-								target.startsWith(`${normalized}/`) ||
-								normalized.startsWith(`${target}/`)
-							);
-						})
-					) {
-						return false;
-					}
-
-					try {
-						const response = await fetch(`${discovery.address}/agents/sessions/open`, {
-							method: 'POST',
-							headers: {
-								Authorization: `Bearer ${discovery.token}`,
-								'Content-Type': 'application/json',
-							},
-							body: JSON.stringify({ sessionId: sessionId }),
-							signal: AbortSignal.timeout(2000),
-						});
-						if (!response.ok) {
-							Logger.warn(
-								`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} returned ${response.status}`,
-							);
-						} else {
-							// Log a peer that failed to open the specific session, but still treat it
-							// as a reachable claimer of the workspace — focusing that window is still
-							// what the user wants.
-							const body = (await response.json().catch(() => undefined)) as
-								| { opened?: boolean }
-								| undefined;
-							if (body?.opened === false) {
-								Logger.warn(
-									`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} could not open session ${sessionId}`,
-								);
-							}
-						}
-						return true;
-					} catch (ex) {
-						// Peer advertised but unreachable (timeout, RST, etc.). Treat as no match so
-						// the caller opens a new window instead of trying to focus a dead window.
-						Logger.warn(
-							`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} unreachable: ${
-								ex instanceof Error ? ex.message : String(ex)
-							}`,
-						);
-						return false;
-					}
-				}),
-		);
-
-		return results.some(Boolean);
-	}
-}