@gitkraken/core-gitlens 0.5.110 → 0.5.112

package/dist/plus/agents/providers/claudeCodeProvider.js

@@ -16,6 +16,26 @@ import { classifyPermissionKind, deriveStatusFromEvent, describeToolInput, extra
 import { getPhaseForStatus } from '../types.js';
 import { ClaudeCodeTranscriptReader } from './claudeCodeTranscript.js';
 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`
@@ -30,6 +50,87 @@ const stopToIdleDebounceMs = 750;
  *  than `stopToIdleDebounceMs` so a continuation that just barely crosses the debounce still
  *  restores continuity. */
 const phaseSinceRestoreWindowMs = 2000;
+/** 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) {
+    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) {
+    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, planFilePath) {
+    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) {
+    return JSON.stringify(value, (_key, val) => {
+        if (val == null || typeof val !== 'object' || Array.isArray(val))
+            return val;
+        const sorted = {};
+        for (const key of Object.keys(val).sort()) {
+            sorted[key] = val[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, b) {
+    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);
+}
 /** Normalize a workspace path to GitLens canonical form (forward slashes, lower-case drive letter
  *  on Windows). Comparisons throughout the home view assume this form, but `_workspacePaths` and
  *  peer-session `workspacePath` values originate from `Uri.fsPath`, which on Windows uses
@@ -69,6 +170,13 @@ function fileActivityStructurallyEqual(a, b) {
     }
     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) {
+    const message = ex instanceof Error ? ex.message : String(ex);
+    return /unknown (?:flag|shorthand flag|command)/i.test(message);
+}
 export class ClaudeCodeProvider {
     callbacks;
     id = 'claudeCode';
@@ -81,17 +189,32 @@ export class ClaudeCodeProvider {
     _disposed = false;
     _handlerDisposables = [];
     _pendingPermissions = new Map();
-    _resolveGitInfoInFlight = new Set();
+    /** `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. */
+    _resolveGitInfoInFlight = new Map();
+    _resolveGitInfoPending = new Map();
+    /** 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. */
+    _archivedSessionIdsCache;
     _sessionBookkeeping = new Map();
     /** 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. */
     _pendingIdleTimers = new Map();
     _workspacePaths = [];
     _staleCheckTimer;
+    /** When the last poll actually ran (gated or not) — paces the idle cadence above. */
+    _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}. */
     _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. */
+    _statusFilterSupported = true;
     _transcriptReader = new ClaudeCodeTranscriptReader();
     constructor(callbacks) {
         this.callbacks = callbacks;
@@ -106,6 +229,9 @@ export class ClaudeCodeProvider {
     stop() {
         // IPC server stays up intentionally — hooks fire even when the window is unfocused
     }
+    sync() {
+        return this.syncSessions();
+    }
     updateWorkspacePaths(workspacePaths) {
         this._workspacePaths = workspacePaths.map(p => normalizePath(p));
         let changed = false;
@@ -190,7 +316,7 @@ export class ClaudeCodeProvider {
         }
         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()) {
@@ -223,7 +349,13 @@ export class ClaudeCodeProvider {
                 }
                 return Promise.resolve();
             }),
-            this.callbacks.ipc.registerHandler('agents/sessions/list', () => Promise.resolve(this._sessions.map(s => ({
+            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
+            // 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(),
@@ -288,6 +420,13 @@ export class ClaudeCodeProvider {
         }
     }
     handleSessionEvent(event, isBlocking) {
+        // 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 = {
             pid: event.pid,
@@ -297,6 +436,8 @@ export class ClaudeCodeProvider {
             initialCwd: event.initialCwd,
             planFile: event.planFile,
             sessionName: event.sessionName,
+            model: event.model,
+            worktreePath: worktreeFromEvent(event),
         };
         const tag = this.sessionTag(event.sessionId, event.sessionName ?? 'unnamed');
         if (event.event === 'SessionStart' || event.event === 'SessionEnd') {
@@ -321,11 +462,31 @@ export class ClaudeCodeProvider {
                     }
                 }
                 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() };
                     }
                 }
@@ -337,27 +498,53 @@ export class ClaudeCodeProvider {
             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();
                 }
-                const bk = this._sessionBookkeeping.get(event.sessionId);
-                if (bk != null) {
-                    this.cancelPendingFileClears(bk);
-                    this.cancelPendingReadClears(bk);
+                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);
                 }
-                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
@@ -406,7 +593,7 @@ export class ClaudeCodeProvider {
             }
             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
@@ -440,7 +627,7 @@ export class ClaudeCodeProvider {
             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
@@ -473,10 +660,28 @@ export class ClaudeCodeProvider {
                         // 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:
@@ -493,11 +698,31 @@ export class ClaudeCodeProvider {
                     const toolDescription = describeToolInput(toolName, toolInput);
                     const toolInputDescription = toolInput.description || undefined;
                     const kind = classifyPermissionKind(toolName);
+                    const toolUseId = hookInput?.tool_use_id;
+                    const toolInputJson = stableStringify(toolInput);
                     return new Promise((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' },
@@ -505,10 +730,11 @@ export class ClaudeCodeProvider {
                             });
                         }
                         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/
                         // PostToolUse) and fall back to the event's planFile for cold-start cases.
@@ -529,17 +755,45 @@ export class ClaudeCodeProvider {
                             questionText: questionDetails?.text,
                             questionCount: questionDetails?.count,
                         };
-                        this.updateSessionWithPermission(event.sessionId, permission, event.pid);
+                        this.updateSessionWithPermission(event.sessionId, permission, eventContext);
+                    });
+                }
+                {
+                    // Mirror the blocking payload's shape so the ask renders identically either way —
+                    // just unresolvable, since no blocking hook entry exists to route an answer through.
+                    const toolName = hookInput?.tool_name ?? 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 = kind != null && toolName != null && toolInput != null
+                        ? {
+                            kind: kind,
+                            toolName: toolName,
+                            toolDescription: describeToolInput(toolName, toolInput),
+                            toolInputDescription: toolInput.description || 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,
                     });
                 }
-                this.updateSessionStatus(event.sessionId, 'permission_requested', {
-                    ...eventContext,
-                    statusDetail: event.toolName,
-                });
                 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);
@@ -563,6 +817,9 @@ export class ClaudeCodeProvider {
                     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,
@@ -578,16 +835,15 @@ export class ClaudeCodeProvider {
             }
             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;
             case 'SubagentStart': {
@@ -698,6 +954,8 @@ export class ClaudeCodeProvider {
         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);
@@ -1075,8 +1333,10 @@ export class ClaudeCodeProvider {
         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)
+            // 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);
@@ -1105,20 +1365,86 @@ export class ClaudeCodeProvider {
         bk.priorPhase = { phase: prevPhase, phaseSince: prevPhaseSince };
         return now;
     }
+    /** Extracts the ask identity a settlement event refers to. `PostToolUse`/`PermissionDenied`
+     *  carry `hookInput.tool_use_id` and `hookInput.tool_input` in production; the top-level
+     *  `event.toolName`/`event.toolInput` are the older-CLI fallback. Input is canonicalized so key
+     *  order (or arriving via the fallback field instead of `hookInput`) doesn't defeat comparison. */
+    settledByFromEvent(event) {
+        const hookInput = event.hookInput;
+        const toolInput = hookInput?.tool_input ?? event.toolInput;
+        return {
+            toolUseId: hookInput?.tool_use_id,
+            toolName: hookInput?.tool_name ?? event.toolName,
+            toolInputJson: toolInput != null ? stableStringify(toolInput) : undefined,
+        };
+    }
+    resolveAllPending(entry, response) {
+        for (const resolver of entry.resolvers) {
+            resolver.resolve(response);
+        }
+    }
+    rejectAllPending(entry, reason) {
+        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.
-    clearStalePermission(sessionId, reason) {
+    // `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.
+    clearStalePermission(sessionId, reason, settledBy) {
         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;
     }
     resolvePermission(sessionId, decision, updatedPermissions) {
@@ -1126,7 +1452,7 @@ export class ClaudeCodeProvider {
         if (pending == null)
             return false;
         Logger.debug(`ClaudeCodeProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`);
-        pending.resolve({
+        this.resolveAllPending(pending, {
             hookSpecificOutput: {
                 hookEventName: 'PermissionRequest',
                 decision: { behavior: decision, updatedPermissions: updatedPermissions },
@@ -1144,6 +1470,126 @@ export class ClaudeCodeProvider {
         this.updateSessionStatus(sessionId, nextStatus);
         return true;
     }
+    async archiveSession(sessionId) {
+        // 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() {
+        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;
+    }
+    async fetchArchivedSessionIds() {
+        try {
+            const output = await this.callbacks.runCLICommand([
+                'ai',
+                'hook',
+                'list-sessions',
+                '--status',
+                'archived',
+                '--json',
+            ]);
+            const sessions = JSON.parse(output);
+            return sessions.map(s => s.sessionId).filter(id => id.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    resolveCompletedSessionDetails(sessionId) {
+        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);
+    }
+    async applyCompletedTranscriptDetails(sessionId, cwd) {
+        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();
+    }
     matchesWorkspace(workspacePath) {
         if (!workspacePath)
             return false;
@@ -1159,11 +1605,13 @@ export class ClaudeCodeProvider {
         const normalized = normalizePath(cwd);
         return this._workspacePaths.find(p => normalized === p || normalized.startsWith(`${p}/`) || p.startsWith(`${normalized}/`));
     }
-    updateSessionWithPermission(sessionId, permission, pid) {
+    updateSessionWithPermission(sessionId, permission, context) {
         // 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');
         this.getBookkeeping(sessionId).pendingPermission = permission;
@@ -1200,7 +1648,12 @@ export class ClaudeCodeProvider {
             return;
         }
         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();
             }
@@ -1213,7 +1666,7 @@ export class ClaudeCodeProvider {
             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();
@@ -1231,10 +1684,13 @@ export class ClaudeCodeProvider {
         }
     }
     ensureSession(sessionId, context) {
-        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,
@@ -1247,13 +1703,18 @@ export class ClaudeCodeProvider {
                 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) {
                 void this.resolveGitInfo(sessionId, cwd);
@@ -1263,10 +1724,9 @@ export class ClaudeCodeProvider {
         }
         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
@@ -1274,23 +1734,55 @@ export class ClaudeCodeProvider {
         // 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 (updatedPid !== existing.pid ||
             updatedWorkspacePath !== existing.workspacePath ||
             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;
         }
@@ -1303,8 +1795,23 @@ export class ClaudeCodeProvider {
         // `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);
         }
@@ -1320,9 +1827,19 @@ export class ClaudeCodeProvider {
         // 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))
+        //
+        // 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;
             try {
@@ -1335,6 +1852,11 @@ export class ClaudeCodeProvider {
             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
             // flows through `commonPath`, populated here from `info.repoRoot` at the same step as
@@ -1357,23 +1879,29 @@ export class ClaudeCodeProvider {
                 }
                 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) {
                 this._sessions[index] = {
                     ...session,
                     cwd: cwd,
-                    worktreePath: info.worktreePath,
+                    worktreePath: effectiveWorktreePath,
                     commonPath: info.repoRoot,
                     initialWorktreePath: updatedInitialWorktreePath,
                     initialCommonPath: updatedInitialCommonPath,
@@ -1383,6 +1911,13 @@ export class ClaudeCodeProvider {
         }
         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);
+            }
         }
     }
     async resolveTranscriptTitles(sessionId, cwd) {
@@ -1408,10 +1943,55 @@ export class ClaudeCodeProvider {
         };
         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. */
+    completeSession(index, endedAt) {
+        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);
+    }
     pruneDeadSessions() {
         const kept = [];
         const removedIds = [];
         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
@@ -1429,7 +2009,7 @@ export class ClaudeCodeProvider {
         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);
@@ -1454,11 +2034,57 @@ export class ClaudeCodeProvider {
         // 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;
         try {
-            const output = await this.callbacks.runCLICommand(['ai', 'hook', 'list-sessions', '--json']);
+            let output;
+            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);
         }
         catch {
@@ -1470,27 +2096,252 @@ export class ClaudeCodeProvider {
         // 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();
-        // 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();
+        // 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;
             }
+            // Active / legacy (absent-status) path — only genuinely-live processes are discoverable.
+            if (!data.pid || !isProcessAlive(data.pid))
+                continue;
             polledAlive.add(data.sessionId);
-            if (known.has(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);
             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);
+            // 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 = data.subagents?.map(sub => ({
                 id: sub.agentId,
                 providerId: this.id,
@@ -1525,15 +2376,48 @@ export class ClaudeCodeProvider {
                 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;
         }
@@ -1543,11 +2427,11 @@ export class ClaudeCodeProvider {
         // 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++;
                 }
@@ -1558,7 +2442,7 @@ export class ClaudeCodeProvider {
                     discovered: discovered,
                     missing: missing,
                     polled: polledAlive.size,
-                    tracked: trackedBefore.size,
+                    tracked: trackedLiveBefore.size,
                 });
             }
         }
@@ -1590,6 +2474,12 @@ export class ClaudeCodeProvider {
             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);
                 const existing = this._sessions.find(s => s.id === peerSession.id);
@@ -1604,6 +2494,11 @@ export class ClaudeCodeProvider {
                     }
                     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
@@ -1623,6 +2518,14 @@ export class ClaudeCodeProvider {
                             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
@@ -1659,6 +2562,10 @@ export class ClaudeCodeProvider {
                         ...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),