@gitkraken/core-gitlens 0.5.110 → 0.5.111

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

@@ -39,6 +39,9 @@ import { ClaudeCodeTranscriptReader } from './claudeCodeTranscript.js';
 interface AgentSessionEvent {
 	event: ClaudeCodeHookEvent;
 	sessionId: string;
+	/** `gk ai hook` client id of the originating host (`claude-code`, `codex`, …) — NOT
+	 *  `AgentSession.providerId`. Absent on older CLIs. */
+	providerId?: string;
 	cwd: string;
 	/** The agent's launch directory, captured first-hand by the CLI and preserved across events.
 	 *  Optional — older CLIs don't send it, in which case consumers fall back to deriving it from
@@ -59,6 +62,10 @@ interface AgentSessionEvent {
 	toolInput?: Record<string, unknown>;
 	permissionSuggestions?: PermissionSuggestion[];
 	hookInput?: Record<string, unknown>;
+	/** CLI-resolved worktree roots for this session's cwd visits, newest last — same shape as
+	 *  {@link SessionFileData.cwdTimeline}. The CLI runs `rev-parse` at hook time and includes this
+	 *  on every event, even though it isn't part of the raw hook payload. */
+	cwdTimeline?: { cwd: string; worktree?: string; at?: string }[];
 }
 
 interface PermissionResponse {
@@ -72,10 +79,15 @@ interface PermissionResponse {
 }
 
 interface PendingPermissionEntry {
-	resolve(response: PermissionResponse): void;
-	reject(reason: Error): void;
+	/** All connections waiting on this ask — duplicate deliveries (CLI retry after its 60s
+	 *  response-header timeout) attach here and settle together. */
+	resolvers: { resolve(response: PermissionResponse): void; reject(reason: Error): void }[];
 	toolName: string;
 	toolDescription: string;
+	/** From `hookInput.tool_use_id` when the CLI surfaces it; identity gate for stale-clearing. */
+	toolUseId?: string;
+	/** Serialized tool_input, for duplicate-delivery detection when `toolUseId` is absent. */
+	toolInputJson?: string;
 }
 
 interface SessionBookkeeping {
@@ -107,13 +119,48 @@ interface SessionBookkeeping {
 	 *  every subsequent hook event. Cleared when the session's cwd changes (re-resolution
 	 *  warranted) or on resetBookkeeping (Stop/SessionStart). */
 	gitInfoUnresolvable: boolean;
+	/** Set while the session's `worktreePath` came from the CLI (an event's `cwdTimeline`, or a poll
+	 *  record's). The CLI resolves the worktree for the exact cwd at hook time; the local probe answers
+	 *  for whichever repo the host registry matches, which for a nested cwd can be the parent worktree.
+	 *  While set, `resolveGitInfo` keeps the seated value instead of overwriting it. Cleared when the
+	 *  cwd moves without the CLI explaining the new location — attribution goes back to the probe. */
+	cliSeatedWorktree?: boolean;
 	/** Phase that immediately preceded the current one, with its original `phaseSince`. Used by
 	 *  `resolvePhaseSince` to restore continuity when phase oscillates back within a short
 	 *  window (e.g., Stop → idle → working after a continuation crosses the debounce). */
 	priorPhase?: { phase: AgentSessionPhase; phaseSince: Date };
+	/** Set once the reconciliation poll has seen this session's durable `ended` record. Gates
+	 *  completed-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
+	 *  most once regardless of how many times the row is opened. */
+	completedDetailsResolved?: boolean;
 }
 
 const staleCheckIntervalMs = 15 * 60 * 1000; // 15 minutes
+/** Minimum spacing between gated reconciliation polls while NOTHING is running. The quarter-hourly
+ *  tick exists to reap agents that died without a `SessionEnd`; with no live session there's nothing
+ *  to reap, leaving only terminal-history reconciliation and the CLI's retention sweep — both fine
+ *  hourly. Window startup polls ungated, so this never delays a fresh window. */
+const idleReconcileIntervalMs = 60 * 60 * 1000; // 1 hour
+/** How long a freshly-completed 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
+/** 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
+ *  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
+ *  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
 /** 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`
@@ -133,10 +180,18 @@ const phaseSinceRestoreWindowMs = 2000;
 
 interface SessionFileData {
 	sessionId: string;
+	/** `gk ai hook` client id of the owning host — see {@link AgentSessionEvent.providerId}. */
+	providerId?: string;
 	event: string;
 	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
+	 *  any age without a git probe (the CLI already ran `rev-parse` at hook time). */
+	cwdTimeline?: { cwd: string; worktree?: string; at?: string }[];
+	worktrees?: string[];
 	pid: number;
 	toolName?: string | null;
 	agentId?: string | null;
@@ -149,6 +204,102 @@ interface SessionFileData {
 	sessionName?: string | null;
 	prompt?: string | null;
 	firstPrompt?: string | null;
+	/** CLI durable-session lifecycle status. Absent on legacy files → treated as `active`. `ended`
+	 *  records are surfaced as terminal `completed` 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. */
+	endedAt?: string;
+}
+
+/** The session's current worktree root from the CLI's durable record — the last cwd-visit's resolved
+ *  worktree, falling back to the last distinct worktree seen. `undefined` on older CLIs that don't
+ *  record it, so the caller resolves git the slow way instead. */
+function worktreeRootFromData(data: SessionFileData): string | undefined {
+	const fromTimeline = data.cwdTimeline?.at(-1)?.worktree;
+	if (fromTimeline) return fromTimeline;
+
+	return data.worktrees?.at(-1) || undefined;
+}
+
+/** The CLI resolves the worktree for `event.cwd` at hook time and includes it on every event —
+ *  using its answer seats `worktreePath` synchronously, closing the in-flight-probe window where
+ *  a session that just moved would otherwise still show its previous worktree until `resolveGitInfo`
+ *  catches up. Scans from the end for the timeline entry matching the event's current cwd. */
+function worktreeFromEvent(event: AgentSessionEvent): string | undefined {
+	const timeline = event.cwdTimeline;
+	if (timeline == null) return undefined;
+
+	for (let i = timeline.length - 1; i >= 0; i--) {
+		const entry = timeline[i];
+		if (entry.cwd === event.cwd) return entry.worktree || undefined;
+	}
+
+	return undefined;
+}
+
+/** Synthesizes an unresolvable ask for a `permission_requested` row that has no routable
+ *  `PendingPermission` — a non-blocking `Notification`/`PermissionRequest` tail, or a
+ *  poll-discovered live/revived row. None of these hold a blocking hook entry to route an
+ *  Allow/Deny through, so the card must show what the agent is waiting on without offering
+ *  actions the host can't fulfill. */
+function synthesizeUnresolvableAsk(toolName: string | null | undefined, planFilePath?: string): PendingPermission {
+	if (toolName != null) {
+		const kind = classifyPermissionKind(toolName);
+		return {
+			kind: kind,
+			toolName: toolName,
+			toolDescription: toolName,
+			// A plan ask with no body at least links the plan the agent wrote, so the card can offer
+			// View Plan instead of a bare tool name.
+			planFilePath: kind === 'plan' ? planFilePath : undefined,
+			resolvable: false,
+		};
+	}
+
+	return {
+		kind: 'elicitation',
+		toolName: 'Input Required',
+		toolDescription: 'Waiting for input',
+		resolvable: false,
+	};
+}
+
+/** JSON.stringify with object keys recursively sorted — array order is preserved. `tool_input`
+ *  can arrive with different key order (or via the top-level fallback field) between deliveries;
+ *  canonicalizing makes input equality reliable across those variations. */
+function stableStringify(value: unknown): string {
+	return JSON.stringify(value, (_key, val: unknown) => {
+		if (val == null || typeof val !== 'object' || Array.isArray(val)) return val;
+
+		const sorted: Record<string, unknown> = {};
+		for (const key of Object.keys(val).sort()) {
+			sorted[key] = (val as Record<string, unknown>)[key];
+		}
+		return sorted;
+	});
+}
+
+/** Field-wise equality for the ask a `permission_requested` row publishes. `updateSessionStatus`
+ *  compares it before short-circuiting so a second ask arriving while the row is already
+ *  `permission_requested` (a non-blocking tail for a different tool) still reaches subscribers. */
+function isSameAsk(a: PendingPermission | undefined, b: PendingPermission | undefined): boolean {
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+
+	return (
+		a.kind === b.kind &&
+		a.toolName === b.toolName &&
+		a.toolDescription === b.toolDescription &&
+		a.toolInputDescription === b.toolInputDescription &&
+		a.resolvable === b.resolvable &&
+		a.planFilePath === b.planFilePath &&
+		a.planSummary === b.planSummary &&
+		a.questionText === b.questionText &&
+		a.questionCount === b.questionCount
+	);
 }
 
 interface DiscoveryFile {
@@ -167,6 +318,10 @@ interface SessionContext {
 	initialCwd?: string;
 	planFile?: string;
 	sessionName?: string;
+	/** The model the session is running, from the hook event. */
+	model?: string;
+	/** CLI-resolved worktree root for the current cwd (authoritative when present). */
+	worktreePath?: string;
 }
 
 type SerializedAgentSession = Omit<AgentSession, 'lastActivity' | 'phaseSince' | 'subagents'> & {
@@ -218,6 +373,14 @@ function fileActivityStructurallyEqual(
 	return true;
 }
 
+/** True when a CLI invocation failed because it didn't recognize a flag/command. `--status` and the
+ *  active-only `list-sessions` default shipped together (gk 3.1.69); an older CLI rejects `--status`
+ *  and returns all sessions unfiltered, so the flagless retry is the correct legacy equivalent. */
+function isUnknownFlagError(ex: unknown): boolean {
+	const message = ex instanceof Error ? ex.message : String(ex);
+	return /unknown (?:flag|shorthand flag|command)/i.test(message);
+}
+
 export class ClaudeCodeProvider implements AgentSessionProvider {
 	readonly id = 'claudeCode';
 	readonly name = 'Claude Code';
@@ -231,17 +394,32 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	private _disposed = false;
 	private _handlerDisposables: UnifiedDisposable[] = [];
 	private readonly _pendingPermissions = new Map<string, PendingPermissionEntry>();
-	private readonly _resolveGitInfoInFlight = new Set<string>();
+	/** `sessionId -> cwd currently being probed`, and the newest cwd requested while that probe runs.
+	 *  A probe's answer is only valid for the cwd it was started with, so a session that moves
+	 *  mid-flight must supersede rather than dedupe — otherwise the older lookup lands last and
+	 *  overwrites the newer location with the directory the session already left. */
+	private readonly _resolveGitInfoInFlight = new Map<string, string>();
+	private readonly _resolveGitInfoPending = new Map<string, string>();
+	/** Short-TTL cache of the machine-global archived-session id list. Holds the in-flight promise so
+	 *  concurrent per-worktree `getPastSessions` calls share one CLI spawn; `archiveSession` clears it. */
+	private _archivedSessionIdsCache: { promise: Promise<string[]>; at: number } | undefined;
 	private readonly _sessionBookkeeping = new Map<string, SessionBookkeeping>();
 	/** Per-session timers for the deferred `Stop → idle` commit. The handle is cleared (and the
 	 *  transition cancelled) by any non-idle status update arriving before the timer fires. */
 	private readonly _pendingIdleTimers = new Map<string, NodeJS.Timeout>();
 	private _workspacePaths: string[] = [];
 	private _staleCheckTimer: UnifiedDisposable | undefined;
+	/** When the last poll actually ran (gated or not) — paces the idle cadence above. */
+	private _lastSyncAt = 0;
 	/** Whether Claude hooks are installed, pushed by the host via {@link setClaudeHooksInstalled}.
 	 *  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;
+	/** 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. */
+	private _statusFilterSupported = true;
 	protected _transcriptReader: ClaudeCodeTranscriptReader = new ClaudeCodeTranscriptReader();
 
 	constructor(private readonly callbacks: AgentProviderCallbacks) {}
@@ -259,6 +437,10 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// IPC server stays up intentionally — hooks fire even when the window is unfocused
 	}
 
+	sync(): Promise<void> {
+		return this.syncSessions();
+	}
+
 	updateWorkspacePaths(workspacePaths: string[]): void {
 		this._workspacePaths = workspacePaths.map(p => normalizePath(p));
 
@@ -352,7 +534,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 		this._handlerDisposables = [];
 		for (const pending of this._pendingPermissions.values()) {
-			pending.reject(new Error('Provider disposed'));
+			this.rejectAllPending(pending, new Error('Provider disposed'));
 		}
 		this._pendingPermissions.clear();
 		for (const bk of this._sessionBookkeeping.values()) {
@@ -390,16 +572,21 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			}),
 			this.callbacks.ipc.registerHandler('agents/sessions/list', () =>
 				Promise.resolve(
-					this._sessions.map(s => ({
-						...s,
-						lastActivity: s.lastActivity.toISOString(),
-						phaseSince: s.phaseSince.toISOString(),
-						subagents: s.subagents?.map(sub => ({
-							...sub,
-							lastActivity: sub.lastActivity.toISOString(),
-							phaseSince: sub.phaseSince.toISOString(),
+					// 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
+					// independently, so peers never need them from here.
+					this._sessions
+						.filter(s => s.status !== 'completed')
+						.map(s => ({
+							...s,
+							lastActivity: s.lastActivity.toISOString(),
+							phaseSince: s.phaseSince.toISOString(),
+							subagents: s.subagents?.map(sub => ({
+								...sub,
+								lastActivity: sub.lastActivity.toISOString(),
+								phaseSince: sub.phaseSince.toISOString(),
+							})),
 						})),
-					})),
 				),
 			),
 			this.callbacks.ipc.registerHandler('agents/sessions/open', async request => {
@@ -467,6 +654,14 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	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}`);
+			return Promise.resolve();
+		}
+
 		const workspacePath = this.resolveWorkspacePath(event.cwd);
 		const eventContext: SessionContext = {
 			pid: event.pid,
@@ -476,6 +671,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			initialCwd: event.initialCwd,
 			planFile: event.planFile,
 			sessionName: event.sessionName,
+			model: event.model,
+			worktreePath: worktreeFromEvent(event),
 		};
 		const tag = this.sessionTag(event.sessionId, event.sessionName ?? 'unnamed');
 
@@ -503,11 +700,30 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						}
 					}
 				} else {
-					// SessionStart for a session we already track is almost always a CLI replay
-					// (resume/reconnect/hook re-init). Don't clobber live state — the next real
-					// event will re-establish status. Refresh pid only.
 					const prev = this._sessions[index];
-					if (event.pid != null && event.pid !== prev.pid) {
+					if (prev.status === 'completed') {
+						// Resuming a terminal session reuses its id, so a SessionStart on a completed
+						// row IS the resume signal — revive it to a live `idle` row (clearing the
+						// completed/archivable state) with clean bookkeeping that completeSession tore
+						// down. The next real event advances it out of idle. A `SessionStart` arrives on
+						// THIS window's hook flow, so the resume is locally owned now: clear the peer
+						// ownership carried over from the terminal record, and take the resume's pid
+						// (never the old terminal/reused one — retaining it would let dispatch focus a
+						// stale or unrelated process).
+						this._sessions[index] = {
+							...prev,
+							status: 'idle',
+							phase: 'idle',
+							phaseSince: new Date(),
+							lastActivity: new Date(),
+							pid: event.pid,
+							isPeerOwned: undefined,
+						};
+						this.resetBookkeeping(event.sessionId);
+					} else if (event.pid != null && event.pid !== prev.pid) {
+						// SessionStart for a live session we already track is almost always a CLI
+						// replay (resume/reconnect/hook re-init). Don't clobber live state — the next
+						// real event re-establishes status. Refresh pid only.
 						this._sessions[index] = { ...prev, pid: event.pid, lastActivity: new Date() };
 					}
 				}
@@ -521,30 +737,54 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			case 'SessionEnd': {
 				const pending = this._pendingPermissions.get(event.sessionId);
 				if (pending != null) {
-					pending.reject(new Error('Session ended'));
+					this.rejectAllPending(pending, new Error('Session ended'));
 					this._pendingPermissions.delete(event.sessionId);
 				}
 				this.cancelPendingIdleTransition(event.sessionId);
 
 				const index = this._sessions.findIndex(s => s.id === event.sessionId);
 				if (index >= 0) {
-					this._sessions.splice(index, 1);
+					if (this._statusFilterSupported) {
+						// Transition to a terminal `completed` row rather than removing it — completed
+						// sessions stay visible (de-emphasized) until archived or 30-day-purged by the CLI.
+						this.completeSession(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.
+						this._sessions.splice(index, 1);
+						const bk = this._sessionBookkeeping.get(event.sessionId);
+						if (bk != null) {
+							this.cancelPendingFileClears(bk);
+							this.cancelPendingReadClears(bk);
+						}
+						this._sessionBookkeeping.delete(event.sessionId);
+						this._transcriptReader.forget(event.sessionId);
+					}
 					this._onDidChangeSessions.fire();
+				} else {
+					// SessionEnd for a session we no longer track (already pruned/removed, or a duplicate
+					// end): still clear any bookkeeping timers + transcript cache the row left behind, so
+					// they don't leak. The tracked branches above already tear this down themselves.
+					const bk = this._sessionBookkeeping.get(event.sessionId);
+					if (bk != null) {
+						this.cancelPendingFileClears(bk);
+						this.cancelPendingReadClears(bk);
+					}
+					this._sessionBookkeeping.delete(event.sessionId);
+					this._transcriptReader.forget(event.sessionId);
 				}
-				const bk = this._sessionBookkeeping.get(event.sessionId);
-				if (bk != null) {
-					this.cancelPendingFileClears(bk);
-					this.cancelPendingReadClears(bk);
-				}
-
-				this._sessionBookkeeping.delete(event.sessionId);
-				this._transcriptReader.forget(event.sessionId);
 				this.callbacks.onSessionEnded?.(this.id);
 				break;
 			}
 
 			case 'UserPromptSubmit': {
-				const { index } = this.ensureSession(event.sessionId, eventContext);
+				const { index, changed } = this.ensureSession(event.sessionId, eventContext);
+				// Seated metadata (location, model, name) has to reach subscribers even when the prompt
+				// turns out to be synthetic and the status update below never runs.
+				if (changed) {
+					this._onDidChangeSessions.fire();
+				}
+
 				const cleaned = prepareStoredPrompt(event.prompt);
 				// A `UserPromptSubmit` whose payload sanitizes to nothing is harness-synthetic
 				// (e.g. background-bash <task-notification>, slash-command stdout echo). Treat it
@@ -596,7 +836,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 			case 'PostToolUse':
 			case 'PostToolUseFailure': {
-				this.clearStalePermission(event.sessionId, event.event);
+				this.clearStalePermission(event.sessionId, event.event, this.settledByFromEvent(event));
 				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
@@ -631,7 +871,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			case 'StopFailure': {
 				const pending = this._pendingPermissions.get(event.sessionId);
 				if (pending != null) {
-					pending.reject(new Error('Session stopped'));
+					this.rejectAllPending(pending, new Error('Session stopped'));
 					this._pendingPermissions.delete(event.sessionId);
 				}
 				// Turn ended: stop the "live" pulse but keep the per-operation decay tail fading over
@@ -667,10 +907,30 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						// No-op — session is already idle from the preceding stop/session-start event
 						break;
 					case 'permission_prompt':
+						this.updateSessionStatus(event.sessionId, 'permission_requested', {
+							...eventContext,
+							statusDetail: event.toolName,
+							pendingPermission: synthesizeUnresolvableAsk(
+								event.toolName,
+								// Plan-kind body: prefer the session's planFile, fall back to the event's
+								// — mirrors the blocking path.
+								this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile,
+							),
+						});
+						break;
 					case 'elicitation_dialog':
+						// An MCP elicitation, not a tool permission — `toolName` names the elicitation, so
+						// classifying it as a tool ask would mislabel the card. Same shape the `Elicitation`
+						// hook produces.
 						this.updateSessionStatus(event.sessionId, 'permission_requested', {
 							...eventContext,
 							statusDetail: event.toolName,
+							pendingPermission: {
+								kind: 'elicitation',
+								toolName: event.toolName ?? 'Input Required',
+								toolDescription: event.toolName ?? 'Waiting for input',
+								resolvable: false,
+							},
 						});
 						break;
 					default:
@@ -688,14 +948,37 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					const toolDescription = describeToolInput(toolName, toolInput);
 					const toolInputDescription = (toolInput.description as string | undefined) || undefined;
 					const kind: PendingPermissionKind = classifyPermissionKind(toolName);
+					const toolUseId = hookInput?.tool_use_id as string | undefined;
+					const toolInputJson = stableStringify(toolInput);
 
 					return new Promise<PermissionResponse>((resolve, reject) => {
 						const existing = this._pendingPermissions.get(event.sessionId);
+						// Same identity as `settledByFromEvent`'s comparisons: `toolUseId` when both sides
+						// have one, else toolName + canonical input.
+						const isDuplicateDelivery =
+							existing != null &&
+							((existing.toolUseId != null && toolUseId != null && existing.toolUseId === toolUseId) ||
+								(existing.toolUseId == null &&
+									toolUseId == null &&
+									existing.toolName === toolName &&
+									existing.toolInputJson === toolInputJson));
+
+						if (isDuplicateDelivery) {
+							// Duplicate delivery of the same ask (CLI retry after its 60s response-header
+							// timeout) — attach instead of replacing so both connections settle together.
+							// Nothing about the display changes, so skip rebuilding it below. Accepted
+							// residual: two independent, identical, concurrent asks are byte-for-byte
+							// indistinguishable on the wire and coalesce the same way, receiving one
+							// decision — evicting instead would falsely deny a live ask.
+							existing.resolvers.push({ resolve: resolve, reject: reject });
+							return;
+						}
+
 						if (existing != null) {
 							Logger.debug(
 								`ClaudeCodeProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`,
 							);
-							existing.resolve({
+							this.resolveAllPending(existing, {
 								hookSpecificOutput: {
 									hookEventName: 'PermissionRequest',
 									decision: { behavior: 'deny' },
@@ -704,10 +987,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						}
 
 						this._pendingPermissions.set(event.sessionId, {
-							resolve: resolve,
-							reject: reject,
+							resolvers: [{ resolve: resolve, reject: reject }],
 							toolName: toolName,
 							toolDescription: toolDescription,
+							toolUseId: toolUseId,
+							toolInputJson: toolInputJson,
 						});
 
 						// Plan-kind body: prefer the existing session's planFile (set via SessionStart/
@@ -732,19 +1016,50 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							questionText: questionDetails?.text,
 							questionCount: questionDetails?.count,
 						};
-						this.updateSessionWithPermission(event.sessionId, permission, event.pid);
+						this.updateSessionWithPermission(event.sessionId, permission, eventContext);
 					});
 				}
 
-				this.updateSessionStatus(event.sessionId, 'permission_requested', {
-					...eventContext,
-					statusDetail: event.toolName,
-				});
+				{
+					// 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 =
+						kind === 'plan'
+							? (this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile)
+							: undefined;
+					// Same body extraction as the blocking path — surfaces render `questionText`/
+					// `planSummary` in place of the tool description, so omitting them would show a
+					// generic "awaiting" card for a question the input actually carries.
+					const questionDetails =
+						kind === 'question' && toolInput != null ? extractQuestionDetails(toolInput) : undefined;
+					const synthesized: PendingPermission =
+						kind != null && toolName != null && toolInput != null
+							? {
+									kind: kind,
+									toolName: toolName,
+									toolDescription: describeToolInput(toolName, toolInput),
+									toolInputDescription: (toolInput.description as string | undefined) || undefined,
+									planFilePath: planFilePath,
+									planSummary: kind === 'plan' ? extractPlanSummary(toolInput) : undefined,
+									questionText: questionDetails?.text,
+									questionCount: questionDetails?.count,
+									resolvable: false,
+								}
+							: synthesizeUnresolvableAsk(toolName, planFilePath);
+					this.updateSessionStatus(event.sessionId, 'permission_requested', {
+						...eventContext,
+						statusDetail: event.toolName,
+						pendingPermission: synthesized,
+					});
+				}
 				break;
 			}
 
 			case 'PermissionDenied': {
-				this.clearStalePermission(event.sessionId, 'PermissionDenied');
+				this.clearStalePermission(event.sessionId, 'PermissionDenied', this.settledByFromEvent(event));
 				const bk = this.getBookkeeping(event.sessionId);
 				bk.activeToolCount = Math.max(0, bk.activeToolCount - 1);
 				const filesChanged = this.untrackToolUseFile(event.sessionId, event);
@@ -769,6 +1084,9 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					kind: 'elicitation',
 					toolName: event.toolName ?? 'Input Required',
 					toolDescription: event.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,
@@ -790,16 +1108,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 			case 'CwdChanged':
 				if (event.cwd) {
-					const index = this._sessions.findIndex(s => s.id === event.sessionId);
-					if (index >= 0 && this._sessions[index].cwd !== event.cwd) {
-						this._sessions[index] = { ...this._sessions[index], cwd: event.cwd };
+					// Route through `ensureSession`: it owns the whole location transition — timeline
+					// seat (or handing attribution back to the probe when the CLI didn't explain the
+					// move), workspacePath/isInWorkspace recompute, the unresolvable-flag clear, and
+					// the probe gating. Writing `cwd` directly here left `cliSeatedWorktree` set, so
+					// the probe's answer for the new cwd could never replace the stale seated one.
+					const { changed } = this.ensureSession(event.sessionId, eventContext);
+					if (changed) {
 						this._onDidChangeSessions.fire();
 					}
-					// Clear the unresolvable flag so the new cwd actually gets re-probed — without
-					// this, a session that started in a non-git cwd would stay flagged forever even
-					// after moving into a git repo.
-					this.getBookkeeping(event.sessionId).gitInfoUnresolvable = false;
-					void this.resolveGitInfo(event.sessionId, event.cwd);
 				}
 				break;
 
@@ -918,6 +1235,8 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		bk.currentReadCounts.clear();
 		bk.lastTouchedAt.clear();
 		bk.gitInfoUnresolvable = false;
+		// `cliSeatedWorktree` deliberately survives: SessionStart seats the worktree via
+		// `ensureSession` BEFORE resetting bookkeeping, and an unexplained cwd move clears it anyway.
 		const parentId = this.findOwningParentId(sessionId);
 		if (parentId != null) {
 			this.syncSessionFileActivity(parentId);
@@ -1318,8 +1637,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.
-			if (this._sessions.findIndex(s => s.id === sessionId) < 0) return;
+			// Session may have been removed (SessionEnd, prune) during the window, or completed 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;
 
 			this.updateSessionStatus(sessionId, 'idle');
 		}, stopToIdleDebounceMs);
@@ -1358,22 +1679,107 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		return now;
 	}
 
+	/** Extracts the ask identity a settlement event refers to. `PostToolUse`/`PermissionDenied`
+	 *  carry `hookInput.tool_use_id` and `hookInput.tool_input` in production; the top-level
+	 *  `event.toolName`/`event.toolInput` are the older-CLI fallback. Input is canonicalized so key
+	 *  order (or arriving via the fallback field instead of `hookInput`) doesn't defeat comparison. */
+	private settledByFromEvent(event: AgentSessionEvent): {
+		toolUseId?: string;
+		toolName?: string;
+		toolInputJson?: string;
+	} {
+		const hookInput = event.hookInput;
+		const toolInput = (hookInput?.tool_input as Record<string, unknown> | undefined) ?? event.toolInput;
+		return {
+			toolUseId: hookInput?.tool_use_id as string | undefined,
+			toolName: (hookInput?.tool_name as string | undefined) ?? event.toolName,
+			toolInputJson: toolInput != null ? stableStringify(toolInput) : undefined,
+		};
+	}
+
+	private resolveAllPending(entry: PendingPermissionEntry, response: PermissionResponse): void {
+		for (const resolver of entry.resolvers) {
+			resolver.resolve(response);
+		}
+	}
+
+	private rejectAllPending(entry: PendingPermissionEntry, reason: Error): void {
+		for (const resolver of entry.resolvers) {
+			resolver.reject(reason);
+		}
+	}
+
 	// Called when a pending permission was resolved outside GitLens (e.g. via the CLI terminal).
 	// The 'deny' response is a safe no-op since the tool has already run or been denied upstream.
-	private clearStalePermission(sessionId: string, reason: string): void {
+	// `settledBy` identifies the ask the settling event actually refers to — out-of-order/duplicate
+	// hook deliveries (PostToolUse for an unrelated tool, a PermissionDenied for an already-evicted
+	// earlier ask) must never deny a still-live blocking ask just because it shares a session id.
+	// `PermissionDenied` itself only ever fires after Claude Code's auto-mode classifier denies a
+	// tool call — never as an echo of a deny a `PermissionRequest` response sent.
+	private clearStalePermission(
+		sessionId: string,
+		reason: string,
+		settledBy?: { toolUseId?: string; toolName?: string; toolInputJson?: string },
+	): void {
 		const bk = this.getBookkeeping(sessionId);
-		if (bk.pendingPermission == null) return;
-
-		Logger.debug(`ClaudeCodeProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
-
 		const pending = this._pendingPermissions.get(sessionId);
+
 		if (pending != null) {
-			pending.resolve({
+			if (settledBy != null) {
+				let mismatch = false;
+
+				if (pending.toolUseId != null && settledBy.toolUseId != null) {
+					// Rule 1: both sides identified — the only trustworthy comparison. `PermissionDenied`/
+					// `PostToolUse` hookInput DOES carry `tool_use_id`, but `PermissionRequest` never does,
+					// so `pending` never actually has one — this branch only engages if a future CLI adds
+					// it to requests too. The asymmetry is deliberate, not a gap to close.
+					mismatch = pending.toolUseId !== settledBy.toolUseId;
+				} else if (pending.toolName === '') {
+					// Rule 2: no identity was captured at registration (degraded payload) — nothing to
+					// gate on, so clear unconditionally rather than stranding the ask forever.
+					mismatch = false;
+				} else {
+					// Rule 3: name must match; when both sides have input, it must match too. A
+					// PostToolUse for a different invocation of the same tool (different input) leaves
+					// the ask untouched.
+					mismatch =
+						settledBy.toolName !== pending.toolName ||
+						(pending.toolInputJson != null &&
+							settledBy.toolInputJson != null &&
+							pending.toolInputJson !== settledBy.toolInputJson);
+				}
+
+				if (mismatch) {
+					Logger.debug(
+						`ClaudeCodeProvider.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)}`);
+			this.resolveAllPending(pending, {
 				hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny' } },
 			});
 			this._pendingPermissions.delete(sessionId);
+			bk.pendingPermission = undefined;
+			return;
 		}
 
+		if (bk.pendingPermission == null) return;
+
+		if (
+			settledBy?.toolName != null &&
+			bk.pendingPermission.toolName != null &&
+			settledBy.toolName !== bk.pendingPermission.toolName
+		) {
+			Logger.debug(
+				`ClaudeCodeProvider.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)}`);
 		bk.pendingPermission = undefined;
 	}
 
@@ -1388,7 +1794,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		Logger.debug(
 			`ClaudeCodeProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`,
 		);
-		pending.resolve({
+		this.resolveAllPending(pending, {
 			hookSpecificOutput: {
 				hookEventName: 'PermissionRequest',
 				decision: { behavior: decision, updatedPermissions: updatedPermissions },
@@ -1409,6 +1815,138 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		return true;
 	}
 
+	async archiveSession(sessionId: string): Promise<boolean> {
+		// Authoritative status guard: the CLI's `archive-session` ends an active session first, so a
+		// stale webview action (or a row that resumed out of `completed` 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') {
+			Logger.warn(
+				`ClaudeCodeProvider.archiveSession: refusing to archive non-completed ${this.sessionTag(sessionId)} (status=${session.status})`,
+			);
+			return false;
+		}
+
+		Logger.debug(`ClaudeCodeProvider.archiveSession: ${this.sessionTag(sessionId)}`);
+		await this.callbacks.runCLICommand(['ai', 'hook', 'archive-session', sessionId, '--json']);
+		// Invalidate the archived-id cache so the next `getPastSessions` re-fetches and excludes this id.
+		this._archivedSessionIdsCache = undefined;
+		// Optimistically drop it — archived sessions are excluded from the `active,ended` poll, so the
+		// next reconciliation confirms the removal regardless.
+		const index = this._sessions.findIndex(s => s.id === sessionId);
+		if (index >= 0) {
+			this._sessions.splice(index, 1);
+			this._sessionBookkeeping.delete(sessionId);
+			this._transcriptReader.forget(sessionId);
+			this._onDidChangeSessions.fire();
+		}
+		return true;
+	}
+
+	/** Lists the ids of sessions the CLI has archived, so callers (the "Past" transcript listing) can
+	 *  exclude them — the tracked row is gone, but the transcript on disk survives and would otherwise
+	 *  resurface there. Resolves to `[]` on any error, including a CLI too old to support the
+	 *  `archived` status filter. */
+	async getArchivedSessionIds(): Promise<string[]> {
+		const cached = this._archivedSessionIdsCache;
+		if (cached != null && Date.now() - cached.at < archivedSessionIdsCacheTtlMs) {
+			return cached.promise;
+		}
+
+		const promise = this.fetchArchivedSessionIds();
+		this._archivedSessionIdsCache = { promise: promise, at: Date.now() };
+		return promise;
+	}
+
+	private async fetchArchivedSessionIds(): Promise<string[]> {
+		try {
+			const output = await this.callbacks.runCLICommand([
+				'ai',
+				'hook',
+				'list-sessions',
+				'--status',
+				'archived',
+				'--json',
+			]);
+			const sessions = JSON.parse(output) as SessionFileData[];
+			return sessions.map(s => s.sessionId).filter(id => id.length > 0);
+		} catch {
+			return [];
+		}
+	}
+
+	resolveCompletedSessionDetails(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;
+
+		// 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;
+
+		bk.completedDetailsResolved = true;
+
+		if (session.cwd) {
+			void this.resolveGitInfo(sessionId, session.cwd);
+		}
+		void this.applyCompletedTranscriptDetails(sessionId, session.cwd);
+	}
+
+	private async applyCompletedTranscriptDetails(sessionId: string, cwd: string | undefined): Promise<void> {
+		let details;
+		try {
+			details = await this._transcriptReader.resolveCompletedDetails(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;
+			}
+			return;
+		}
+		if (details == null) return;
+
+		const index = this._sessions.findIndex(s => s.id === sessionId);
+		if (index < 0) return;
+
+		const session = this._sessions[index];
+		// The session may have been archived/removed while we were reading.
+		if (session.status !== 'completed') return;
+
+		const { titles } = details;
+		const nextTitles =
+			titles.custom != null || titles.ai != null || titles.agent != null
+				? { custom: titles.custom, ai: titles.ai, agent: titles.agent }
+				: session.transcriptTitles;
+		// Durable-store prompts (full text) win over the transcript's (CLI-truncated) copy; only
+		// backfill from the transcript when the field is empty.
+		const nextFirstPrompt = session.firstPrompt ?? prepareStoredPrompt(details.firstPrompt);
+		const nextLastPrompt = session.lastPrompt ?? prepareStoredPrompt(details.lastPrompt);
+
+		const titlesChanged =
+			nextTitles?.custom !== session.transcriptTitles?.custom ||
+			nextTitles?.ai !== session.transcriptTitles?.ai ||
+			nextTitles?.agent !== session.transcriptTitles?.agent;
+		if (!titlesChanged && nextFirstPrompt === session.firstPrompt && nextLastPrompt === session.lastPrompt) {
+			return;
+		}
+
+		this._sessions[index] = {
+			...session,
+			transcriptTitles: nextTitles,
+			firstPrompt: nextFirstPrompt,
+			lastPrompt: nextLastPrompt,
+		};
+		this._onDidChangeSessions.fire();
+	}
+
 	private matchesWorkspace(workspacePath: string | undefined): boolean {
 		if (!workspacePath) return false;
 
@@ -1430,12 +1968,18 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		);
 	}
 
-	private updateSessionWithPermission(sessionId: string, permission: PendingPermission, pid?: number): void {
+	private updateSessionWithPermission(
+		sessionId: string,
+		permission: PendingPermission,
+		context?: SessionContext,
+	): void {
 		// A pending permission is a working/waiting transition — cancel any deferred Stop → idle
 		// commit so the session doesn't briefly flip to idle before showing the prompt.
 		this.cancelPendingIdleTransition(sessionId);
 
-		const { index } = this.ensureSession(sessionId, { pid: pid });
+		// The full event context, not just the pid: a blocking ask can be the first event of a
+		// session, and a row created here with no location would sit unattributed for the whole block.
+		const { index } = this.ensureSession(sessionId, context);
 
 		const prev = this._sessions[index];
 		const newPhase = getPhaseForStatus('permission_requested');
@@ -1455,7 +1999,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	private updateSessionStatus(
 		sessionId: string,
 		status: AgentSessionStatus,
-		options?: SessionContext & { statusDetail?: string },
+		options?: SessionContext & { statusDetail?: string; pendingPermission?: PendingPermission },
 	): void {
 		// Any non-idle status update implicitly cancels a deferred Stop → idle commit. The
 		// timer is owned here so the schedule/cancel pair is uniformly enforced regardless of
@@ -1482,7 +2026,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 
 		const statusDetail = options?.statusDetail;
-		if (prev.status === status && prev.statusDetail === statusDetail) {
+		// Resolved before the short-circuit: a second ask can arrive while the row already sits at
+		// `permission_requested`, and comparing only status+detail would publish the first ask forever.
+		const nextPendingPermission =
+			status === 'permission_requested' ? (bk.pendingPermission ?? options?.pendingPermission) : undefined;
+		if (
+			prev.status === status &&
+			prev.statusDetail === statusDetail &&
+			isSameAsk(prev.pendingPermission, nextPendingPermission)
+		) {
 			if (metadataChanged) {
 				this._onDidChangeSessions.fire();
 			}
@@ -1496,7 +2048,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			phase: newPhase,
 			phaseSince: this.resolvePhaseSince(sessionId, prev.phase, prev.phaseSince, newPhase),
 			statusDetail: statusDetail,
-			pendingPermission: status === 'permission_requested' ? bk.pendingPermission : undefined,
+			pendingPermission: nextPendingPermission,
 			lastActivity: new Date(),
 		};
 		this._onDidChangeSessions.fire();
@@ -1517,11 +2069,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 	}
 
 	private ensureSession(sessionId: string, context?: SessionContext): { index: number; changed: boolean } {
-		const { pid, workspacePath, isInWorkspace, cwd, initialCwd, planFile, sessionName } = context ?? {};
+		const { pid, workspacePath, isInWorkspace, cwd, initialCwd, planFile, sessionName, model, worktreePath } =
+			context ?? {};
 
 		let index = this._sessions.findIndex(s => s.id === sessionId);
 		if (index < 0) {
 			const now = new Date();
+			// Same worktree-derived fallback as the update branch below: a session created with a
+			// scratch cwd but a CLI-seated worktree still belongs to that worktree's workspace.
+			const createdWorkspacePath = workspacePath ?? this.resolveWorkspacePath(worktreePath);
 			index = this._sessions.length;
 			this._sessions.push({
 				id: sessionId,
@@ -1534,15 +2090,20 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				pid: pid,
 				lastActivity: now,
 				isSubagent: false,
-				workspacePath: workspacePath,
+				workspacePath: createdWorkspacePath,
 				cwd: cwd,
 				initialCwd: initialCwd ?? cwd,
 				planFile: planFile,
-				isInWorkspace: isInWorkspace ?? false,
+				isInWorkspace: createdWorkspacePath != null ? true : (isInWorkspace ?? false),
+				model: model,
+				worktreePath: worktreePath != null ? normalizePath(worktreePath) : undefined,
 			});
 			Logger.debug(
 				`ClaudeCodeProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`,
 			);
+			if (worktreePath != null) {
+				this.getBookkeeping(sessionId).cliSeatedWorktree = true;
+			}
 			this._onDidChangeSessions.fire();
 
 			if (cwd != null) {
@@ -1554,10 +2115,9 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 		const existing = this._sessions[index];
 		const updatedPid = pid != null && existing.pid == null ? pid : existing.pid;
-		const updatedWorkspacePath = workspacePath || existing.workspacePath;
-		const updatedIsInWorkspace = workspacePath ? (isInWorkspace ?? existing.isInWorkspace) : existing.isInWorkspace;
 		const updatedPlanFile = planFile ?? existing.planFile;
 		const updatedName = sessionName || existing.name;
+		const updatedModel = model || existing.model;
 		const updatedCwd = cwd ?? existing.cwd;
 		// Prefer the CLI's authoritative `initialCwd` (the true launch dir it captured first-hand,
 		// even for sessions that started before this window opened); otherwise keep whatever we
@@ -1565,6 +2125,32 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// don't send `initialCwd`, or a cold-create before any cwd was known). Comparing live `cwd`
 		// against `initialCwd` is how consumers detect launch-vs-current drift, so it stays stable.
 		const updatedInitialCwd = initialCwd ?? existing.initialCwd ?? cwd;
+		// The CLI resolves this at hook time and sends it on every event — authoritative when
+		// present, so it seats ahead of the `resolveGitInfo` probe below (which still fills
+		// `commonPath` and remains the fallback for older CLIs that don't send `cwdTimeline`).
+		const updatedWorktreePath = worktreePath != null ? normalizePath(worktreePath) : existing.worktreePath;
+		// Workspace membership follows the ATTRIBUTION, not the raw cwd: a scratch-dir excursion
+		// (cwd in /tmp, worktree kept) stays in-workspace via its worktree, while a genuine move to
+		// a repo outside the workspace honestly drops membership when events carry a cwd.
+		const updatedWorkspacePath =
+			workspacePath ??
+			this.resolveWorkspacePath(updatedWorktreePath) ??
+			(cwd == null ? existing.workspacePath : undefined);
+		const updatedIsInWorkspace = cwd == null ? existing.isInWorkspace : updatedWorkspacePath != null;
+
+		const cwdMoved = cwd != null && updatedCwd !== existing.cwd;
+		const worktreeMoved =
+			updatedWorktreePath != null &&
+			existing.worktreePath != null &&
+			updatedWorktreePath !== existing.worktreePath;
+
+		// The CLI explaining the location owns attribution; a move it didn't explain hands it back to
+		// the probe.
+		if (worktreePath != null) {
+			this.getBookkeeping(sessionId).cliSeatedWorktree = true;
+		} else if (cwdMoved) {
+			this.getBookkeeping(sessionId).cliSeatedWorktree = false;
+		}
 
 		let changed = false;
 		if (
@@ -1573,18 +2159,27 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			updatedIsInWorkspace !== existing.isInWorkspace ||
 			updatedPlanFile !== existing.planFile ||
 			updatedName !== existing.name ||
+			updatedModel !== existing.model ||
 			updatedCwd !== existing.cwd ||
-			updatedInitialCwd !== existing.initialCwd
+			updatedInitialCwd !== existing.initialCwd ||
+			updatedWorktreePath !== existing.worktreePath
 		) {
 			this._sessions[index] = {
 				...existing,
 				name: updatedName,
+				model: updatedModel,
 				pid: updatedPid,
 				workspacePath: updatedWorkspacePath,
 				cwd: updatedCwd,
 				initialCwd: updatedInitialCwd,
 				planFile: updatedPlanFile,
 				isInWorkspace: updatedIsInWorkspace,
+				worktreePath: updatedWorktreePath,
+				// A worktree move can cross repos, and the spread would otherwise carry the old repo
+				// identity forward — which consumers prefer over the new worktree, pinning the card to
+				// the wrong repo. Drop it; the probe below refills it. Mirrors the poll's ended-record
+				// re-seat.
+				commonPath: worktreeMoved ? undefined : existing.commonPath,
 			};
 			changed = true;
 		}
@@ -1598,13 +2193,30 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// `resolveGitInfo` confirms the cwd isn't a git repo, preventing a retry storm on every
 		// hook event for non-git-repo cwds. The flag is cleared on cwd change (`CwdChanged`) and
 		// on `resetBookkeeping` (Stop/SessionStart) so re-resolution can happen when warranted.
+		// A cwd move re-resolves too. `worktreePath`/`commonPath` are resolved from whichever cwd was
+		// seen first, so an agent that moves between worktrees would otherwise stay pinned to its
+		// launch repo — attaching to the wrong WIP row and leaving its real worktree showing no
+		// agents at all. `CwdChanged` covers the move the CLI announces; this covers an ordinary
+		// event that simply arrives carrying a new cwd.
+		//
+		// A cwd the CLI already attributed to the same worktree needs no probe at all — that's the
+		// common case (an agent `cd`-ing around inside its own tree), and probing it would spawn a git
+		// call per hook event for an answer we already have. A first seat (no prior worktree) still
+		// counts as a location change: the move may be out of a non-git dir whose probe latched
+		// `gitInfoUnresolvable`, and `commonPath` still needs the probe.
+		const locationNeedsProbe = cwdMoved && (worktreePath == null || worktreeMoved || existing.worktreePath == null);
+		if (locationNeedsProbe) {
+			this.getBookkeeping(sessionId).gitInfoUnresolvable = false;
+		}
+
 		if (
 			cwd != null &&
-			(existing.worktreePath == null || existing.commonPath == null) &&
+			(locationNeedsProbe || existing.worktreePath == null || existing.commonPath == null) &&
 			!this.getBookkeeping(sessionId).gitInfoUnresolvable
 		) {
 			void this.resolveGitInfo(sessionId, cwd);
 		}
+
 		return { index: index, changed: changed };
 	}
 
@@ -1618,9 +2230,20 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// would spawn a fresh git probe per hook event. The `gitInfoUnresolvable` bookkeeping flag
 		// (set below when `info == null`) is the long-lived suppressor across hook events; this
 		// in-flight set only dedupes concurrent overlapping probes within a single resolution.
-		if (this._resolveGitInfoInFlight.has(sessionId)) return;
+		//
+		// Keyed by cwd as well: a probe for the SAME cwd is genuinely redundant, but one for a
+		// different cwd (a missed `CwdChanged` corrected off the durable record, say) must not be
+		// swallowed — the in-flight answer describes the old directory. Record it as pending so the
+		// running probe hands off to it, and discard the stale answer below.
+		const inFlightCwd = this._resolveGitInfoInFlight.get(sessionId);
+		if (inFlightCwd != null) {
+			if (inFlightCwd !== cwd) {
+				this._resolveGitInfoPending.set(sessionId, cwd);
+			}
+			return;
+		}
 
-		this._resolveGitInfoInFlight.add(sessionId);
+		this._resolveGitInfoInFlight.set(sessionId, cwd);
 		try {
 			let info: Awaited<ReturnType<typeof resolveGitInfo>> | undefined;
 			try {
@@ -1633,6 +2256,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			const index = this._sessions.findIndex(s => s.id === sessionId);
 			if (index < 0) return;
 
+			// Superseded while we were probing: this answer describes a directory the session has
+			// already left, so applying it would undo the newer location. Drop it — the `finally`
+			// below re-runs for the newest cwd.
+			if (this._resolveGitInfoPending.has(sessionId)) return;
+
 			const session = this._sessions[index];
 
 			// `workspacePath` stays as the matched workspace folder (or undefined). Repo identity
@@ -1657,18 +2285,26 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				return;
 			}
 
+			// A CLI-seated worktree wins over the probe's answer (see `cliSeatedWorktree`): the CLI
+			// resolved it for this exact cwd, while the probe can name the parent worktree for a nested
+			// one. `commonPath` always comes from the probe — the CLI doesn't resolve repo identity.
+			const effectiveWorktreePath =
+				this.getBookkeeping(sessionId).cliSeatedWorktree && session.worktreePath != null
+					? session.worktreePath
+					: info.worktreePath;
+
 			// Capture the worktree/commonPath at the first successful resolve so consumers can
 			// detect drift (e.g. an agent that `cd`'d into a sibling worktree after launch). Gated
 			// on `initialCommonPath` — captured together with `initialWorktreePath` so a first
 			// resolve where `info.worktreePath` happens to be undefined doesn't leave the latter
 			// open to a later overwrite. Once set, never overwritten.
 			const firstResolve = session.initialCommonPath == null;
-			const updatedInitialWorktreePath = firstResolve ? info.worktreePath : session.initialWorktreePath;
+			const updatedInitialWorktreePath = firstResolve ? effectiveWorktreePath : session.initialWorktreePath;
 			const updatedInitialCommonPath = firstResolve ? info.repoRoot : session.initialCommonPath;
 
 			if (
 				cwd !== session.cwd ||
-				info.worktreePath !== session.worktreePath ||
+				effectiveWorktreePath !== session.worktreePath ||
 				info.repoRoot !== session.commonPath ||
 				updatedInitialWorktreePath !== session.initialWorktreePath ||
 				updatedInitialCommonPath !== session.initialCommonPath
@@ -1676,7 +2312,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				this._sessions[index] = {
 					...session,
 					cwd: cwd,
-					worktreePath: info.worktreePath,
+					worktreePath: effectiveWorktreePath,
 					commonPath: info.repoRoot,
 					initialWorktreePath: updatedInitialWorktreePath,
 					initialCommonPath: updatedInitialCommonPath,
@@ -1685,6 +2321,14 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			}
 		} finally {
 			this._resolveGitInfoInFlight.delete(sessionId);
+
+			// Hand off to the newest cwd requested while this probe ran, so a move that arrived
+			// mid-flight still resolves instead of being dropped by the dedupe.
+			const pendingCwd = this._resolveGitInfoPending.get(sessionId);
+			if (pendingCwd != null) {
+				this._resolveGitInfoPending.delete(sessionId);
+				void this.resolveGitInfo(sessionId, pendingCwd);
+			}
 		}
 	}
 
@@ -1711,10 +2355,58 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		this._onDidChangeSessions.fire();
 	}
 
+	/** Transitions the session at `index` to the terminal `completed` 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 {
+		const prev = this._sessions[index];
+		this._sessions[index] = {
+			...prev,
+			status: 'completed',
+			phase: 'completed',
+			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
+		// in-flight permission promise (otherwise a blocking request leaks until dispose) and cancel a
+		// pending Stop→idle timer (otherwise it fires inside its window and revives this row to a
+		// live zombie).
+		const pending = this._pendingPermissions.get(prev.id);
+		if (pending != null) {
+			this.rejectAllPending(pending, new Error('Session completed'));
+			this._pendingPermissions.delete(prev.id);
+		}
+		this.cancelPendingIdleTransition(prev.id);
+
+		const bk = this._sessionBookkeeping.get(prev.id);
+		if (bk != null) {
+			this.cancelPendingFileClears(bk);
+			this.cancelPendingReadClears(bk);
+		}
+		this._sessionBookkeeping.delete(prev.id);
+		this._transcriptReader.forget(prev.id);
+	}
+
 	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
+			// liveness pruning must never drop them (they leave only via poll reconciliation).
+			if (s.status === 'completed') {
+				kept.push(s);
+				continue;
+			}
+
 			// A session blocking on us for a permission decision is by definition alive,
 			// even if `kill(pid, 0)` says otherwise (e.g. transient EPERM/ESRCH). Dropping
 			// it here loses pendingPermission and lastPrompt; the next syncSessions then
@@ -1731,7 +2423,7 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		for (const id of removedIds) {
 			const pending = this._pendingPermissions.get(id);
 			if (pending != null) {
-				pending.reject(new Error('Session pruned'));
+				this.rejectAllPending(pending, new Error('Session pruned'));
 				this._pendingPermissions.delete(id);
 			}
 			this.cancelPendingIdleTransition(id);
@@ -1759,11 +2451,60 @@ 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
+		// 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;
 
+		// Narrowly: hooks off AND nothing running, i.e. we hold only terminal history. There's no
+		// dying process to reap and no live state to correct — just rows to reconcile and the
+		// retention sweep to trigger, neither of which needs quarter-hourly resolution. Back the
+		// cadence off rather than stopping (window startup polls ungated, so a reload is current).
+		// Hooks ON keeps the full cadence deliberately: there the tick is also the backstop for a
+		// session whose hook events never reached our IPC server.
+		if (
+			options?.gate &&
+			!this._claudeHooksInstalled &&
+			!this._sessions.some(s => s.status !== 'completed') &&
+			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.
+		const pollStartedAt = Date.now();
+		this._lastSyncAt = pollStartedAt;
+
 		let sessions: SessionFileData[];
 		try {
-			const output = await this.callbacks.runCLICommand(['ai', 'hook', 'list-sessions', '--json']);
+			let output: string;
+			try {
+				// `--status active,ended` surfaces both live sessions and the CLI's durable ended records
+				// (excluding `archived`). Newer CLIs default `list-sessions` to active-only, so the flag
+				// is required to see completed sessions at all.
+				output = await this.callbacks.runCLICommand([
+					'ai',
+					'hook',
+					'list-sessions',
+					'--status',
+					'active,ended',
+					'--json',
+				]);
+				this._statusFilterSupported = true;
+			} catch (ex) {
+				// Only retry on an unknown-flag error — a pre-3.1.69 CLI rejects `--status` but returns
+				// all sessions unfiltered, so the flagless call is the correct legacy equivalent. Real
+				// failures (CLI missing, spawn error) rethrow to the prune-and-return handler below.
+				if (!isUnknownFlagError(ex)) throw ex;
+
+				this._statusFilterSupported = false;
+				output = await this.callbacks.runCLICommand(['ai', 'hook', 'list-sessions', '--json']);
+			}
 			sessions = JSON.parse(output) as SessionFileData[];
 		} catch {
 			if (this.pruneDeadSessions()) {
@@ -1775,24 +2516,255 @@ 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).
-		const trackedBefore = new Set(this._sessions.map(s => s.id));
+		// Drift is measured over *live* sessions only; completed 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>();
-		// Mutable copy of `trackedBefore` that also accumulates ids added during this poll, so the
-		// membership check below is O(1) and duplicate ids within a single poll response are only
-		// added once. `trackedBefore` itself stays the pre-poll snapshot used by the `missing` calc.
-		const known = new Set(trackedBefore);
+		// 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.
+		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));
 
 		let changed = false;
 		let discovered = 0;
 
 		for (const data of sessions) {
-			if (!data.sessionId || !data.pid || !isProcessAlive(data.pid)) {
+			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;
+
+			const effectiveStatus = data.status ?? 'active';
+
+			// Archived records are excluded by the `active,ended` query; guard anyway.
+			if (effectiveStatus === 'archived') continue;
+
+			if (effectiveStatus === 'ended') {
+				polledIds.add(data.sessionId);
+				const endedDate = new Date(data.endedAt ?? data.updatedAt);
+
+				const 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);
+						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.
+					const existing = this._sessions[existingIndex];
+					const worktreeRoot = worktreeRootFromData(data);
+					const cwdChanged = Boolean(data.cwd) && data.cwd !== 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
+								? undefined
+								: existing.worktreePath;
+					const worktreeMoved = nextWorktreePath !== existing.worktreePath;
+					if (cwdChanged || worktreeMoved) {
+						const workspacePath = this.resolveWorkspacePath(data.cwd || existing.cwd);
+						this._sessions[existingIndex] = {
+							...existing,
+							cwd: data.cwd || existing.cwd,
+							initialCwd: existing.initialCwd ?? data.initialCwd ?? data.cwd,
+							worktreePath: nextWorktreePath,
+							workspacePath: workspacePath,
+							isInWorkspace: workspacePath != null,
+							// A worktree move can cross repos, and the spread would otherwise carry the old
+							// repo identity forward — which consumers PREFER over the freshly-resolved
+							// worktree metadata, pinning the card to the wrong repo. Drop it and let the
+							// host backfill from the new worktree.
+							commonPath: worktreeMoved ? undefined : existing.commonPath,
+						};
+						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);
+						}
+					}
+
+					this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
+					continue;
+				}
+
+				known.add(data.sessionId);
+				const workspacePath = this.resolveWorkspacePath(data.cwd);
+				const worktreeRoot = worktreeRootFromData(data);
+				this._sessions.push({
+					id: data.sessionId,
+					providerId: this.id,
+					providerName: this.name,
+					name: data.sessionName || undefined,
+					status: 'completed',
+					phase: 'completed',
+					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
+					// cards / WIP rows / the resume picker at any age, no git probe.
+					worktreePath: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
+					cwd: data.cwd,
+					initialCwd: data.initialCwd ?? data.cwd,
+					planFile: data.planFile ?? undefined,
+					isInWorkspace: workspacePath != null,
+					lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
+					firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
+					model: data.model ?? undefined,
+					endReason: data.endReason ?? undefined,
+					endedAt: data.endedAt != null ? new Date(data.endedAt).getTime() : undefined,
+					// Subagents are meaningless once terminal.
+					subagents: undefined,
+				});
+				this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
+				changed = true;
+				// Titles/prompts still resolve lazily via resolveCompletedSessionDetails (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 &&
+					data.cwd &&
+					Date.now() - endedDate.getTime() < recentCompletedGitResolveThresholdMs
+				) {
+					void this.resolveGitInfo(data.sessionId, data.cwd);
+				}
 				continue;
 			}
 
-			polledAlive.add(data.sessionId);
+			// Active / legacy (absent-status) path — only genuinely-live processes are discoverable.
+			if (!data.pid || !isProcessAlive(data.pid)) continue;
 
-			if (known.has(data.sessionId)) continue;
+			polledAlive.add(data.sessionId);
+			polledIds.add(data.sessionId);
+
+			if (known.has(data.sessionId)) {
+				// Already tracked.
+				const existingIndex = this._sessions.findIndex(s => s.id === data.sessionId);
+				if (existingIndex >= 0) {
+					const existing = this._sessions[existingIndex];
+					// The status the CLI's last event implies — a resumed session may already be mid-work
+					// (`PreToolUse` → tool_use, `UserPromptSubmit` → thinking), and hardcoding `idle` would
+					// mislabel active work and risk a concurrent-write resume.
+					const polledStatus = deriveStatusFromEvent(data.event);
+					if (existing.status === 'completed') {
+						// We hold it as `completed` 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
+						// 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
+						// 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.
+						if (revivedAt.getTime() < existing.phaseSince.getTime()) continue;
+
+						// The poll has no blocking hook entry for this ask (it's discovered off the CLI's
+						// durable record, not this window's IPC path) — synthesize an unresolvable one so
+						// the row shows what it's waiting on instead of an empty "Needs input" card.
+						const revivedPendingPermission =
+							polledStatus === 'permission_requested'
+								? synthesizeUnresolvableAsk(data.toolName, 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.
+						const revivedWorktreeRoot = worktreeRootFromData(data);
+						// No record worktree data (older CLI): KEEP the completed row's attribution. A
+						// resume whose cwd is scratch space (e.g. /tmp) still belongs to its worktree —
+						// re-rooting happens only when git affirmatively resolves a new one (the probe
+						// below, on success). Attribution persists until something better is known.
+						const revivedWorktreePath =
+							revivedWorktreeRoot != null ? normalizePath(revivedWorktreeRoot) : existing.worktreePath;
+						// Membership follows the attribution, mirroring `ensureSession`: cwd first, the
+						// kept worktree as the fallback for a scratch-dir resume.
+						const revivedWorkspacePath =
+							this.resolveWorkspacePath(data.cwd) ?? this.resolveWorkspacePath(revivedWorktreePath);
+						this._sessions[existingIndex] = {
+							...existing,
+							status: polledStatus,
+							phase: getPhaseForStatus(polledStatus),
+							phaseSince: revivedAt,
+							lastActivity: revivedAt,
+							// Fresh pid from the CLI, and re-classify ownership on next open rather than
+							// trusting the terminal record's `isPeerOwned`.
+							pid: data.pid,
+							isPeerOwned: undefined,
+							pendingPermission: revivedPendingPermission,
+							// The resume can be running somewhere else entirely, so take the record's
+							// location rather than leaving the row filed under where it ended.
+							cwd: data.cwd ?? existing.cwd,
+							workspacePath:
+								revivedWorkspacePath ?? (data.cwd == null ? existing.workspacePath : undefined),
+							isInWorkspace: data.cwd == null ? existing.isInWorkspace : revivedWorkspacePath != null,
+							worktreePath: revivedWorktreePath,
+							// 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
+							// consumers that key off them.
+							endReason: undefined,
+							endedAt: undefined,
+						};
+						this.resetBookkeeping(data.sessionId);
+						// The record's worktree is the CLI's own resolution; without one the probe owns
+						// attribution again.
+						this.getBookkeeping(data.sessionId).cliSeatedWorktree = revivedWorktreeRoot != null;
+						if (data.cwd != null && data.cwd !== existing.cwd) {
+							void this.resolveGitInfo(data.sessionId, data.cwd);
+						}
+						changed = true;
+					} else if (
+						existing.pendingPermission?.resolvable === false &&
+						polledStatus !== 'permission_requested' &&
+						new Date(data.updatedAt).getTime() > existing.lastActivity.getTime()
+					) {
+						// The record has moved past the ask this row still shows. Only a synthesized
+						// (`resolvable: false`) ask is repairable this way — a routable one is bookkeeping-
+						// owned and cleared by its own resolution paths, which the record can't see.
+						this._sessions[existingIndex] = {
+							...existing,
+							status: polledStatus,
+							phase: getPhaseForStatus(polledStatus),
+							phaseSince: new Date(data.updatedAt),
+							// The detail described the ask's tool; carry the record's current tool for
+							// tool_use, else clear — keeping it would show the answered ask's tool as
+							// the active one.
+							statusDetail: polledStatus === 'tool_use' ? (data.toolName ?? undefined) : undefined,
+							pendingPermission: undefined,
+							lastActivity: new Date(data.updatedAt),
+						};
+						changed = true;
+					} else if (existing.transcriptTitles?.ai == null && existing.transcriptTitles?.custom == null) {
+						// A live session we discovered via the poll (another worktree/window owns its
+						// hook flow) gets none of the local IPC re-resolves (SessionStart, idle). So one
+						// discovered before Claude wrote its `ai-title` would show the repo slug forever.
+						// Re-check the transcript each poll until a real title lands — cheap: the reader
+						// tail-reads from its mtime cache and no-ops when the file hasn't grown.
+						void this.resolveTranscriptTitles(data.sessionId, data.cwd);
+					}
+				}
+				continue;
+			}
 
 			known.add(data.sessionId);
 
@@ -1801,6 +2773,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 			const status = deriveStatusFromEvent(data.event);
 			const phase = getPhaseForStatus(status);
 			const activityDate = new Date(data.updatedAt);
+			// 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)
+					: 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.
+			const worktreeRoot = worktreeRootFromData(data);
 
 			const subagents: AgentSession[] | undefined = data.subagents?.map(sub => ({
 				id: sub.agentId,
@@ -1837,17 +2818,54 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 				isInWorkspace: isInWorkspace,
 				lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
 				firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
+				model: data.model ?? undefined,
 				subagents: subagents,
+				pendingPermission: pendingPermission,
+				worktreePath: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
 			});
 			changed = true;
 			discovered++;
 
+			// The record's worktree is the CLI's own resolution — mark it seated so the probe below
+			// (still wanted for `commonPath`) can't clobber it for a nested worktree. Mirrors the
+			// revival branch above.
+			this.getBookkeeping(data.sessionId).cliSeatedWorktree = worktreeRoot != null;
 			if (data.cwd) {
 				void this.resolveGitInfo(data.sessionId, data.cwd);
 			}
 			void this.resolveTranscriptTitles(data.sessionId, data.cwd);
 		}
 
+		// The poll is authoritative for completed-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
+		// instead pin it forever — there, absence from the poll is the confirmation.
+		const staleCompleted = this._sessions.filter(
+			s =>
+				s.status === 'completed' &&
+				!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.
+					// `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
+					// 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
+					// an absence that's really a not-yet-visible record.
+					s.phaseSince.getTime() < pollStartedAt - completedRemovalGraceMs),
+		);
+		if (staleCompleted.length > 0) {
+			const staleIds = new Set(staleCompleted.map(s => s.id));
+			this._sessions = this._sessions.filter(s => !staleIds.has(s.id));
+			for (const s of staleCompleted) {
+				this._sessionBookkeeping.delete(s.id);
+				this._transcriptReader.forget(s.id);
+			}
+			changed = true;
+		}
+
 		if (this.pruneDeadSessions()) {
 			changed = true;
 		}
@@ -1859,11 +2877,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		// Report any drift between the live-synced set and the poll. Only on the recurring (gated)
 		// poll — the ungated bootstrap call runs before the live path has had a chance to receive
 		// any events, so its discoveries are expected cold-start state, not drift. `missing` counts
-		// sessions we still track that the poll no longer reports alive (a teardown the live path
+		// 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 trackedBefore) {
+			for (const id of trackedLiveBefore) {
 				if (!polledAlive.has(id)) {
 					missing++;
 				}
@@ -1874,13 +2892,13 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 					discovered: discovered,
 					missing: missing,
 					polled: polledAlive.size,
-					tracked: trackedBefore.size,
+					tracked: trackedLiveBefore.size,
 				});
 			}
 		}
 	}
 
-	private async querySiblingWindowSessions(): Promise<void> {
+	protected async querySiblingWindowSessions(): Promise<void> {
 		const discoveryDir = this.callbacks.ipc.agentDiscoveryDir;
 		if (discoveryDir == null) return;
 
@@ -1912,6 +2930,12 @@ 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
+				// 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;
+
 				const peerActivity = new Date(peerSession.lastActivity);
 				const peerPhaseSince = new Date(peerSession.phaseSince);
 
@@ -1929,6 +2953,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 
 					if (peerActivity > existing.lastActivity) {
 						const idx = this._sessions.indexOf(existing);
+						// A terminal row the peer now reports live IS a resume the peer owns. Mirror the
+						// poll/SessionStart revive paths: take the peer's pid (retaining the terminal
+						// record's dead — and possibly reused — pid would let dispatch focus an unrelated
+						// process) and mark it peer-owned so opens route through the peer's IPC.
+						const revivedFromCompleted = existing.status === 'completed';
 						// 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
@@ -1948,6 +2977,15 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 							phaseSince: peerPhaseSince,
 							statusDetail: peerSession.statusDetail,
 							lastActivity: peerActivity,
+							// A locally-routable ask wins — a blocking ask fans out to every window, so we
+							// may hold the hook entry the peer lacks. Otherwise mirror the peer's ask marked
+							// unresolvable (we have no entry to answer it), and clear it when the peer did.
+							pendingPermission:
+								this._sessionBookkeeping.get(peerSession.id)?.pendingPermission ??
+								(peerSession.pendingPermission != null
+									? { ...peerSession.pendingPermission, resolvable: false }
+									: undefined),
+							...(revivedFromCompleted ? { 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
@@ -1983,6 +3021,11 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 						...peerSession,
 						lastActivity: peerActivity,
 						phaseSince: peerPhaseSince,
+						// The peer owns the hook entry, so an imported ask can never be routed from here.
+						pendingPermission:
+							peerSession.pendingPermission != null
+								? { ...peerSession.pendingPermission, resolvable: false }
+								: undefined,
 						workspacePath: normalizeWorkspacePath(peerSession.workspacePath),
 						isInWorkspace: this.matchesWorkspace(peerSession.workspacePath),
 						subagents: rehydrateSubagents(peerSession.subagents),