@gitkraken/core-gitlens 0.5.113 → 0.5.114

package/src/plus/agents/providers/{claudeCodeProvider.ts → gkAgentProvider.ts}

@@ -5,7 +5,16 @@ 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 { normalizePath } from '../../../utils/path.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,
@@ -21,23 +30,29 @@ import {
 import type {
 	AgentProviderCallbacks,
 	AgentSession,
+	AgentSessionHistoryItem,
+	AgentSessionHistoryOptions,
+	AgentSessionHistoryResult,
 	AgentSessionPhase,
 	AgentSessionProvider,
+	AgentSessionResumeOutcome,
+	AgentSessionResumeTarget,
 	AgentSessionStatus,
-	ClaudeCodeHookEvent,
+	LiveAgentSession,
 	PendingPermission,
 	PendingPermissionKind,
 	PermissionDecision,
 	PermissionSuggestion,
-	ResumableAgentSession,
-	ResumableSessionsOptions,
-	ResumableSessionsResult,
 } from '../types.js';
 import { getPhaseForStatus } from '../types.js';
+import type { EndedTranscriptDetails } from './claudeCodeTranscript.js';
 import { ClaudeCodeTranscriptReader } from './claudeCodeTranscript.js';
 
 interface AgentSessionEvent {
-	event: ClaudeCodeHookEvent;
+	/** 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. */
@@ -130,14 +145,19 @@ interface SessionBookkeeping {
 	 *  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
-	 *  completed-session removal: a session the live `SessionEnd` path just transitioned is never
+	 *  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;
-	/** Set once a completed session's transcript has been read on demand (via
-	 *  `resolveCompletedSessionDetails`). Terminal transcripts don't change, so the read happens at
+	/** 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. */
-	completedDetailsResolved?: boolean;
+	endedDetailsResolved?: boolean;
 }
 
 const staleCheckIntervalMs = 15 * 60 * 1000; // 15 minutes
@@ -146,21 +166,21 @@ const staleCheckIntervalMs = 15 * 60 * 1000; // 15 minutes
  *  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-completed row is protected from absence-based removal. The CLI persists the
+/** 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 completed will list it — this guards only against that ordering changing on the CLI
- *  side, where the cost of being wrong is a completed row silently vanishing. */
-const completedRemovalGraceMs = 30 * 1000; // 30 seconds
+ *  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. `getPastSessions` asks for it once per worktree on panel open, so without
+ *  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
-/** Completed sessions defer git + transcript resolution (a 30-day cold-start would otherwise fan out
+/** 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 recentCompletedGitResolveThresholdMs = 24 * 60 * 60 * 1000; // 24 hours
+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`
@@ -182,13 +202,19 @@ 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 completed sessions attach to branch cards / WIP rows / the resume picker at
+	 *  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[];
@@ -205,12 +231,12 @@ interface SessionFileData {
 	prompt?: string | null;
 	firstPrompt?: string | null;
 	/** CLI durable-session lifecycle status. Absent on legacy files → treated as `active`. `ended`
-	 *  records are surfaced as terminal `completed` sessions; `archived` is excluded by the query. */
+	 *  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 completed rows. */
+	/** RFC3339 timestamp the session ended; used as `lastActivity`/`phaseSince` for ended rows. */
 	endedAt?: string;
 }
 
@@ -240,6 +266,125 @@ function worktreeFromEvent(event: AgentSessionEvent): string | 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
@@ -310,6 +455,10 @@ interface DiscoveryFile {
 }
 
 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;
@@ -322,6 +471,8 @@ interface SessionContext {
 	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'> & {
@@ -373,6 +524,67 @@ function fileActivityStructurallyEqual(
 	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. */
@@ -381,10 +593,14 @@ function isUnknownFlagError(ex: unknown): boolean {
 	return /unknown (?:flag|shorthand flag|command)/i.test(message);
 }
 
-export class ClaudeCodeProvider implements AgentSessionProvider {
-	readonly id = 'claudeCode';
-	readonly name = 'Claude Code';
+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;
@@ -411,16 +627,20 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	private _staleCheckTimer: UnifiedDisposable | undefined;
 	/** When the last poll actually ran (gated or not) — paces the idle cadence above. */
 	private _lastSyncAt = 0;
-	/** Whether Claude hooks are installed, pushed by the host via {@link setClaudeHooksInstalled}.
+	/** 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 _claudeHooksInstalled = true;
+	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,
-	 *  completed rows are untenable — no poll can ever confirm or archive one — so `SessionEnd`
-	 *  reverts to removing the session and reconciliation drops any completed stragglers. */
+	 *  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) {}
 
@@ -428,6 +648,20 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		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();
@@ -482,15 +716,13 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			// Re-publish so the agents discovery file reflects the new workspacePaths.
 			this.callbacks.ipc
 				.publishAgents(this._workspacePaths)
-				.catch((ex: unknown) =>
-					Logger.error(ex, 'ClaudeCodeProvider.updateWorkspacePaths: publishAgents failed'),
-				);
+				.catch((ex: unknown) => Logger.error(ex, 'GkAgentProvider.updateWorkspacePaths: publishAgents failed'));
 		}
 	}
 
-	setClaudeHooksInstalled(installed: boolean): void {
-		const wasOff = !this._claudeHooksInstalled;
-		this._claudeHooksInstalled = installed;
+	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:
@@ -502,26 +734,114 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 	}
 
-	/** Reads past sessions out of Claude's transcript store. Claude homes each transcript under the
-	 *  directory encoding the session's current cwd (migrating it if the session `cd`s), so the
-	 *  directory for `cwd` is exactly what `claude --resume <id>` can find when invoked from there —
-	 *  every session returned is resumable from `cwd`. */
-	async listResumableSessions(cwd: string, options?: ResumableSessionsOptions): Promise<ResumableSessionsResult> {
-		const { sessions, total } = await this._transcriptReader.listSessions(cwd, {
-			limit: options?.limit,
-			excludeSessionIds: options?.excludeSessionIds,
-		});
+	/** 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 resumable = sessions.map<ResumableAgentSession>(s => ({
-			id: s.sessionId,
-			providerId: this.id,
-			cwd: cwd,
-			lastActivity: new Date(s.lastActivityMs),
-			titles: s.titles,
-			lastPrompt: s.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: resumable, total: total };
+		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 {
@@ -557,7 +877,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		this.dispose();
 	}
 
-	@gate<typeof ClaudeCodeProvider.prototype.ensureIpcServer>()
+	@gate<typeof GkAgentProvider.prototype.ensureIpcServer>()
 	private async ensureIpcServer(): Promise<void> {
 		if (this._ipcStarted || this._disposed) return;
 
@@ -572,11 +892,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			}),
 			this.callbacks.ipc.registerHandler('agents/sessions/list', () =>
 				Promise.resolve(
-					// Exclude terminal `completed` rows: an older-version peer has no `completed` phase and
-					// would import them as phantom "idle" sessions. Our own poll surfaces completed sessions
+					// 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 !== 'completed')
+						.filter(s => s.status !== 'ended')
 						.map(s => ({
 							...s,
 							lastActivity: s.lastActivity.toISOString(),
@@ -600,7 +920,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					return { opened: true };
 				} catch (ex) {
 					Logger.warn(
-						`ClaudeCodeProvider.agents/sessions/open: ${ex instanceof Error ? ex.message : String(ex)}`,
+						`GkAgentProvider.agents/sessions/open: ${ex instanceof Error ? ex.message : String(ex)}`,
 					);
 					return { opened: false };
 				}
@@ -614,7 +934,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			for (const d of handlers) {
 				d.dispose();
 			}
-			Logger.error(ex, 'ClaudeCodeProvider.ensureIpcServer');
+			Logger.error(ex, 'GkAgentProvider.ensureIpcServer');
 			return;
 		}
 
@@ -649,21 +969,40 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				staleCheckIntervalMs,
 			);
 		} catch (ex) {
-			Logger.error(ex, 'ClaudeCodeProvider.ensureIpcServer');
+			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. Absent = accept: older CLIs
-		// don't stamp it. A dropped blocking request gets no decision, so the CLI waits out its own
-		// hook timeout — correct, since we must not answer for an agent we don't track.
-		if (event.providerId != null && event.providerId !== 'claude-code') {
-			Logger.debug(`ClaudeCodeProvider.handleSessionEvent: ignoring ${event.event} from ${event.providerId}`);
+		// 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,
@@ -673,18 +1012,21 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			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 (event.event === 'SessionStart' || event.event === 'SessionEnd') {
-			Logger.info(`ClaudeCodeProvider.handleSessionEvent: ${event.event} ${tag}`);
+		if (hookEvent === 'SessionStart' || hookEvent === 'SessionEnd') {
+			Logger.info(`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}`);
 		} else {
 			Logger.debug(
-				`ClaudeCodeProvider.handleSessionEvent: ${event.event} ${tag}${event.toolName ? ` tool=${event.toolName}` : ''}${event.agentId ? ` agent=${event.agentId}` : ''}${event.notificationType ? ` type=${event.notificationType}` : ''}`,
+				`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}${toolName ? ` tool=${toolName}` : ''}${event.agentId ? ` agent=${event.agentId}` : ''}${event.notificationType ? ` type=${event.notificationType}` : ''}`,
 			);
 		}
 
-		switch (event.event) {
+		switch (hookEvent) {
 			case 'SessionStart': {
 				const wasNew = this._sessions.findIndex(s => s.id === event.sessionId) < 0;
 				const { index } = this.ensureSession(event.sessionId, eventContext);
@@ -701,10 +1043,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					}
 				} else {
 					const prev = this._sessions[index];
-					if (prev.status === 'completed') {
-						// Resuming a terminal session reuses its id, so a SessionStart on a completed
+					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
-						// completed/archivable state) with clean bookkeeping that completeSession tore
+						// 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
@@ -730,7 +1072,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 				this._onDidChangeSessions.fire();
 				void this.resolveTranscriptTitles(event.sessionId, event.cwd);
-				this.callbacks.onSessionStarted?.(this.id);
+				this.callbacks.onSessionStarted?.(capabilities.providerId);
 				break;
 			}
 
@@ -745,12 +1087,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				const index = this._sessions.findIndex(s => s.id === event.sessionId);
 				if (index >= 0) {
 					if (this._statusFilterSupported) {
-						// Transition to a terminal `completed` row rather than removing it — completed
+						// 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.completeSession(index, new Date());
+						this.endSession(index, new Date());
 					} else {
-						// Legacy CLI (no `--status` durable store): a completed row could never be
-						// poll-confirmed nor archived, so keep the pre-completed remove-on-end behavior.
+						// 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) {
@@ -759,6 +1101,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						}
 						this._sessionBookkeeping.delete(event.sessionId);
 						this._transcriptReader.forget(event.sessionId);
+						this.noteTerminalTransition();
 					}
 					this._onDidChangeSessions.fire();
 				} else {
@@ -772,8 +1115,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					}
 					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?.(this.id);
+				this.callbacks.onSessionEnded?.(capabilities.providerId);
 				break;
 			}
 
@@ -806,15 +1152,14 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			case 'PreToolUse': {
 				const bk = this.getBookkeeping(event.sessionId);
 				bk.activeToolCount++;
-				const filesChanged = this.trackToolUseFile(event.sessionId, event);
-				const readsChanged = this.trackToolUseRead(event.sessionId, event);
+				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 hookInput = event.hookInput;
-				const toolInput = (hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
-				const toolName = (hookInput?.tool_name as string | undefined) ?? event.toolName ?? '';
+				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
@@ -836,7 +1181,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 			case 'PostToolUse':
 			case 'PostToolUseFailure': {
-				this.clearStalePermission(event.sessionId, event.event, this.settledByFromEvent(event));
+				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
@@ -845,8 +1190,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				// `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);
-				const readsChanged = this.scheduleClearToolUseRead(event.sessionId, event);
+				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
@@ -909,9 +1254,9 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					case 'permission_prompt':
 						this.updateSessionStatus(event.sessionId, 'permission_requested', {
 							...eventContext,
-							statusDetail: event.toolName,
+							statusDetail: toolName,
 							pendingPermission: synthesizeUnresolvableAsk(
-								event.toolName,
+								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,
@@ -924,11 +1269,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// hook produces.
 						this.updateSessionStatus(event.sessionId, 'permission_requested', {
 							...eventContext,
-							statusDetail: event.toolName,
+							statusDetail: toolName,
 							pendingPermission: {
 								kind: 'elicitation',
-								toolName: event.toolName ?? 'Input Required',
-								toolDescription: event.toolName ?? 'Waiting for input',
+								toolName: toolName ?? 'Input Required',
+								toolDescription: toolName ?? 'Waiting for input',
 								resolvable: false,
 							},
 						});
@@ -943,11 +1288,14 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				// 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;
-				if (isBlocking && toolInput != null) {
-					const toolName = (hookInput?.tool_name as string | undefined) ?? event.toolName ?? '';
-					const toolDescription = describeToolInput(toolName, 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(toolName);
+					const kind: PendingPermissionKind = classifyPermissionKind(askToolName);
 					const toolUseId = hookInput?.tool_use_id as string | undefined;
 					const toolInputJson = stableStringify(toolInput);
 
@@ -960,7 +1308,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							((existing.toolUseId != null && toolUseId != null && existing.toolUseId === toolUseId) ||
 								(existing.toolUseId == null &&
 									toolUseId == null &&
-									existing.toolName === toolName &&
+									existing.toolName === askToolName &&
 									existing.toolInputJson === toolInputJson));
 
 						if (isDuplicateDelivery) {
@@ -976,7 +1324,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 						if (existing != null) {
 							Logger.debug(
-								`ClaudeCodeProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`,
+								`GkAgentProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`,
 							);
 							this.resolveAllPending(existing, {
 								hookSpecificOutput: {
@@ -988,7 +1336,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 						this._pendingPermissions.set(event.sessionId, {
 							resolvers: [{ resolve: resolve, reject: reject }],
-							toolName: toolName,
+							toolName: askToolName,
 							toolDescription: toolDescription,
 							toolUseId: toolUseId,
 							toolInputJson: toolInputJson,
@@ -1005,7 +1353,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 						const permission: PendingPermission = {
 							kind: kind,
-							toolName: toolName,
+							toolName: askToolName,
 							toolDescription: toolDescription,
 							toolInputDescription: toolInputDescription,
 							suggestions:
@@ -1023,7 +1371,6 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				{
 					// 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 toolName = (hookInput?.tool_name as string | undefined) ?? event.toolName;
 					const kind = toolName != null ? classifyPermissionKind(toolName) : undefined;
 					// Plan-kind body: same session-first preference as the blocking path.
 					const planFilePath =
@@ -1051,7 +1398,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							: synthesizeUnresolvableAsk(toolName, planFilePath);
 					this.updateSessionStatus(event.sessionId, 'permission_requested', {
 						...eventContext,
-						statusDetail: event.toolName,
+						statusDetail: toolName,
 						pendingPermission: synthesized,
 					});
 				}
@@ -1059,11 +1406,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			}
 
 			case 'PermissionDenied': {
-				this.clearStalePermission(event.sessionId, 'PermissionDenied', this.settledByFromEvent(event));
+				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);
-				const readsChanged = this.untrackToolUseRead(event.sessionId, event);
+				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).
@@ -1082,15 +1433,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				const bk = this.getBookkeeping(event.sessionId);
 				bk.pendingPermission = {
 					kind: 'elicitation',
-					toolName: event.toolName ?? 'Input Required',
-					toolDescription: event.toolName ?? 'Waiting for input',
+					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: event.toolName,
+					statusDetail: toolName,
 				});
 				break;
 			}
@@ -1127,8 +1478,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					const now = new Date();
 					const subagent: AgentSession = {
 						id: event.agentId,
-						providerId: this.id,
-						providerName: this.name,
+						providerId: capabilities.providerId,
+						providerName: capabilities.displayName,
 						name: event.agentType ?? 'Subagent',
 						status: 'thinking',
 						phase: 'working',
@@ -1181,6 +1532,22 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			: `[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) {
@@ -1294,8 +1661,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	 *  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): string | undefined {
-		const toolName = (event.hookInput?.tool_name as string | undefined) ?? event.toolName;
+	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;
@@ -1335,8 +1702,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	 *  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): boolean {
-		const filePath = this.getEventFilePath(event);
+	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);
@@ -1360,8 +1727,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	 *  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): boolean {
-		const filePath = this.getEventFilePath(event);
+	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);
@@ -1418,8 +1789,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	/** 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): boolean {
-		const filePath = this.getEventFilePath(event);
+	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);
@@ -1441,8 +1812,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	/** Mirror of {@link getEventFilePath} for read-only file tools. */
-	private getEventReadPath(event: AgentSessionEvent): string | undefined {
-		const toolName = (event.hookInput?.tool_name as string | undefined) ?? event.toolName;
+	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;
@@ -1452,8 +1823,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	/** Refcount mirror of {@link trackToolUseFile} for read-only file tools. */
-	private trackToolUseRead(sessionId: string, event: AgentSessionEvent): boolean {
-		const filePath = this.getEventReadPath(event);
+	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);
@@ -1469,8 +1840,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 	/** 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): boolean {
-		const filePath = this.getEventReadPath(event);
+	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);
@@ -1515,8 +1890,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	/** Immediate-drop mirror of {@link untrackToolUseFile} for read-only file tools. */
-	private untrackToolUseRead(sessionId: string, event: AgentSessionEvent): boolean {
-		const filePath = this.getEventReadPath(event);
+	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);
@@ -1560,6 +1935,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		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 };
@@ -1637,10 +2014,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		this.cancelPendingIdleTransition(sessionId);
 		const timer = setTimeout(() => {
 			this._pendingIdleTimers.delete(sessionId);
-			// Session may have been removed (SessionEnd, prune) during the window, or completed by a
+			// 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 === 'completed') return;
+			if (idx < 0 || this._sessions[idx].status === 'ended') return;
 
 			this.updateSessionStatus(sessionId, 'idle');
 		}, stopToIdleDebounceMs);
@@ -1683,7 +2060,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	 *  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): {
+	private settledByFromEvent(
+		event: AgentSessionEvent,
+		capabilities: AgentCapabilities,
+	): {
 		toolUseId?: string;
 		toolName?: string;
 		toolInputJson?: string;
@@ -1692,7 +2072,9 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		const toolInput = (hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
 		return {
 			toolUseId: hookInput?.tool_use_id as string | undefined,
-			toolName: (hookInput?.tool_name as string | undefined) ?? event.toolName,
+			// 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,
 		};
 	}
@@ -1751,13 +2133,13 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 				if (mismatch) {
 					Logger.debug(
-						`ClaudeCodeProvider.clearStalePermission: skip (identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${pending.toolUseId ?? pending.toolName} settledBy=${settledBy.toolUseId ?? settledBy.toolName ?? 'unknown'}`,
+						`GkAgentProvider.clearStalePermission: skip (identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${pending.toolUseId ?? pending.toolName} settledBy=${settledBy.toolUseId ?? settledBy.toolName ?? 'unknown'}`,
 					);
 					return;
 				}
 			}
 
-			Logger.debug(`ClaudeCodeProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
+			Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
 			this.resolveAllPending(pending, {
 				hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny' } },
 			});
@@ -1774,12 +2156,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			settledBy.toolName !== bk.pendingPermission.toolName
 		) {
 			Logger.debug(
-				`ClaudeCodeProvider.clearStalePermission: skip (display-only identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${bk.pendingPermission.toolName} settledBy=${settledBy.toolName}`,
+				`GkAgentProvider.clearStalePermission: skip (display-only identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${bk.pendingPermission.toolName} settledBy=${settledBy.toolName}`,
 			);
 			return;
 		}
 
-		Logger.debug(`ClaudeCodeProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
+		Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
 		bk.pendingPermission = undefined;
 	}
 
@@ -1788,11 +2170,22 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		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(
-			`ClaudeCodeProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`,
+			`GkAgentProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`,
 		);
 		this.resolveAllPending(pending, {
 			hookSpecificOutput: {
@@ -1801,7 +2194,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			},
 		});
 		this.callbacks.onPermissionResolved?.({
-			provider: this.id,
+			provider: capabilities?.providerId ?? claudeCodeCapabilities.providerId,
 			tool: pending.toolName,
 			decision: decision,
 		});
@@ -1817,19 +2210,19 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 	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 `completed` since the click) must never
+		// 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 !== 'completed') {
+		if (session != null && session.status !== 'ended') {
 			Logger.warn(
-				`ClaudeCodeProvider.archiveSession: refusing to archive non-completed ${this.sessionTag(sessionId)} (status=${session.status})`,
+				`GkAgentProvider.archiveSession: refusing to archive non-ended ${this.sessionTag(sessionId)} (status=${session.status})`,
 			);
 			return false;
 		}
 
-		Logger.debug(`ClaudeCodeProvider.archiveSession: ${this.sessionTag(sessionId)}`);
+		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;
@@ -1877,37 +2270,70 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 	}
 
-	resolveCompletedSessionDetails(sessionId: string): void {
+	resolveEndedSessionDetails(sessionId: string): void {
 		const session = this._sessions.find(s => s.id === sessionId);
-		// Only completed sessions defer resolution; live sessions resolve eagerly on discovery.
-		if (session?.status !== 'completed') return;
+		// 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.completedDetailsResolved) return;
+		if (bk.endedDetailsResolved) return;
 
-		bk.completedDetailsResolved = true;
+		bk.endedDetailsResolved = true;
 
 		if (session.cwd) {
 			void this.resolveGitInfo(sessionId, session.cwd);
 		}
-		void this.applyCompletedTranscriptDetails(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);
+		}
 	}
 
-	private async applyCompletedTranscriptDetails(sessionId: string, cwd: string | undefined): Promise<void> {
+	/** 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.resolveCompletedDetails(sessionId, cwd);
+			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.completedDetailsResolved = false;
+				bk.endedDetailsResolved = false;
 			}
 			return;
 		}
@@ -1918,7 +2344,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 		const session = this._sessions[index];
 		// The session may have been archived/removed while we were reading.
-		if (session.status !== 'completed') return;
+		if (session.status !== 'ended') return;
 
 		const { titles } = details;
 		const nextTitles =
@@ -2069,8 +2495,19 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	private ensureSession(sessionId: string, context?: SessionContext): { index: number; changed: boolean } {
-		const { pid, workspacePath, isInWorkspace, cwd, initialCwd, planFile, sessionName, model, worktreePath } =
-			context ?? {};
+		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) {
@@ -2078,11 +2515,16 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			// 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: this.id,
-				providerName: this.name,
+				providerId: identity.providerId,
+				providerName: identity.displayName,
 				name: sessionName || undefined,
 				status: 'idle',
 				phase: getPhaseForStatus('idle'),
@@ -2097,9 +2539,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				isInWorkspace: createdWorkspacePath != null ? true : (isInWorkspace ?? false),
 				model: model,
 				worktreePath: worktreePath != null ? normalizePath(worktreePath) : undefined,
+				visitedWorktreePaths: unionVisited(undefined, visitedWorktreePaths, worktreePath),
 			});
 			Logger.debug(
-				`ClaudeCodeProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`,
+				`GkAgentProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`,
 			);
 			if (worktreePath != null) {
 				this.getBookkeeping(sessionId).cliSeatedWorktree = true;
@@ -2129,6 +2572,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// 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.
@@ -2162,7 +2610,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			updatedModel !== existing.model ||
 			updatedCwd !== existing.cwd ||
 			updatedInitialCwd !== existing.initialCwd ||
-			updatedWorktreePath !== existing.worktreePath
+			updatedWorktreePath !== existing.worktreePath ||
+			updatedVisitedWorktreePaths !== existing.visitedWorktreePaths
 		) {
 			this._sessions[index] = {
 				...existing,
@@ -2175,6 +2624,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				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
@@ -2204,7 +2654,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// 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.
-		const locationNeedsProbe = cwdMoved && (worktreePath == null || worktreeMoved || existing.worktreePath == null);
+		//
+		// 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;
 		}
@@ -2246,10 +2701,14 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		this._resolveGitInfoInFlight.set(sessionId, cwd);
 		try {
 			let info: Awaited<ReturnType<typeof resolveGitInfo>> | undefined;
+			let failed = false;
 			try {
 				info = await resolveGitInfo(cwd);
 			} catch {
-				// Git not available or not a git repo — fall through to mark unresolvable below
+				// 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;
 			}
 
@@ -2261,6 +2720,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			// 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
@@ -2278,8 +2739,51 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			// followed by a new session start).
 			if (info == null) {
 				this.getBookkeeping(sessionId).gitInfoUnresolvable = true;
-				if (cwd !== session.cwd) {
-					this._sessions[index] = { ...session, cwd: cwd };
+
+				// 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;
@@ -2316,6 +2820,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					commonPath: info.repoRoot,
 					initialWorktreePath: updatedInitialWorktreePath,
 					initialCommonPath: updatedInitialCommonPath,
+					visitedWorktreePaths: unionVisited(session.visitedWorktreePaths, effectiveWorktreePath),
 				};
 				this._onDidChangeSessions.fire();
 			}
@@ -2333,6 +2838,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	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);
@@ -2355,25 +2864,22 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		this._onDidChangeSessions.fire();
 	}
 
-	/** Transitions the session at `index` to the terminal `completed` state in place: keeps the row,
+	/** 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 completeSession(index: number, endedAt: Date): void {
+	private endSession(index: number, endedAt: Date): void {
 		const prev = this._sessions[index];
 		this._sessions[index] = {
 			...prev,
-			status: 'completed',
-			phase: 'completed',
+			status: 'ended',
+			phase: 'ended',
 			phaseSince: endedAt,
 			lastActivity: endedAt,
 			statusDetail: undefined,
 			pendingPermission: undefined,
 			subagents: undefined,
-			// A terminal row carries no live working state — drop the file-activity heatmap so
-			// consumers reading it directly don't render a frozen tail for a finished session.
-			fileActivity: 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
@@ -2382,7 +2888,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// live zombie).
 		const pending = this._pendingPermissions.get(prev.id);
 		if (pending != null) {
-			this.rejectAllPending(pending, new Error('Session completed'));
+			this.rejectAllPending(pending, new Error('Session ended'));
 			this._pendingPermissions.delete(prev.id);
 		}
 		this.cancelPendingIdleTransition(prev.id);
@@ -2394,15 +2900,30 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 		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) {
-			// Completed sessions are terminal and durable — their PID is usually dead by design, so
+			// 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 === 'completed') {
+			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;
 			}
@@ -2438,8 +2959,9 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			this._sessionBookkeeping.delete(id);
 			this._transcriptReader.forget(id);
 		}
+		this.noteTerminalTransition();
 		Logger.debug(
-			`ClaudeCodeProvider.syncSessions: removed ${removedIds.length} stale session(s): ${removedIds.map(id => id.substring(0, 8)).join(', ')}`,
+			`GkAgentProvider.syncSessions: removed ${removedIds.length} stale session(s): ${removedIds.map(id => id.substring(0, 8)).join(', ')}`,
 		);
 		return true;
 	}
@@ -2451,13 +2973,13 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// 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, completed included. A completed row is something
+		// 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._claudeHooksInstalled) return;
+		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
@@ -2467,16 +2989,16 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// session whose hook events never reached our IPC server.
 		if (
 			options?.gate &&
-			!this._claudeHooksInstalled &&
-			!this._sessions.some(s => s.status !== 'completed') &&
+			!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 completed the row" from "an in-flight poll that predates it" — see the
-		// completed-removal filter.
+		// 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;
 
@@ -2486,7 +3008,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			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 completed sessions at all.
+				// is required to see ended sessions at all.
 				output = await this.callbacks.runCLICommand([
 					'ai',
 					'hook',
@@ -2506,7 +3028,13 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				output = await this.callbacks.runCLICommand(['ai', 'hook', 'list-sessions', '--json']);
 			}
 			sessions = JSON.parse(output) as SessionFileData[];
-		} catch {
+		} 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();
 			}
@@ -2516,27 +3044,66 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// 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; completed sessions are durable history, so their
+		// 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.
-		const trackedLiveBefore = new Set(this._sessions.filter(s => s.status !== 'completed').map(s => s.id));
-		const polledAlive = new Set<string>();
-		// Every id the poll returned (live *and* completed). Drives completed-session reconciliation:
-		// a tracked completed session absent from this set was archived/purged by the CLI.
+		//
+		// 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;
-		let discovered = 0;
+		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;
 
-			// Another AI host's record in the CLI's shared store. Must stay ahead of `polledIds`/
-			// `polledAlive`: an id in either would skew completed-row reconciliation and the
-			// `onSyncDiscrepancy` drift signal below.
-			if (data.providerId != null && data.providerId !== 'claude-code') 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';
 
@@ -2546,42 +3113,119 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			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) {
-					// Already tracked. If the live path missed the SessionEnd (e.g. `/clear` kept the
-					// PID alive under a new id), transition it to completed now — otherwise a live-status
-					// row would linger as a zombie, since pruneDeadSessions can't reap a live PID.
-					if (this._sessions[existingIndex].status !== 'completed') {
-						this.completeSession(existingIndex, endedDate);
+					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 the record's location. The durable record is authoritative for a
-					// terminal session, and a `CwdChanged` hook we never received would otherwise leave the
-					// card attached to the wrong worktree — and "Open Session" resuming from a stale
-					// directory. Deliberately limited to location: prompts/titles have their own on-demand
-					// transcript resolution, which holds richer values than the record does.
+					// 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 worktreeRoot = worktreeRootFromData(data);
-					const cwdChanged = Boolean(data.cwd) && data.cwd !== existing.cwd;
+					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
-					// change is a discrete event, so that's one probe, not the cold-start fan-out the
-					// completed path exists to avoid.
-					const nextWorktreePath =
-						worktreeRoot != null
-							? normalizePath(worktreeRoot)
-							: cwdChanged
+					// 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(data.cwd || existing.cwd);
+						const workspacePath = this.resolveWorkspacePath(currentCwd);
 						this._sessions[existingIndex] = {
 							...existing,
-							cwd: data.cwd || existing.cwd,
+							cwd: currentCwd,
 							initialCwd: existing.initialCwd ?? data.initialCwd ?? data.cwd,
 							worktreePath: nextWorktreePath,
 							workspacePath: workspacePath,
@@ -2591,38 +3235,132 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							// 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), so resolve the new cwd
-						// once rather than leaving the row location-less.
-						if (nextWorktreePath == null && data.cwd) {
-							void this.resolveGitInfo(data.sessionId, data.cwd);
+						// 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);
 						}
 					}
 
-					this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
+					// 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(data.cwd);
-				const worktreeRoot = worktreeRootFromData(data);
+				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: this.id,
-					providerName: this.name,
+					providerId: capabilities.providerId,
+					providerName: capabilities.displayName,
 					name: data.sessionName || undefined,
-					status: 'completed',
-					phase: 'completed',
+					status: 'ended',
+					phase: 'ended',
 					phaseSince: endedDate,
 					pid: data.pid,
 					lastActivity: endedDate,
 					isSubagent: false,
 					workspacePath: workspacePath,
-					// Read straight from the CLI's durable record so completed sessions attach to branch
+					// 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: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
+					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,
@@ -2637,14 +3375,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				});
 				this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
 				changed = true;
-				// Titles/prompts still resolve lazily via resolveCompletedSessionDetails (a 30-day
+				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 (
-					worktreeRoot == null &&
+					recordWorktreeRoot == null &&
 					data.cwd &&
-					Date.now() - endedDate.getTime() < recentCompletedGitResolveThresholdMs
+					Date.now() - endedDate.getTime() < recentEndedGitResolveThresholdMs
 				) {
 					void this.resolveGitInfo(data.sessionId, data.cwd);
 				}
@@ -2654,7 +3393,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			// Active / legacy (absent-status) path — only genuinely-live processes are discoverable.
 			if (!data.pid || !isProcessAlive(data.pid)) continue;
 
-			polledAlive.add(data.sessionId);
+			polledAlive.set(data.sessionId, capabilities.providerId);
 			polledIds.add(data.sessionId);
 
 			if (known.has(data.sessionId)) {
@@ -2665,18 +3404,34 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					// 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(data.event);
-					if (existing.status === 'completed') {
-						// We hold it as `completed` but the CLI now reports it as a live process (a
+					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→completed transition above. Leave genuinely-live
+						// 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 completion. `SessionEnd` fires
+						// 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 completed row.
+						// 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
@@ -2684,12 +3439,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// the row shows what it's waiting on instead of an empty "Needs input" card.
 						const revivedPendingPermission =
 							polledStatus === 'permission_requested'
-								? synthesizeUnresolvableAsk(data.toolName, data.planFile ?? undefined)
+								? 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 completed.
+						// 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 completed row's attribution. A
+						// 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.
@@ -2717,10 +3472,16 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 								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 completed to
+							// No longer terminal: leaving these set makes the row read as ended to
 							// consumers that key off them.
 							endReason: undefined,
 							endedAt: undefined,
@@ -2729,7 +3490,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// The record's worktree is the CLI's own resolution; without one the probe owns
 						// attribution again.
 						this.getBookkeeping(data.sessionId).cliSeatedWorktree = revivedWorktreeRoot != null;
-						if (data.cwd != null && data.cwd !== existing.cwd) {
+						// 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;
@@ -2749,11 +3515,29 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							// 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' ? (data.toolName ?? undefined) : undefined,
+							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
@@ -2770,23 +3554,44 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 			const workspacePath = this.resolveWorkspacePath(data.cwd);
 			const isInWorkspace = workspacePath != null;
-			const status = deriveStatusFromEvent(data.event);
-			const phase = getPhaseForStatus(status);
 			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(data.toolName, data.planFile ?? undefined)
+					? 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 completed-session push below.
+			// 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: this.id,
-				providerName: this.name,
+				providerId: capabilities.providerId,
+				providerName: capabilities.displayName,
 				name: sub.agentType ?? 'Subagent',
 				status: 'thinking',
 				phase: 'working' as const,
@@ -2799,12 +3604,12 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 			this._sessions.push({
 				id: data.sessionId,
-				providerId: this.id,
-				providerName: this.name,
+				providerId: capabilities.providerId,
+				providerName: capabilities.displayName,
 				name: data.sessionName || undefined,
 				status: status,
 				phase: phase,
-				phaseSince: activityDate,
+				phaseSince: phaseSince,
 				pid: data.pid,
 				lastActivity: activityDate,
 				isSubagent: false,
@@ -2822,9 +3627,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				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;
-			discovered++;
+			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
@@ -2836,36 +3647,44 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			void this.resolveTranscriptTitles(data.sessionId, data.cwd);
 		}
 
-		// The poll is authoritative for completed-session removal (archived elsewhere or 30-day-purged).
+		// 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 a completed row, so the guard would
+		// 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 staleCompleted = this._sessions.filter(
+		const staleEnded = this._sessions.filter(
 			s =>
-				s.status === 'completed' &&
+				s.status === 'ended' &&
 				!polledIds.has(s.id) &&
 				(!this._statusFilterSupported ||
 					this._sessionBookkeeping.get(s.id)?.polledAtLeastOnce === true ||
-					// Or this poll's snapshot postdates the completion, so its absence is authoritative.
+					// 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
-					// `completeSession` drops the bookkeeping — so without this the row is unremovable for
+					// `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-completed row out of reach of
+					// 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 - completedRemovalGraceMs),
+					s.phaseSince.getTime() < pollStartedAt - endedRemovalGraceMs),
 		);
-		if (staleCompleted.length > 0) {
-			const staleIds = new Set(staleCompleted.map(s => s.id));
+		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 staleCompleted) {
+			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;
 		}
@@ -2880,20 +3699,38 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// 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) {
-			let missing = 0;
-			for (const id of trackedLiveBefore) {
+			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)) {
-					missing++;
+					drift.missing++;
 				}
 			}
-			if (discovered > 0 || missing > 0) {
-				this.callbacks.onSyncDiscrepancy?.({
-					provider: this.id,
-					discovered: discovered,
-					missing: missing,
-					polled: polledAlive.size,
-					tracked: trackedLiveBefore.size,
-				});
+			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 });
 			}
 		}
 	}
@@ -2930,17 +3767,18 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			if (peerSessions == null) continue;
 
 			for (const peerSession of peerSessions) {
-				// Skip terminal rows a peer published: completed sessions live in the machine-global CLI
+				// 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.
-				if (peerSession.status === 'completed') continue;
+				// 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);
 
-				const existing = this._sessions.find(s => s.id === peerSession.id);
-
 				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
@@ -2957,7 +3795,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// 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 revivedFromCompleted = existing.status === 'completed';
+						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
@@ -2985,7 +3823,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 								(peerSession.pendingPermission != null
 									? { ...peerSession.pendingPermission, resolvable: false }
 									: undefined),
-							...(revivedFromCompleted ? { pid: peerSession.pid, isPeerOwned: true } : 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
@@ -2997,6 +3835,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							// 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
@@ -3008,6 +3850,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							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
@@ -3156,7 +4002,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						});
 						if (!response.ok) {
 							Logger.warn(
-								`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} returned ${response.status}`,
+								`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} returned ${response.status}`,
 							);
 						} else {
 							// Log a peer that failed to open the specific session, but still treat it
@@ -3167,7 +4013,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 								| undefined;
 							if (body?.opened === false) {
 								Logger.warn(
-									`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} could not open session ${sessionId}`,
+									`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} could not open session ${sessionId}`,
 								);
 							}
 						}
@@ -3176,7 +4022,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// 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(
-							`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} unreachable: ${
+							`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} unreachable: ${
 								ex instanceof Error ? ex.message : String(ex)
 							}`,
 						);