@gitkraken/core-gitlens 0.5.113 → 0.5.114

package/dist/plus/agents/providers/{claudeCodeProvider.js → gkAgentProvider.js}

@@ -10,7 +10,8 @@ import { gate } from '../../../utils/decorators/gate.js';
 import { disposableInterval } from '../../../utils/disposable.js';
 import { Emitter } from '../../../utils/event.js';
 import { Logger } from '../../../utils/logger.js';
-import { normalizePath } from '../../../utils/path.js';
+import { arePathsEqual, normalizePath } from '../../../utils/path.js';
+import { agentCapabilities, claudeCodeCapabilities, getAgentCapabilities, getAgentCapabilitiesByProviderId, resolveCanonicalHookEvent, resolveCanonicalToolName, } from '../agentCapabilities.js';
 import { prepareStoredPrompt } from '../sanitizePrompt.js';
 import { classifyPermissionKind, deriveStatusFromEvent, describeToolInput, extractPlanSummary, extractQuestionDetails, getToolFilePath, getToolReadPath, isProcessAlive, rehydrateSubagents, } from '../stateMachine.js';
 import { getPhaseForStatus } from '../types.js';
@@ -21,21 +22,21 @@ const staleCheckIntervalMs = 15 * 60 * 1000; // 15 minutes
  *  to reap, leaving only terminal-history reconciliation and the CLI's retention sweep — both fine
  *  hourly. Window startup polls ungated, so this never delays a fresh window. */
 const idleReconcileIntervalMs = 60 * 60 * 1000; // 1 hour
-/** How long a freshly-completed row is protected from absence-based removal. The CLI persists the
+/** How long a freshly-ended row is protected from absence-based removal. The CLI persists the
  *  ended record (atomic temp+rename) BEFORE broadcasting the hook event, so a poll that starts after
- *  we mark a row completed will list it — this guards only against that ordering changing on the CLI
- *  side, where the cost of being wrong is a completed row silently vanishing. */
-const completedRemovalGraceMs = 30 * 1000; // 30 seconds
+ *  we mark a row ended will list it — this guards only against that ordering changing on the CLI
+ *  side, where the cost of being wrong is an ended row silently vanishing. */
+const endedRemovalGraceMs = 30 * 1000; // 30 seconds
 /** How long the machine-global archived-session id list (fetched via a separate `--status archived`
- *  CLI query) is cached. `getPastSessions` asks for it once per worktree on panel open, so without
+ *  CLI query) is cached. `listSessionHistory` asks for it once per worktree on panel open, so without
  *  this a multi-worktree graph spawns N identical CLI processes. `archiveSession` invalidates the
  *  cache, so a just-archived row never lingers under "Past". */
 const archivedSessionIdsCacheTtlMs = 10 * 1000; // 10 seconds
-/** Completed sessions defer git + transcript resolution (a 30-day cold-start would otherwise fan out
+/** Ended sessions defer git + transcript resolution (a 30-day cold-start would otherwise fan out
  *  hundreds of probes). Exception: sessions ended within this window still surface on WIP rows /
  *  branch cards, which match strictly by resolved `worktreePath` — so their git info is resolved
  *  eagerly at poll time (a handful), keeping the older tail lazy. Mirrors the 24h WIP-row window. */
-const recentCompletedGitResolveThresholdMs = 24 * 60 * 60 * 1000; // 24 hours
+const recentEndedGitResolveThresholdMs = 24 * 60 * 60 * 1000; // 24 hours
 /** Default cooldown between PostToolUse and dropping the file from `fileActivity`. Held long
  *  enough that the treemap activity overlay can render a decay tail well past the moment the tool
  *  call completed. The host may override per-call via `AgentProviderCallbacks.getActivityDecayMs`
@@ -74,6 +75,110 @@ function worktreeFromEvent(event) {
     }
     return undefined;
 }
+/** Reorders `paths` so each distinct (already-normalized) value is positioned by its LAST
+ *  occurrence — an earlier occurrence of a value that recurs later is dropped, and the value's one
+ *  remaining slot sits where that last occurrence falls. Implemented via delete-then-reinsert into
+ *  a `Map`: re-inserting a key after deleting it moves it to the end of `Map` iteration order,
+ *  which is exactly "this value's position is its most recent occurrence". */
+function orderByLastOccurrence(paths) {
+    const seen = new Map();
+    for (const path of paths) {
+        seen.delete(path);
+        seen.set(path, true);
+    }
+    return [...seen.keys()];
+}
+/** Distinct, normalized, non-empty `worktree` values from a `cwdTimeline`, ordered by recency —
+ *  positioned by each path's LAST occurrence in the (chronological) timeline, so a path the
+ *  session returns to later sorts after one it doesn't. `undefined` when the timeline is absent or
+ *  names no worktree — callers should NOT overwrite an existing `visitedWorktreePaths` with an
+ *  empty array in that case. */
+function visitedFromTimeline(timeline) {
+    if (timeline == null)
+        return undefined;
+    const paths = [];
+    for (const entry of timeline) {
+        if (!entry.worktree)
+            continue;
+        paths.push(normalizePath(entry.worktree));
+    }
+    if (paths.length === 0)
+        return undefined;
+    return orderByLastOccurrence(paths);
+}
+/** Unions `adds` (each an array or a single path, `undefined` skipped) into `existing`, normalizing
+ *  every path, and reorders the result by recency: every add — including one that names a path
+ *  already in `existing` — moves that path to the end, same "last occurrence wins the slot" rule
+ *  {@link orderByLastOccurrence} applies to a single timeline. Adds arrive in chronological order at
+ *  every call site (timeline-derived paths first, the current `worktreePath` folded last), so the
+ *  current worktree normally ends up last.
+ *
+ *  **Reference-stability contract — load-bearing**: returns `existing` BY REFERENCE, unchanged,
+ *  when the resulting sequence is element-for-element identical to `existing`. Callers
+ *  (`ensureSession`'s identity gate) rely on this to avoid firing spurious change events on every
+ *  hook event / poll cycle when the visited set hasn't actually changed — re-processing an
+ *  unchanged timeline plus the same current worktree reproduces the identical sequence (each path
+ *  "moves" to the same slot it already occupies), so the comparison below still holds. */
+function unionVisited(existing, ...adds) {
+    const combined = existing != null ? [...existing] : [];
+    for (const add of adds) {
+        if (add == null)
+            continue;
+        const values = typeof add === 'string' ? [add] : add;
+        for (const value of values) {
+            if (!value)
+                continue;
+            combined.push(normalizePath(value));
+        }
+    }
+    const next = orderByLastOccurrence(combined);
+    if (existing != null && next.length === existing.length && next.every((path, i) => path === existing[i])) {
+        return existing;
+    }
+    return next.length > 0 ? next : undefined;
+}
+/** Peer-merge variant of {@link unionVisited}: same normalize-and-dedupe, but APPEND-ONLY —
+ *  `existing`'s order is preserved and any path the peer names that we don't already have is
+ *  appended in the peer's own order. A peer's order can't be trusted as fresher than ours without
+ *  timestamps, so peer input never reorders what we already hold. Returns `existing` BY REFERENCE
+ *  when nothing new is added — same rationale as {@link unionVisited}. */
+function unionVisitedAppendOnly(existing, ...adds) {
+    const next = new Set(existing ?? []);
+    let grew = false;
+    for (const add of adds) {
+        if (add == null)
+            continue;
+        const values = typeof add === 'string' ? [add] : add;
+        for (const value of values) {
+            if (!value)
+                continue;
+            const normalized = normalizePath(value);
+            if (!next.has(normalized)) {
+                next.add(normalized);
+                grew = true;
+            }
+        }
+    }
+    return grew ? [...next] : existing;
+}
+/** The event's tool name, translated from the agent's native vocabulary into the canonical (Claude
+ *  Code) one. Prefers the raw `hookInput.tool_name` passthrough and falls back to the projected
+ *  top-level field for older CLIs. Everything downstream — `describeToolInput`,
+ *  `classifyPermissionKind`, `getToolFilePath`, `getToolReadPath`, and the display detail — expects
+ *  canonical names, and Claude Code has no alias table, so its names pass through untouched. */
+function canonicalToolNameFromEvent(capabilities, event) {
+    const native = event.hookInput?.tool_name ?? event.toolName;
+    return native != null ? resolveCanonicalToolName(capabilities, native) : undefined;
+}
+/** Whether GitLens can actually answer a blocking permission ask from this agent. Two conditions,
+ *  deliberately separate: the agent must support blocking hooks at all, AND the response we build
+ *  must be one it understands. {@link PermissionResponse} is Claude-shaped
+ *  (`hookSpecificOutput.hookEventName: 'PermissionRequest'`), so an agent that supports blocking
+ *  hooks but expects a different envelope stays observe-only until per-agent response builders land
+ *  — at which point the second clause is what gets deleted. */
+function canAnswerBlockingPermission(capabilities) {
+    return capabilities.supportsBlockingPermissions && capabilities.hookClientId === 'claude-code';
+}
 /** Synthesizes an unresolvable ask for a `permission_requested` row that has no routable
  *  `PendingPermission` — a non-blocking `Notification`/`PermissionRequest` tail, or a
  *  poll-discovered live/revived row. None of these hold a blocking hook entry to route an
@@ -170,6 +275,56 @@ function fileActivityStructurallyEqual(a, b) {
     }
     return true;
 }
+/**
+ * Maps what `claude agents --json` reports for a live session onto `AgentSessionStatus`, per Claude's
+ * documented agent-view vocabulary.
+ *
+ * `kind: 'interactive'` entries carry `status` while their process is alive, plus `waitingFor` when
+ * that status is `waiting` — `'permission prompt'` is the one value with a distinct status of its own
+ * here, since a permission request is a different kind of block from an ordinary question.
+ *
+ * `kind: 'background'` entries carry `state` instead: `working` / `blocked` / `done` / `failed` /
+ * `stopped`, where `blocked` IS the documented "needs input" state.
+ *
+ * Returns `undefined` for a background session in a TERMINAL state. `--json` lists background
+ * sessions "still working or blocked even when their process has exited", so a listing is not by
+ * itself proof of life — without this, a genuinely finished session would be resurrected as `idle`,
+ * which is the opposite of the bug this mapping exists to fix. Callers must not treat such an entry
+ * as live: ended-record paths trust the durable record, while active discovery/repair paths skip or
+ * remove the stale active row.
+ *
+ * Anything unrecognized degrades to `'idle'` rather than guessing a working/waiting phase.
+ */
+/** Resolves a non-terminal listing override for an `ended` record. `undefined` means "let the ended
+ *  record stand": either the listing doesn't mention this session, or its background state is
+ *  terminal (see {@link statusFromLiveSession}). Active-record paths inspect the entry separately
+ *  because they must distinguish absence (unknown; keep record status) from terminal (skip/remove). */
+function liveOverrideFor(liveSessions, sessionId) {
+    const live = liveSessions?.get(sessionId);
+    if (live == null)
+        return undefined;
+    const status = statusFromLiveSession(live);
+    return status != null ? { live: live, status: status } : undefined;
+}
+function statusFromLiveSession(live) {
+    switch (live.status) {
+        case 'waiting':
+            return live.waitingFor === 'permission prompt' ? 'permission_requested' : 'waiting';
+        case 'busy':
+            return 'thinking';
+    }
+    switch (live.state) {
+        case 'blocked':
+            return 'waiting';
+        case 'working':
+            return 'thinking';
+        case 'done':
+        case 'failed':
+        case 'stopped':
+            return undefined;
+    }
+    return 'idle';
+}
 /** True when a CLI invocation failed because it didn't recognize a flag/command. `--status` and the
  *  active-only `list-sessions` default shipped together (gk 3.1.69); an older CLI rejects `--status`
  *  and returns all sessions unfiltered, so the flagless retry is the correct legacy equivalent. */
@@ -177,11 +332,15 @@ function isUnknownFlagError(ex) {
     const message = ex instanceof Error ? ex.message : String(ex);
     return /unknown (?:flag|shorthand flag|command)/i.test(message);
 }
-export class ClaudeCodeProvider {
+export class GkAgentProvider {
     callbacks;
-    id = 'claudeCode';
-    name = 'Claude Code';
+    /** Identifies the PROVIDER, not an agent: this one hosts every `gk ai hook` client GitLens has
+     *  a descriptor for. A session's own agent identity lives on {@link AgentSession.providerId}
+     *  (`claudeCode`, `codex`, …), sourced from {@link AgentCapabilities} — never from here. */
+    id = 'gkAgents';
+    name = 'Coding Agents';
     icon = 'robot';
+    agentProviderIds = agentCapabilities.map(c => c.providerId);
     _onDidChangeSessions = new Emitter();
     onDidChangeSessions = this._onDidChangeSessions.event;
     _sessions = [];
@@ -206,22 +365,38 @@ export class ClaudeCodeProvider {
     _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}.
+    /** Whether agent hooks are installed, pushed by the host via {@link setHooksInstalled}.
      *  Fail-open (`true`) until the first push lands so a fresh window with real hooks isn't
      *  suppressed on its first ticks. Gates the reconciliation poll in {@link syncSessions}. */
-    _claudeHooksInstalled = true;
+    _hooksInstalled = true;
     /** Whether the CLI supports `list-sessions --status` (and with it the durable ended-session
      *  store). Optimistic until the poll's flagless fallback proves otherwise. When unsupported,
-     *  completed rows are untenable — no poll can ever confirm or archive one — so `SessionEnd`
-     *  reverts to removing the session and reconciliation drops any completed stragglers. */
+     *  ended rows are untenable — no poll can ever confirm or archive one — so `SessionEnd`
+     *  reverts to removing the session and reconciliation drops any ended stragglers. */
     _statusFilterSupported = true;
     _transcriptReader = new ClaudeCodeTranscriptReader();
+    _terminalGeneration = 0;
+    /** Ended-transcript detail results, cached forever per window — an ended transcript is
+     *  immutable, so once resolved it never needs a second read. Keyed by session id. */
+    _sessionDetailsCache = new Map();
     constructor(callbacks) {
         this.callbacks = callbacks;
     }
     get sessions() {
         return this._sessions;
     }
+    get terminalGeneration() {
+        return this._terminalGeneration;
+    }
+    /** Single choke point for every terminal transition — a session ending, being removed on end
+     *  (legacy path), being pruned, or a fresh ended record being discovered. Bumps the generation
+     *  the host's history queries validate against (a transition mid-query means the answer may be
+     *  missing a session) and drops the transcript listing caches, whose warm entries may predate
+     *  the transcript the transition just left behind. */
+    noteTerminalTransition() {
+        this._terminalGeneration++;
+        this._transcriptReader.invalidateListings();
+    }
     start(workspacePaths) {
         this._workspacePaths = workspacePaths.map(p => normalizePath(p));
         void this.ensureIpcServer();
@@ -271,12 +446,12 @@ export class ClaudeCodeProvider {
             // Re-publish so the agents discovery file reflects the new workspacePaths.
             this.callbacks.ipc
                 .publishAgents(this._workspacePaths)
-                .catch((ex) => Logger.error(ex, 'ClaudeCodeProvider.updateWorkspacePaths: publishAgents failed'));
+                .catch((ex) => Logger.error(ex, 'GkAgentProvider.updateWorkspacePaths: publishAgents failed'));
         }
     }
-    setClaudeHooksInstalled(installed) {
-        const wasOff = !this._claudeHooksInstalled;
-        this._claudeHooksInstalled = installed;
+    setHooksInstalled(installed) {
+        const wasOff = !this._hooksInstalled;
+        this._hooksInstalled = installed;
         // On a fresh off→on transition, reconcile immediately rather than waiting up to a full
         // interval — picks up any session that was already running before hooks were installed.
         // This is a deliberate discovery pass (like the cold-start bootstrap), not a routine tick:
@@ -287,24 +462,100 @@ export class ClaudeCodeProvider {
             void this.syncSessions();
         }
     }
-    /** Reads past sessions out of Claude's transcript store. Claude homes each transcript under the
-     *  directory encoding the session's current cwd (migrating it if the session `cd`s), so the
-     *  directory for `cwd` is exactly what `claude --resume <id>` can find when invoked from there —
-     *  every session returned is resumable from `cwd`. */
-    async listResumableSessions(cwd, options) {
-        const { sessions, total } = await this._transcriptReader.listSessions(cwd, {
-            limit: options?.limit,
-            excludeSessionIds: options?.excludeSessionIds,
-        });
-        const resumable = sessions.map(s => ({
-            id: s.sessionId,
-            providerId: this.id,
-            cwd: cwd,
-            lastActivity: new Date(s.lastActivityMs),
-            titles: s.titles,
-            lastPrompt: s.lastPrompt,
-        }));
-        return { sessions: resumable, total: total };
+    /** Reads Claude history from its transcript store and tracked terminal records. The exact project
+     *  directory preserves legacy sessions that predate the CLI's durable records. Recent ended
+     *  records add an authoritative worktree-to-session association, so their ids are also recovered
+     *  from other project directories when Claude left the transcript behind after a cwd/worktree
+     *  move. A tracked record with no readable transcript remains visible and archivable, but does not
+     *  advertise Resume. Archive filtering stays provider-local so ids from another harness cannot
+     *  suppress Claude rows. `requireResume` drops the transcript-less tracked records, leaving only
+     *  rows that carry a resume action — and a `total` counting only those. */
+    async listSessionHistory(cwd, options) {
+        const resumeOnly = options?.requireResume === true;
+        // No launcher means no row can carry resume, so a resume-only query has nothing to return.
+        if (resumeOnly && this.callbacks.resumeSession == null)
+            return { sessions: [], total: 0 };
+        const archivedSessionIds = new Set(await this.getArchivedSessionIds());
+        const excludeSessionIds = new Set(options?.excludeSessionIds);
+        for (const id of archivedSessionIds) {
+            excludeSessionIds.add(id);
+        }
+        const trackedEndedSessions = [];
+        const endedSessionIds = new Set();
+        for (const session of this._sessions) {
+            if (session.status === 'ended' &&
+                session.worktreePath != null &&
+                arePathsEqual(session.worktreePath, cwd) &&
+                !excludeSessionIds.has(session.id)) {
+                // A tracked record's own row carries archive but no resume; its id still drives transcript
+                // recovery below, which does produce a resumable row when the transcript moved with it.
+                if (!resumeOnly) {
+                    trackedEndedSessions.push(session);
+                }
+                // Only an agent whose sessions can be resumed feeds transcript recovery. The reader is
+                // Claude-transcript-specific, so another agent's id could only ever miss — but stating it
+                // keeps the resume capability the reason, rather than leaving it to a coincidence of which
+                // store the reader happens to read.
+                if (getAgentCapabilitiesByProviderId(session.providerId)?.supportsResume !== false) {
+                    endedSessionIds.add(session.id);
+                }
+            }
+        }
+        const [direct, recovered] = await Promise.all([
+            this._transcriptReader.listSessions(cwd, {
+                limit: options?.limit,
+                excludeSessionIds: excludeSessionIds,
+            }),
+            this._transcriptReader.listSessionsByIds(endedSessionIds, {
+                limit: options?.limit,
+                excludeCwd: cwd,
+            }),
+        ]);
+        const historyById = new Map();
+        const addTranscript = (session, resumeCwd) => {
+            if (excludeSessionIds.has(session.sessionId))
+                return;
+            const disposition = archivedSessionIds.has(session.sessionId) ? 'archived' : 'ended';
+            const resumeActions = this.callbacks.resumeSession != null ? { resume: { cwd: resumeCwd } } : {};
+            historyById.set(session.sessionId, {
+                id: session.sessionId,
+                // The reader only reads Claude Code's transcript store, so every row it produces is
+                // Claude's by construction.
+                providerId: claudeCodeCapabilities.providerId,
+                disposition: disposition,
+                actions: disposition === 'ended' ? { ...resumeActions, archive: true } : resumeActions,
+                lastActivity: new Date(session.lastActivityMs),
+                titles: session.titles,
+                lastPrompt: session.lastPrompt,
+            });
+        };
+        for (const session of direct.sessions) {
+            addTranscript(session, cwd);
+        }
+        for (const session of recovered.sessions) {
+            addTranscript(session, session.cwd);
+        }
+        for (const session of trackedEndedSessions) {
+            if (historyById.has(session.id))
+                continue;
+            historyById.set(session.id, {
+                id: session.id,
+                providerId: session.providerId,
+                disposition: 'ended',
+                actions: { archive: true },
+                lastActivity: session.lastActivity,
+                name: session.name,
+                titles: session.transcriptTitles,
+                firstPrompt: session.firstPrompt,
+                lastPrompt: session.lastPrompt,
+            });
+        }
+        const history = [...historyById.values()].sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
+        const limited = options?.limit != null && options.limit > 0 ? history.slice(0, options.limit) : history;
+        return { sessions: limited, total: Math.max(direct.total + recovered.total, history.length) };
+    }
+    resumeSession(sessionId, cwd, target, name) {
+        return this.callbacks.resumeSession?.(sessionId, cwd, target, name) ?? Promise.resolve(false);
     }
     dispose() {
         this._disposed = true;
@@ -350,11 +601,11 @@ export class ClaudeCodeProvider {
                 return Promise.resolve();
             }),
             this.callbacks.ipc.registerHandler('agents/sessions/list', () => Promise.resolve(
-            // Exclude terminal `completed` rows: an older-version peer has no `completed` phase and
-            // would import them as phantom "idle" sessions. Our own poll surfaces completed sessions
+            // Exclude terminal `ended` rows: an older-version peer has no `ended` phase and
+            // would import them as phantom "idle" sessions. Our own poll surfaces ended sessions
             // independently, so peers never need them from here.
             this._sessions
-                .filter(s => s.status !== 'completed')
+                .filter(s => s.status !== 'ended')
                 .map(s => ({
                 ...s,
                 lastActivity: s.lastActivity.toISOString(),
@@ -375,7 +626,7 @@ export class ClaudeCodeProvider {
                     return { opened: true };
                 }
                 catch (ex) {
-                    Logger.warn(`ClaudeCodeProvider.agents/sessions/open: ${ex instanceof Error ? ex.message : String(ex)}`);
+                    Logger.warn(`GkAgentProvider.agents/sessions/open: ${ex instanceof Error ? ex.message : String(ex)}`);
                     return { opened: false };
                 }
             }),
@@ -388,7 +639,7 @@ export class ClaudeCodeProvider {
             for (const d of handlers) {
                 d.dispose();
             }
-            Logger.error(ex, 'ClaudeCodeProvider.ensureIpcServer');
+            Logger.error(ex, 'GkAgentProvider.ensureIpcServer');
             return;
         }
         // `publishAgents` no-ops silently if the IPC server failed to start; don't seal
@@ -416,19 +667,35 @@ export class ClaudeCodeProvider {
             this._staleCheckTimer = disposableInterval(() => void this.syncSessions({ gate: true }), staleCheckIntervalMs);
         }
         catch (ex) {
-            Logger.error(ex, 'ClaudeCodeProvider.ensureIpcServer');
+            Logger.error(ex, 'GkAgentProvider.ensureIpcServer');
         }
     }
     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}`);
+        // The CLI broadcasts every AI host's events to every listener, stamped with its `gk ai hook`
+        // client id. Absent = `claude-code`: older CLIs don't stamp it, and no other client existed
+        // then. A client we hold no descriptor for is dropped — the CLI supports more than this table
+        // does, and we can't interpret an agent whose vocabulary we don't know. A dropped blocking
+        // request gets no decision, so the CLI waits out its own hook timeout, which is correct: we
+        // must not answer for an agent we don't track.
+        const hookClientId = event.providerId ?? 'claude-code';
+        const capabilities = getAgentCapabilities(hookClientId);
+        if (capabilities == null) {
+            Logger.debug(`GkAgentProvider.handleSessionEvent: ignoring ${event.event} from ${hookClientId}`);
             return Promise.resolve();
         }
+        // The CLI relays each agent's native event name verbatim, so translate before doing anything
+        // else. An unresolvable name must never reach the switch below: it would match no case while
+        // still having created/updated a row, and for a blocking delivery would answer nothing while
+        // looking handled.
+        const hookEvent = resolveCanonicalHookEvent(capabilities, event.event, event.hookInput);
+        if (hookEvent == null) {
+            Logger.debug(`GkAgentProvider.handleSessionEvent: ignoring unmapped event ${event.event} from ${hookClientId}`);
+            return Promise.resolve();
+        }
+        const toolName = canonicalToolNameFromEvent(capabilities, event);
         const workspacePath = this.resolveWorkspacePath(event.cwd);
         const eventContext = {
+            capabilities: capabilities,
             pid: event.pid,
             workspacePath: workspacePath,
             isInWorkspace: workspacePath != null,
@@ -438,15 +705,18 @@ export class ClaudeCodeProvider {
             sessionName: event.sessionName,
             model: event.model,
             worktreePath: worktreeFromEvent(event),
+            visitedWorktreePaths: visitedFromTimeline(event.cwdTimeline),
         };
         const tag = this.sessionTag(event.sessionId, event.sessionName ?? 'unnamed');
-        if (event.event === 'SessionStart' || event.event === 'SessionEnd') {
-            Logger.info(`ClaudeCodeProvider.handleSessionEvent: ${event.event} ${tag}`);
+        // Log the native name alongside the canonical one — a mapping mistake is otherwise invisible.
+        const eventTag = event.event === hookEvent ? hookEvent : `${hookEvent}(${event.event})`;
+        if (hookEvent === 'SessionStart' || hookEvent === 'SessionEnd') {
+            Logger.info(`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}`);
         }
         else {
-            Logger.debug(`ClaudeCodeProvider.handleSessionEvent: ${event.event} ${tag}${event.toolName ? ` tool=${event.toolName}` : ''}${event.agentId ? ` agent=${event.agentId}` : ''}${event.notificationType ? ` type=${event.notificationType}` : ''}`);
+            Logger.debug(`GkAgentProvider.handleSessionEvent: ${eventTag} ${tag}${toolName ? ` tool=${toolName}` : ''}${event.agentId ? ` agent=${event.agentId}` : ''}${event.notificationType ? ` type=${event.notificationType}` : ''}`);
         }
-        switch (event.event) {
+        switch (hookEvent) {
             case 'SessionStart': {
                 const wasNew = this._sessions.findIndex(s => s.id === event.sessionId) < 0;
                 const { index } = this.ensureSession(event.sessionId, eventContext);
@@ -463,10 +733,10 @@ export class ClaudeCodeProvider {
                 }
                 else {
                     const prev = this._sessions[index];
-                    if (prev.status === 'completed') {
-                        // Resuming a terminal session reuses its id, so a SessionStart on a completed
+                    if (prev.status === 'ended') {
+                        // Resuming a terminal session reuses its id, so a SessionStart on an ended
                         // row IS the resume signal — revive it to a live `idle` row (clearing the
-                        // completed/archivable state) with clean bookkeeping that completeSession tore
+                        // ended/archivable state) with clean bookkeeping that endSession tore
                         // down. The next real event advances it out of idle. A `SessionStart` arrives on
                         // THIS window's hook flow, so the resume is locally owned now: clear the peer
                         // ownership carried over from the terminal record, and take the resume's pid
@@ -492,7 +762,7 @@ export class ClaudeCodeProvider {
                 }
                 this._onDidChangeSessions.fire();
                 void this.resolveTranscriptTitles(event.sessionId, event.cwd);
-                this.callbacks.onSessionStarted?.(this.id);
+                this.callbacks.onSessionStarted?.(capabilities.providerId);
                 break;
             }
             case 'SessionEnd': {
@@ -505,13 +775,13 @@ export class ClaudeCodeProvider {
                 const index = this._sessions.findIndex(s => s.id === event.sessionId);
                 if (index >= 0) {
                     if (this._statusFilterSupported) {
-                        // Transition to a terminal `completed` row rather than removing it — completed
+                        // Transition to a terminal `ended` row rather than removing it — ended
                         // sessions stay visible (de-emphasized) until archived or 30-day-purged by the CLI.
-                        this.completeSession(index, new Date());
+                        this.endSession(index, new Date());
                     }
                     else {
-                        // Legacy CLI (no `--status` durable store): a completed row could never be
-                        // poll-confirmed nor archived, so keep the pre-completed remove-on-end behavior.
+                        // Legacy CLI (no `--status` durable store): an ended row could never be
+                        // poll-confirmed nor archived, so keep the pre-ended remove-on-end behavior.
                         this._sessions.splice(index, 1);
                         const bk = this._sessionBookkeeping.get(event.sessionId);
                         if (bk != null) {
@@ -520,6 +790,7 @@ export class ClaudeCodeProvider {
                         }
                         this._sessionBookkeeping.delete(event.sessionId);
                         this._transcriptReader.forget(event.sessionId);
+                        this.noteTerminalTransition();
                     }
                     this._onDidChangeSessions.fire();
                 }
@@ -534,8 +805,11 @@ export class ClaudeCodeProvider {
                     }
                     this._sessionBookkeeping.delete(event.sessionId);
                     this._transcriptReader.forget(event.sessionId);
+                    // Untracked or not, a session just reached a terminal state and finalized its
+                    // transcript — an in-flight history query must not accept an answer that predates it.
+                    this.noteTerminalTransition();
                 }
-                this.callbacks.onSessionEnded?.(this.id);
+                this.callbacks.onSessionEnded?.(capabilities.providerId);
                 break;
             }
             case 'UserPromptSubmit': {
@@ -565,15 +839,13 @@ export class ClaudeCodeProvider {
             case 'PreToolUse': {
                 const bk = this.getBookkeeping(event.sessionId);
                 bk.activeToolCount++;
-                const filesChanged = this.trackToolUseFile(event.sessionId, event);
-                const readsChanged = this.trackToolUseRead(event.sessionId, event);
+                const filesChanged = this.trackToolUseFile(event.sessionId, event, capabilities);
+                const readsChanged = this.trackToolUseRead(event.sessionId, event, capabilities);
                 // Resolve a rich `Bash(grep …)`-style detail via the same tool_input passthrough the
                 // PermissionRequest handler uses, so working sessions surface what their tool is
                 // actually doing — not just the bare tool name. Falls back to bare name when no
                 // toolInput is available (older CLI / unhandled tool).
-                const hookInput = event.hookInput;
-                const toolInput = hookInput?.tool_input ?? event.toolInput;
-                const toolName = hookInput?.tool_name ?? event.toolName ?? '';
+                const toolInput = event.hookInput?.tool_input ?? event.toolInput;
                 const statusDetail = toolInput != null && toolName ? describeToolInput(toolName, toolInput) : toolName || undefined;
                 // Capture pre-update status so we can tell whether the upcoming updateSessionStatus
                 // will fire on its own — needed to avoid dropping fileActivity changes when the
@@ -593,7 +865,7 @@ export class ClaudeCodeProvider {
             }
             case 'PostToolUse':
             case 'PostToolUseFailure': {
-                this.clearStalePermission(event.sessionId, event.event, this.settledByFromEvent(event));
+                this.clearStalePermission(event.sessionId, hookEvent, this.settledByFromEvent(event, capabilities));
                 const bk = this.getBookkeeping(event.sessionId);
                 bk.activeToolCount = Math.max(0, bk.activeToolCount - 1);
                 // Cooldown the file-edit decoration instead of dropping it immediately, so a quick
@@ -602,8 +874,8 @@ export class ClaudeCodeProvider {
                 // `editing`/`reading` off the moment refcount hits zero, though — capture whether that
                 // changed the published list so we fire it ourselves when the status update below short-
                 // circuits (a parallel tool is still in flight, so activeToolCount stays > 0).
-                const filesChanged = this.scheduleClearToolUseFile(event.sessionId, event);
-                const readsChanged = this.scheduleClearToolUseRead(event.sessionId, event);
+                const filesChanged = this.scheduleClearToolUseFile(event.sessionId, event, capabilities);
+                const readsChanged = this.scheduleClearToolUseRead(event.sessionId, event, capabilities);
                 if (bk.activeToolCount === 0) {
                     // updateSessionStatus short-circuits without firing when status+detail are unchanged
                     // (already 'thinking' with no detail) — which would drop the editing/reading flag-flip
@@ -662,8 +934,8 @@ export class ClaudeCodeProvider {
                     case 'permission_prompt':
                         this.updateSessionStatus(event.sessionId, 'permission_requested', {
                             ...eventContext,
-                            statusDetail: event.toolName,
-                            pendingPermission: synthesizeUnresolvableAsk(event.toolName, 
+                            statusDetail: toolName,
+                            pendingPermission: synthesizeUnresolvableAsk(toolName, 
                             // Plan-kind body: prefer the session's planFile, fall back to the event's
                             // — mirrors the blocking path.
                             this._sessions.find(s => s.id === event.sessionId)?.planFile ?? event.planFile),
@@ -675,11 +947,11 @@ export class ClaudeCodeProvider {
                         // hook produces.
                         this.updateSessionStatus(event.sessionId, 'permission_requested', {
                             ...eventContext,
-                            statusDetail: event.toolName,
+                            statusDetail: toolName,
                             pendingPermission: {
                                 kind: 'elicitation',
-                                toolName: event.toolName ?? 'Input Required',
-                                toolDescription: event.toolName ?? 'Waiting for input',
+                                toolName: toolName ?? 'Input Required',
+                                toolDescription: toolName ?? 'Waiting for input',
                                 resolvable: false,
                             },
                         });
@@ -693,11 +965,14 @@ export class ClaudeCodeProvider {
                 // hookInput is the raw passthrough; fall back to top-level fields for older CLI versions.
                 const hookInput = event.hookInput;
                 const toolInput = hookInput?.tool_input ?? event.toolInput;
-                if (isBlocking && toolInput != null) {
-                    const toolName = hookInput?.tool_name ?? event.toolName ?? '';
-                    const toolDescription = describeToolInput(toolName, toolInput);
+                // An agent whose asks we can't answer falls through to the observe-only branch below,
+                // which publishes the same card marked `resolvable: false`. Registering a pending entry
+                // for it would promise an Allow/Deny this window can never route.
+                if (canAnswerBlockingPermission(capabilities) && isBlocking && toolInput != null) {
+                    const askToolName = toolName ?? '';
+                    const toolDescription = describeToolInput(askToolName, toolInput);
                     const toolInputDescription = toolInput.description || undefined;
-                    const kind = classifyPermissionKind(toolName);
+                    const kind = classifyPermissionKind(askToolName);
                     const toolUseId = hookInput?.tool_use_id;
                     const toolInputJson = stableStringify(toolInput);
                     return new Promise((resolve, reject) => {
@@ -708,7 +983,7 @@ export class ClaudeCodeProvider {
                             ((existing.toolUseId != null && toolUseId != null && existing.toolUseId === toolUseId) ||
                                 (existing.toolUseId == null &&
                                     toolUseId == null &&
-                                    existing.toolName === toolName &&
+                                    existing.toolName === askToolName &&
                                     existing.toolInputJson === toolInputJson));
                         if (isDuplicateDelivery) {
                             // Duplicate delivery of the same ask (CLI retry after its 60s response-header
@@ -721,7 +996,7 @@ export class ClaudeCodeProvider {
                             return;
                         }
                         if (existing != null) {
-                            Logger.debug(`ClaudeCodeProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`);
+                            Logger.debug(`GkAgentProvider.handleSessionEvent: auto-denying stale permission ${tag} tool=${existing.toolName}`);
                             this.resolveAllPending(existing, {
                                 hookSpecificOutput: {
                                     hookEventName: 'PermissionRequest',
@@ -731,7 +1006,7 @@ export class ClaudeCodeProvider {
                         }
                         this._pendingPermissions.set(event.sessionId, {
                             resolvers: [{ resolve: resolve, reject: reject }],
-                            toolName: toolName,
+                            toolName: askToolName,
                             toolDescription: toolDescription,
                             toolUseId: toolUseId,
                             toolInputJson: toolInputJson,
@@ -745,7 +1020,7 @@ export class ClaudeCodeProvider {
                         const questionDetails = kind === 'question' ? extractQuestionDetails(toolInput) : undefined;
                         const permission = {
                             kind: kind,
-                            toolName: toolName,
+                            toolName: askToolName,
                             toolDescription: toolDescription,
                             toolInputDescription: toolInputDescription,
                             suggestions: hookInput?.permission_suggestions ??
@@ -761,7 +1036,6 @@ export class ClaudeCodeProvider {
                 {
                     // 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'
@@ -786,18 +1060,18 @@ export class ClaudeCodeProvider {
                         : synthesizeUnresolvableAsk(toolName, planFilePath);
                     this.updateSessionStatus(event.sessionId, 'permission_requested', {
                         ...eventContext,
-                        statusDetail: event.toolName,
+                        statusDetail: toolName,
                         pendingPermission: synthesized,
                     });
                 }
                 break;
             }
             case 'PermissionDenied': {
-                this.clearStalePermission(event.sessionId, 'PermissionDenied', this.settledByFromEvent(event));
+                this.clearStalePermission(event.sessionId, 'PermissionDenied', this.settledByFromEvent(event, capabilities));
                 const bk = this.getBookkeeping(event.sessionId);
                 bk.activeToolCount = Math.max(0, bk.activeToolCount - 1);
-                const filesChanged = this.untrackToolUseFile(event.sessionId, event);
-                const readsChanged = this.untrackToolUseRead(event.sessionId, event);
+                const filesChanged = this.untrackToolUseFile(event.sessionId, event, capabilities);
+                const readsChanged = this.untrackToolUseRead(event.sessionId, event, capabilities);
                 // When a parallel tool is still active the next status equals the current one and
                 // updateSessionStatus short-circuits — without an explicit fire, the dropped path
                 // would never reach subscribers (treemap activity overlay, WIP decoration).
@@ -815,15 +1089,15 @@ export class ClaudeCodeProvider {
                 const bk = this.getBookkeeping(event.sessionId);
                 bk.pendingPermission = {
                     kind: 'elicitation',
-                    toolName: event.toolName ?? 'Input Required',
-                    toolDescription: event.toolName ?? 'Waiting for input',
+                    toolName: toolName ?? 'Input Required',
+                    toolDescription: toolName ?? 'Waiting for input',
                     // `Elicitation` arrives on a non-blocking hook, so no entry exists for
                     // `resolvePermission` to answer — the user responds in the agent's own session.
                     resolvable: false,
                 };
                 this.updateSessionStatus(event.sessionId, 'permission_requested', {
                     ...eventContext,
-                    statusDetail: event.toolName,
+                    statusDetail: toolName,
                 });
                 break;
             }
@@ -853,8 +1127,8 @@ export class ClaudeCodeProvider {
                     const now = new Date();
                     const subagent = {
                         id: event.agentId,
-                        providerId: this.id,
-                        providerName: this.name,
+                        providerId: capabilities.providerId,
+                        providerName: capabilities.displayName,
                         name: event.agentType ?? 'Subagent',
                         status: 'thinking',
                         phase: 'working',
@@ -902,6 +1176,20 @@ export class ClaudeCodeProvider {
             ? `[session=${sessionId.substring(0, 8)}(${name})]`
             : `[session=${sessionId.substring(0, 8)}]`;
     }
+    /** The owning agent's descriptor for a tracked session, resolved from the session's own
+     *  `providerId`. `undefined` when the session isn't tracked (pruned/archived since) or carries a
+     *  `providerId` the descriptor table doesn't know — callers pick their own fallback rather than
+     *  silently assuming Claude Code. */
+    getSessionCapabilities(sessionId) {
+        const session = this._sessions.find(s => s.id === sessionId);
+        return session != null ? getAgentCapabilitiesByProviderId(session.providerId) : undefined;
+    }
+    /** Whether the session's agent leaves a transcript on disk for {@link ClaudeCodeTranscriptReader}
+     *  to tail. Fails OPEN when no descriptor resolves, so an unknown/absent `providerId` can never
+     *  suppress the Claude path this reader exists for. */
+    supportsTranscripts(sessionId) {
+        return this.getSessionCapabilities(sessionId)?.supportsTranscripts ?? true;
+    }
     getBookkeeping(sessionId) {
         let bk = this._sessionBookkeeping.get(sessionId);
         if (bk == null) {
@@ -1009,8 +1297,8 @@ export class ClaudeCodeProvider {
      *  for older CLI versions that only fill the top-level fields. Treats an empty-object
      *  `hookInput.tool_input` as missing — `??` would have kept it (truthy) and shadowed a
      *  populated `event.toolInput`. */
-    getEventFilePath(event) {
-        const toolName = event.hookInput?.tool_name ?? event.toolName;
+    getEventFilePath(event, capabilities) {
+        const toolName = canonicalToolNameFromEvent(capabilities, event);
         if (toolName == null)
             return undefined;
         const rawHookInput = event.hookInput?.tool_input;
@@ -1049,8 +1337,8 @@ export class ClaudeCodeProvider {
      *  doesn't reliably surface) so parallel calls bump the count and Post/Pre order doesn't matter.
      *  Returns whether the parent's published `fileActivity` actually changed so callers can fire
      *  when the surrounding {@link updateSessionStatus} short-circuits. */
-    trackToolUseFile(sessionId, event) {
-        const filePath = this.getEventFilePath(event);
+    trackToolUseFile(sessionId, event, capabilities) {
+        const filePath = this.getEventFilePath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1073,8 +1361,8 @@ export class ClaudeCodeProvider {
      *  above zero. Returns whether the parent's published `fileActivity` changed (i.e. `editing`
      *  flipped off) so the PostToolUse caller can fire when its `updateSessionStatus` short-
      *  circuits (a parallel tool still in flight keeps activeToolCount > 0). */
-    scheduleClearToolUseFile(sessionId, event) {
-        const filePath = this.getEventFilePath(event);
+    scheduleClearToolUseFile(sessionId, event, capabilities) {
+        const filePath = this.getEventFilePath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1128,8 +1416,8 @@ export class ClaudeCodeProvider {
     /** Drops a tracked tool call's file immediately (no cooldown). Used for PermissionDenied,
      *  where the tool never ran — keeping the "live" badge would be misleading.
      *  Returns whether the published list changed. */
-    untrackToolUseFile(sessionId, event) {
-        const filePath = this.getEventFilePath(event);
+    untrackToolUseFile(sessionId, event, capabilities) {
+        const filePath = this.getEventFilePath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1150,8 +1438,8 @@ export class ClaudeCodeProvider {
         return this.syncSessionFileActivityForChild(sessionId);
     }
     /** Mirror of {@link getEventFilePath} for read-only file tools. */
-    getEventReadPath(event) {
-        const toolName = event.hookInput?.tool_name ?? event.toolName;
+    getEventReadPath(event, capabilities) {
+        const toolName = canonicalToolNameFromEvent(capabilities, event);
         if (toolName == null)
             return undefined;
         const rawHookInput = event.hookInput?.tool_input;
@@ -1160,8 +1448,8 @@ export class ClaudeCodeProvider {
         return getToolReadPath(toolName, toolInput);
     }
     /** Refcount mirror of {@link trackToolUseFile} for read-only file tools. */
-    trackToolUseRead(sessionId, event) {
-        const filePath = this.getEventReadPath(event);
+    trackToolUseRead(sessionId, event, capabilities) {
+        const filePath = this.getEventReadPath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1176,8 +1464,8 @@ export class ClaudeCodeProvider {
     }
     /** Cooldown mirror of {@link scheduleClearToolUseFile} for read-only file tools. Returns
      *  whether the parent's published `fileActivity` changed (i.e. `reading` flipped off). */
-    scheduleClearToolUseRead(sessionId, event) {
-        const filePath = this.getEventReadPath(event);
+    scheduleClearToolUseRead(sessionId, event, capabilities) {
+        const filePath = this.getEventReadPath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1219,8 +1507,8 @@ export class ClaudeCodeProvider {
         bk.pendingReadClears.set(filePath, timer);
     }
     /** Immediate-drop mirror of {@link untrackToolUseFile} for read-only file tools. */
-    untrackToolUseRead(sessionId, event) {
-        const filePath = this.getEventReadPath(event);
+    untrackToolUseRead(sessionId, event, capabilities) {
+        const filePath = this.getEventReadPath(event, capabilities);
         if (filePath == null)
             return false;
         const bk = this.getBookkeeping(sessionId);
@@ -1263,6 +1551,8 @@ export class ClaudeCodeProvider {
         if (index < 0)
             return false;
         const parent = this._sessions[index];
+        if (parent.status === 'ended')
+            return false;
         const parentBk = this._sessionBookkeeping.get(parentSessionId);
         const merged = new Map();
         const contributeFrom = (bk) => {
@@ -1333,10 +1623,10 @@ export class ClaudeCodeProvider {
         this.cancelPendingIdleTransition(sessionId);
         const timer = setTimeout(() => {
             this._pendingIdleTimers.delete(sessionId);
-            // Session may have been removed (SessionEnd, prune) during the window, or completed by a
+            // Session may have been removed (SessionEnd, prune) during the window, or ended by a
             // poll/SessionEnd that raced this timer — reviving a terminal row to idle would zombie it.
             const idx = this._sessions.findIndex(s => s.id === sessionId);
-            if (idx < 0 || this._sessions[idx].status === 'completed')
+            if (idx < 0 || this._sessions[idx].status === 'ended')
                 return;
             this.updateSessionStatus(sessionId, 'idle');
         }, stopToIdleDebounceMs);
@@ -1369,12 +1659,14 @@ export class ClaudeCodeProvider {
      *  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) {
+    settledByFromEvent(event, capabilities) {
         const hookInput = event.hookInput;
         const toolInput = hookInput?.tool_input ?? event.toolInput;
         return {
             toolUseId: hookInput?.tool_use_id,
-            toolName: hookInput?.tool_name ?? event.toolName,
+            // Canonical, because the registered ask's `toolName` is canonical too — comparing a native
+            // name against it would look like an identity mismatch and strand the ask.
+            toolName: canonicalToolNameFromEvent(capabilities, event),
             toolInputJson: toolInput != null ? stableStringify(toolInput) : undefined,
         };
     }
@@ -1424,11 +1716,11 @@ export class ClaudeCodeProvider {
                                 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'}`);
+                    Logger.debug(`GkAgentProvider.clearStalePermission: skip (identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${pending.toolUseId ?? pending.toolName} settledBy=${settledBy.toolUseId ?? settledBy.toolName ?? 'unknown'}`);
                     return;
                 }
             }
-            Logger.debug(`ClaudeCodeProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
+            Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
             this.resolveAllPending(pending, {
                 hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny' } },
             });
@@ -1441,17 +1733,25 @@ export class ClaudeCodeProvider {
         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}`);
+            Logger.debug(`GkAgentProvider.clearStalePermission: skip (display-only identity mismatch) ${reason} ${this.sessionTag(sessionId)} pending=${bk.pendingPermission.toolName} settledBy=${settledBy.toolName}`);
             return;
         }
-        Logger.debug(`ClaudeCodeProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
+        Logger.debug(`GkAgentProvider.clearStalePermission: ${reason} ${this.sessionTag(sessionId)}`);
         bk.pendingPermission = undefined;
     }
     resolvePermission(sessionId, decision, updatedPermissions) {
+        // Explicit refusal rather than an incidental one: an agent we can't answer for never registers
+        // a pending entry, so the `pending == null` check below would already return `false` — but the
+        // caller deserves to know WHY, and the guard has to survive a future entry-registering path.
+        const capabilities = this.getSessionCapabilities(sessionId);
+        if (capabilities != null && !canAnswerBlockingPermission(capabilities)) {
+            Logger.debug(`GkAgentProvider.resolvePermission: refusing ${decision} for ${this.sessionTag(sessionId)} — ${capabilities.displayName} asks are observe-only`);
+            return false;
+        }
         const pending = this._pendingPermissions.get(sessionId);
         if (pending == null)
             return false;
-        Logger.debug(`ClaudeCodeProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`);
+        Logger.debug(`GkAgentProvider.resolvePermission: ${decision} ${this.sessionTag(sessionId)} tool=${pending.toolName}`);
         this.resolveAllPending(pending, {
             hookSpecificOutput: {
                 hookEventName: 'PermissionRequest',
@@ -1459,7 +1759,7 @@ export class ClaudeCodeProvider {
             },
         });
         this.callbacks.onPermissionResolved?.({
-            provider: this.id,
+            provider: capabilities?.providerId ?? claudeCodeCapabilities.providerId,
             tool: pending.toolName,
             decision: decision,
         });
@@ -1472,16 +1772,16 @@ export class ClaudeCodeProvider {
     }
     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
+        // stale webview action (or a row that resumed out of `ended` since the click) must never
         // reach the CLI — archiving is only ever valid on a terminal row. Callers gate the UI too,
         // but this is the last line that owns live process safety. Returns `false` when refused so the
         // host doesn't record a success telemetry event for an archive that never happened.
         const session = this._sessions.find(s => s.id === sessionId);
-        if (session != null && session.status !== 'completed') {
-            Logger.warn(`ClaudeCodeProvider.archiveSession: refusing to archive non-completed ${this.sessionTag(sessionId)} (status=${session.status})`);
+        if (session != null && session.status !== 'ended') {
+            Logger.warn(`GkAgentProvider.archiveSession: refusing to archive non-ended ${this.sessionTag(sessionId)} (status=${session.status})`);
             return false;
         }
-        Logger.debug(`ClaudeCodeProvider.archiveSession: ${this.sessionTag(sessionId)}`);
+        Logger.debug(`GkAgentProvider.archiveSession: ${this.sessionTag(sessionId)}`);
         await this.callbacks.runCLICommand(['ai', 'hook', 'archive-session', sessionId, '--json']);
         // Invalidate the archived-id cache so the next `getPastSessions` re-fetches and excludes this id.
         this._archivedSessionIdsCache = undefined;
@@ -1526,28 +1826,60 @@ export class ClaudeCodeProvider {
             return [];
         }
     }
-    resolveCompletedSessionDetails(sessionId) {
+    resolveEndedSessionDetails(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')
+        // Only ended sessions defer resolution; live sessions resolve eagerly on discovery.
+        if (session?.status !== 'ended')
             return;
         // The durable store drops the prompt (and only ever carries an auto-slug name) for most ended
         // sessions, so read the terminal transcript once on demand to recover a real title + the
         // first/last prompt. Both the git probe and transcript read sit under the guard so repeated
         // opens don't re-probe git or re-read a possibly-large file.
         const bk = this.getBookkeeping(sessionId);
-        if (bk.completedDetailsResolved)
+        if (bk.endedDetailsResolved)
             return;
-        bk.completedDetailsResolved = true;
+        bk.endedDetailsResolved = true;
         if (session.cwd) {
             void this.resolveGitInfo(sessionId, session.cwd);
         }
-        void this.applyCompletedTranscriptDetails(sessionId, session.cwd);
+        // Git identity resolves for every agent; the transcript read is Claude-only (see
+        // `resolveTranscriptTitles`).
+        if (this.supportsTranscripts(sessionId)) {
+            void this.applyEndedTranscriptDetails(sessionId, session.cwd);
+        }
+    }
+    /** No `_sessions` gate, unlike {@link resolveEndedSessionDetails} — must work for a
+     *  transcript-only id this window never tracked live (past-session-sheet callers). */
+    async resolveSessionDetails(sessionId, cwd) {
+        // The reader only reads Claude Code's store, so an agent that leaves no transcript can only
+        // ever miss here. Reachable rather than theoretical: an ended session of ANY agent becomes a
+        // Past row, and opening its sheet routes here by `providerId`. `supportsTranscripts` fails
+        // open, so the transcript-only ids this method exists for — untracked, therefore capability-
+        // less, and Claude's by construction since only its store produces them — still resolve.
+        if (!this.supportsTranscripts(sessionId))
+            return undefined;
+        let cached = this._sessionDetailsCache.get(sessionId);
+        if (cached == null) {
+            cached = this._transcriptReader.resolveEndedDetails(sessionId, cwd).catch((ex) => {
+                // A read error (transient I/O, permissions) is not terminal state — drop the cache
+                // entry so a later call retries. A resolved `undefined` IS terminal (no transcript on
+                // disk) and stays cached.
+                this._sessionDetailsCache.delete(sessionId);
+                throw ex;
+            });
+            this._sessionDetailsCache.set(sessionId, cached);
+        }
+        try {
+            return await cached;
+        }
+        catch {
+            return undefined;
+        }
     }
-    async applyCompletedTranscriptDetails(sessionId, cwd) {
+    async applyEndedTranscriptDetails(sessionId, cwd) {
         let details;
         try {
-            details = await this._transcriptReader.resolveCompletedDetails(sessionId, cwd);
+            details = await this._transcriptReader.resolveEndedDetails(sessionId, cwd);
         }
         catch {
             // A read error (transient I/O, permissions) is not terminal state — clear the once-only
@@ -1555,7 +1887,7 @@ export class ClaudeCodeProvider {
             // so it keeps the guard and never re-scans.
             const bk = this._sessionBookkeeping.get(sessionId);
             if (bk != null) {
-                bk.completedDetailsResolved = false;
+                bk.endedDetailsResolved = false;
             }
             return;
         }
@@ -1566,7 +1898,7 @@ export class ClaudeCodeProvider {
             return;
         const session = this._sessions[index];
         // The session may have been archived/removed while we were reading.
-        if (session.status !== 'completed')
+        if (session.status !== 'ended')
             return;
         const { titles } = details;
         const nextTitles = titles.custom != null || titles.ai != null || titles.agent != null
@@ -1684,18 +2016,23 @@ export class ClaudeCodeProvider {
         }
     }
     ensureSession(sessionId, context) {
-        const { pid, workspacePath, isInWorkspace, cwd, initialCwd, planFile, sessionName, model, worktreePath } = context ?? {};
+        const { capabilities, pid, workspacePath, isInWorkspace, cwd, initialCwd, planFile, sessionName, model, worktreePath, visitedWorktreePaths, } = context ?? {};
         let index = this._sessions.findIndex(s => s.id === sessionId);
         if (index < 0) {
             const now = new Date();
             // Same worktree-derived fallback as the update branch below: a session created with a
             // scratch cwd but a CLI-seated worktree still belongs to that worktree's workspace.
             const createdWorkspacePath = workspacePath ?? this.resolveWorkspacePath(worktreePath);
+            // Identity comes from the owning agent's descriptor, never from the provider — Claude's
+            // `providerId` stays the `claudeCode` the descriptor encodes. The fallback covers the
+            // deferred-commit paths (see `SessionContext.capabilities`), which only ever run against a
+            // row that already exists; reaching it would mean a row created outside every event path.
+            const identity = capabilities ?? claudeCodeCapabilities;
             index = this._sessions.length;
             this._sessions.push({
                 id: sessionId,
-                providerId: this.id,
-                providerName: this.name,
+                providerId: identity.providerId,
+                providerName: identity.displayName,
                 name: sessionName || undefined,
                 status: 'idle',
                 phase: getPhaseForStatus('idle'),
@@ -1710,8 +2047,9 @@ export class ClaudeCodeProvider {
                 isInWorkspace: createdWorkspacePath != null ? true : (isInWorkspace ?? false),
                 model: model,
                 worktreePath: worktreePath != null ? normalizePath(worktreePath) : undefined,
+                visitedWorktreePaths: unionVisited(undefined, visitedWorktreePaths, worktreePath),
             });
-            Logger.debug(`ClaudeCodeProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`);
+            Logger.debug(`GkAgentProvider.ensureSession: implicitly created ${this.sessionTag(sessionId, sessionName ?? 'unnamed')}`);
             if (worktreePath != null) {
                 this.getBookkeeping(sessionId).cliSeatedWorktree = true;
             }
@@ -1738,6 +2076,7 @@ export class ClaudeCodeProvider {
         // present, so it seats ahead of the `resolveGitInfo` probe below (which still fills
         // `commonPath` and remains the fallback for older CLIs that don't send `cwdTimeline`).
         const updatedWorktreePath = worktreePath != null ? normalizePath(worktreePath) : existing.worktreePath;
+        const updatedVisitedWorktreePaths = unionVisited(existing.visitedWorktreePaths, visitedWorktreePaths, updatedWorktreePath);
         // Workspace membership follows the ATTRIBUTION, not the raw cwd: a scratch-dir excursion
         // (cwd in /tmp, worktree kept) stays in-workspace via its worktree, while a genuine move to
         // a repo outside the workspace honestly drops membership when events carry a cwd.
@@ -1766,7 +2105,8 @@ export class ClaudeCodeProvider {
             updatedModel !== existing.model ||
             updatedCwd !== existing.cwd ||
             updatedInitialCwd !== existing.initialCwd ||
-            updatedWorktreePath !== existing.worktreePath) {
+            updatedWorktreePath !== existing.worktreePath ||
+            updatedVisitedWorktreePaths !== existing.visitedWorktreePaths) {
             this._sessions[index] = {
                 ...existing,
                 name: updatedName,
@@ -1778,6 +2118,7 @@ export class ClaudeCodeProvider {
                 planFile: updatedPlanFile,
                 isInWorkspace: updatedIsInWorkspace,
                 worktreePath: updatedWorktreePath,
+                visitedWorktreePaths: updatedVisitedWorktreePaths,
                 // A worktree move can cross repos, and the spread would otherwise carry the old repo
                 // identity forward — which consumers prefer over the new worktree, pinning the card to
                 // the wrong repo. Drop it; the probe below refills it. Mirrors the poll's ended-record
@@ -1806,7 +2147,11 @@ export class ClaudeCodeProvider {
         // call per hook event for an answer we already have. A first seat (no prior worktree) still
         // counts as a location change: the move may be out of a non-git dir whose probe latched
         // `gitInfoUnresolvable`, and `commonPath` still needs the probe.
-        const locationNeedsProbe = cwdMoved && (worktreePath == null || worktreeMoved || existing.worktreePath == null);
+        //
+        // A worktree move is a location change on its own, even with the SAME cwd (cwdTimeline
+        // updated, cwd unchanged) — the `commonPath` drop above (`worktreeMoved ? undefined : …`)
+        // needs the probe to refill it, and without `worktreeMoved` here nothing else would fire it.
+        const locationNeedsProbe = worktreeMoved || (cwdMoved && (worktreePath == null || existing.worktreePath == null));
         if (locationNeedsProbe) {
             this.getBookkeeping(sessionId).gitInfoUnresolvable = false;
         }
@@ -1842,11 +2187,15 @@ export class ClaudeCodeProvider {
         this._resolveGitInfoInFlight.set(sessionId, cwd);
         try {
             let info;
+            let failed = false;
             try {
                 info = await resolveGitInfo(cwd);
             }
             catch {
-                // Git not available or not a git repo — fall through to mark unresolvable below
+                // A transient git/spawn failure, distinct from a confirmed "not a repo" (`info ==
+                // null` below). Must not latch `gitInfoUnresolvable` — the next hook event retries
+                // via `ensureSession`'s `commonPath == null` check.
+                failed = true;
                 info = undefined;
             }
             const index = this._sessions.findIndex(s => s.id === sessionId);
@@ -1857,6 +2206,8 @@ export class ClaudeCodeProvider {
             // below re-runs for the newest cwd.
             if (this._resolveGitInfoPending.has(sessionId))
                 return;
+            if (failed)
+                return;
             const session = this._sessions[index];
             // `workspacePath` stays as the matched workspace folder (or undefined). Repo identity
             // flows through `commonPath`, populated here from `info.repoRoot` at the same step as
@@ -1873,8 +2224,48 @@ export class ClaudeCodeProvider {
             // followed by a new session start).
             if (info == null) {
                 this.getBookkeeping(sessionId).gitInfoUnresolvable = true;
-                if (cwd !== session.cwd) {
-                    this._sessions[index] = { ...session, cwd: cwd };
+                // The cwd itself isn't a repo, but a CLI-seated worktree (from `cwdTimeline`, see
+                // `worktreeFromEvent`) may still name one — e.g. a scratch cwd like `/tmp/x` whose
+                // session the CLI attributed to a real worktree. Probe the worktree root inline, in
+                // the same in-flight window, so a scratch cwd doesn't leave `commonPath` permanently
+                // unresolved.
+                let worktreeInfo;
+                let liveIndex = index;
+                let liveSession = session;
+                if (session.worktreePath != null && session.worktreePath !== cwd && session.commonPath == null) {
+                    try {
+                        worktreeInfo = await resolveGitInfo(session.worktreePath);
+                    }
+                    catch {
+                        worktreeInfo = undefined;
+                    }
+                    // Re-find and re-read after this second await, for both the success and
+                    // fall-through writes below — the array can have been reassigned/spliced (e.g.
+                    // `pruneDeadSessions`), or the session's own fields updated, while the probe ran.
+                    liveIndex = this._sessions.findIndex(s => s.id === sessionId);
+                    if (liveIndex < 0)
+                        return;
+                    if (this._resolveGitInfoPending.has(sessionId))
+                        return;
+                    liveSession = this._sessions[liveIndex];
+                }
+                if (worktreeInfo != null) {
+                    const worktreeFirstResolve = liveSession.initialCommonPath == null;
+                    this._sessions[liveIndex] = {
+                        ...liveSession,
+                        cwd: cwd,
+                        commonPath: worktreeInfo.repoRoot,
+                        initialWorktreePath: worktreeFirstResolve
+                            ? liveSession.worktreePath
+                            : liveSession.initialWorktreePath,
+                        initialCommonPath: worktreeFirstResolve ? worktreeInfo.repoRoot : liveSession.initialCommonPath,
+                        visitedWorktreePaths: unionVisited(liveSession.visitedWorktreePaths, liveSession.worktreePath),
+                    };
+                    this._onDidChangeSessions.fire();
+                    return;
+                }
+                if (cwd !== liveSession.cwd) {
+                    this._sessions[liveIndex] = { ...liveSession, cwd: cwd };
                     this._onDidChangeSessions.fire();
                 }
                 return;
@@ -1905,6 +2296,7 @@ export class ClaudeCodeProvider {
                     commonPath: info.repoRoot,
                     initialWorktreePath: updatedInitialWorktreePath,
                     initialCommonPath: updatedInitialCommonPath,
+                    visitedWorktreePaths: unionVisited(session.visitedWorktreePaths, effectiveWorktreePath),
                 };
                 this._onDidChangeSessions.fire();
             }
@@ -1921,6 +2313,10 @@ export class ClaudeCodeProvider {
         }
     }
     async resolveTranscriptTitles(sessionId, cwd) {
+        // The reader only understands Claude Code's `~/.claude/projects/**` JSONL store, so for any
+        // other agent this would be a guaranteed-miss directory scan on every event and poll.
+        if (!this.supportsTranscripts(sessionId))
+            return;
         let titles;
         try {
             titles = await this._transcriptReader.resolve(sessionId, cwd);
@@ -1943,25 +2339,22 @@ export class ClaudeCodeProvider {
         };
         this._onDidChangeSessions.fire();
     }
-    /** Transitions the session at `index` to the terminal `completed` state in place: keeps the row,
+    /** Transitions the session at `index` to the terminal `ended` state in place: keeps the row,
      *  stamps `endedAt` as its activity time, clears transient state (statusDetail, pendingPermission,
      *  subagents), and tears down its bookkeeping/timers. Shared by the live `SessionEnd` path and the
      *  poll backstop for a `SessionEnd` the live path missed. Does not fire change events — the caller
      *  batches those. */
-    completeSession(index, endedAt) {
+    endSession(index, endedAt) {
         const prev = this._sessions[index];
         this._sessions[index] = {
             ...prev,
-            status: 'completed',
-            phase: 'completed',
+            status: 'ended',
+            phase: 'ended',
             phaseSince: endedAt,
             lastActivity: endedAt,
             statusDetail: undefined,
             pendingPermission: undefined,
             subagents: undefined,
-            // A terminal row carries no live working state — drop the file-activity heatmap so
-            // consumers reading it directly don't render a frozen tail for a finished session.
-            fileActivity: undefined,
         };
         // Terminal teardown, owned here so every caller gets it — the live `SessionEnd` path does
         // this before calling us, but the poll's missed-SessionEnd transition doesn't: reject any
@@ -1970,7 +2363,7 @@ export class ClaudeCodeProvider {
         // live zombie).
         const pending = this._pendingPermissions.get(prev.id);
         if (pending != null) {
-            this.rejectAllPending(pending, new Error('Session completed'));
+            this.rejectAllPending(pending, new Error('Session ended'));
             this._pendingPermissions.delete(prev.id);
         }
         this.cancelPendingIdleTransition(prev.id);
@@ -1981,14 +2374,28 @@ export class ClaudeCodeProvider {
         }
         this._sessionBookkeeping.delete(prev.id);
         this._transcriptReader.forget(prev.id);
+        this.noteTerminalTransition();
     }
     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
+            // Ended sessions are terminal and durable — their PID is usually dead by design, so
             // liveness pruning must never drop them (they leave only via poll reconciliation).
-            if (s.status === 'completed') {
+            if (s.status === 'ended') {
+                kept.push(s);
+                continue;
+            }
+            // An agent that multiplexes concurrent sessions in one process (Codex) reports the SAME
+            // pid for all of them, so the pid answers "is the host process alive", not "is this
+            // session alive" — in both directions. A live shared process would pin every session it
+            // ever hosted, and a dead one would reap live siblings along with the finished session.
+            // Neither is recoverable here, so pid liveness is not evidence for these rows at all:
+            // keep them and let the paths that DO identify a session end them — a `SessionEnd`, or the
+            // poll seeing the CLI's durable `ended` record (which the CLI writes for a stale session
+            // of its own accord). The CLI takes the same position: for `pidSharingClients` a pid-only
+            // match is a guess, so it keeps such an end revivable.
+            if (getAgentCapabilitiesByProviderId(s.providerId)?.sharesPids === true) {
                 kept.push(s);
                 continue;
             }
@@ -2024,7 +2431,8 @@ export class ClaudeCodeProvider {
             this._sessionBookkeeping.delete(id);
             this._transcriptReader.forget(id);
         }
-        Logger.debug(`ClaudeCodeProvider.syncSessions: removed ${removedIds.length} stale session(s): ${removedIds.map(id => id.substring(0, 8)).join(', ')}`);
+        this.noteTerminalTransition();
+        Logger.debug(`GkAgentProvider.syncSessions: removed ${removedIds.length} stale session(s): ${removedIds.map(id => id.substring(0, 8)).join(', ')}`);
         return true;
     }
     async syncSessions(options) {
@@ -2034,13 +2442,13 @@ 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
+        // Deliberately counts ALL tracked sessions, ended included. An ended row is something
         // we have to reconcile — it's removed only when the CLI stops listing it (archived from
         // another window, or aged out) — and this poll is the sole mechanism that does so. It's also
         // what triggers the CLI's own 30-day retention sweep, which runs on `list-sessions` and
         // nothing else: no timer, no daemon. Gating it out to save a spawn wouldn't avoid work, it
         // would strand the rows on screen AND the records on disk until the window reloads.
-        if (options?.gate && this._sessions.length === 0 && !this._claudeHooksInstalled)
+        if (options?.gate && this._sessions.length === 0 && !this._hooksInstalled)
             return;
         // Narrowly: hooks off AND nothing running, i.e. we hold only terminal history. There's no
         // dying process to reap and no live state to correct — just rows to reconcile and the
@@ -2049,14 +2457,14 @@ export class ClaudeCodeProvider {
         // 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') &&
+            !this._hooksInstalled &&
+            !this._sessions.some(s => s.status !== 'ended') &&
             Date.now() - this._lastSyncAt < idleReconcileIntervalMs) {
             return;
         }
         // Stamped BEFORE the CLI call so the reconciliation below can tell "this poll's snapshot was
-        // taken after we completed the row" from "an in-flight poll that predates it" — see the
-        // completed-removal filter.
+        // taken after we ended the row" from "an in-flight poll that predates it" — see the
+        // ended-removal filter.
         const pollStartedAt = Date.now();
         this._lastSyncAt = pollStartedAt;
         let sessions;
@@ -2065,7 +2473,7 @@ export class ClaudeCodeProvider {
             try {
                 // `--status active,ended` surfaces both live sessions and the CLI's durable ended records
                 // (excluding `archived`). Newer CLIs default `list-sessions` to active-only, so the flag
-                // is required to see completed sessions at all.
+                // is required to see ended sessions at all.
                 output = await this.callbacks.runCLICommand([
                     'ai',
                     'hook',
@@ -2087,7 +2495,11 @@ export class ClaudeCodeProvider {
             }
             sessions = JSON.parse(output);
         }
-        catch {
+        catch (ex) {
+            // Expected whenever the CLI is missing or still installing, so not an error — but log it:
+            // every session in the window silently stops reconciling until the next tick, and without
+            // this the symptom ("no agents anywhere") is indistinguishable from having no agents.
+            Logger.debug(`GkAgentProvider.syncSessions: poll skipped — ${ex instanceof Error ? ex.message : String(ex)}`);
             if (this.pruneDeadSessions()) {
                 this._onDidChangeSessions.fire();
             }
@@ -2096,26 +2508,60 @@ 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).
-        // Drift is measured over *live* sessions only; completed sessions are durable history, so their
+        // Drift is measured over *live* sessions only; ended sessions are durable history, so their
         // absence from `polledAlive` is expected and must not skew the discrepancy signal.
-        const trackedLiveBefore = new Set(this._sessions.filter(s => s.status !== 'completed').map(s => s.id));
-        const polledAlive = new Set();
-        // Every id the poll returned (live *and* completed). Drives completed-session reconciliation:
-        // a tracked completed session absent from this set was archived/purged by the CLI.
+        //
+        // Both maps carry the owning agent's `providerId` per session so the report below can be split
+        // per agent: the two paths' reliability differs by agent (one may never reach the live path at
+        // all), and one pooled number would average that away into noise.
+        const trackedLiveBefore = new Map(this._sessions.filter(s => s.status !== 'ended').map(s => [s.id, s.providerId]));
+        const polledAlive = new Map();
+        // Every id the poll returned (live *and* ended). Drives ended-session reconciliation:
+        // a tracked ended session absent from this set was archived/purged by the CLI.
         const polledIds = new Set();
         // Accumulates ids already tracked or added during this poll, so the membership check is O(1)
         // and duplicate ids within a single response are only added once.
         const known = new Set(this._sessions.map(s => s.id));
+        // The CLI's durable store never revives a resumed session — once it moves a record to its
+        // `ended` store, nothing moves it back, so a record reporting `ended` isn't proof the session
+        // is over. The listing also repairs the two active-record cases that have no fresher hook state:
+        // first discovery and synthesized, unresolvable permission asks. Fetched once per poll (not per
+        // row); the host caches the underlying `claude agents --json` invocation behind a short TTL, so
+        // this doesn't spawn a process per session.
+        const liveSessions = await this.callbacks.getLiveAgentSessions?.();
         let changed = false;
-        let discovered = 0;
+        const discoveredByAgent = new Map();
+        const noteDiscovered = (providerId) => {
+            discoveredByAgent.set(providerId, (discoveredByAgent.get(providerId) ?? 0) + 1);
+        };
+        /** Ids kept alive against a stale `ended` record. Logged below — this path has no other
+         *  observability, and "the agent isn't showing up" is otherwise indistinguishable from
+         *  "the listing never ran". */
+        const keptAlive = [];
         for (const data of sessions) {
             if (!data.sessionId)
                 continue;
-            // Another AI host's record in the CLI's shared store. Must stay ahead of `polledIds`/
-            // `polledAlive`: an id in either would skew completed-row reconciliation and the
-            // `onSyncDiscrepancy` drift signal below.
-            if (data.providerId != null && data.providerId !== 'claude-code')
+            // A record from a client we hold no descriptor for (the CLI supports more than this table
+            // does). Must stay ahead of `polledIds`/`polledAlive`: an id in either would skew ended-row
+            // reconciliation and the `onSyncDiscrepancy` drift signal below. Absent = `claude-code`,
+            // matching the live path — older CLIs don't stamp it.
+            const capabilities = getAgentCapabilities(data.providerId ?? 'claude-code');
+            if (capabilities == null)
                 continue;
+            // The record's `event` is the agent's native name. Canonicalize it so `deriveStatusFromEvent`
+            // sees a vocabulary it knows — an unmapped native name falls through to `data.event`, which
+            // that function's `default` already resolves to `idle`. Deliberately NOT a skip: unlike the
+            // live path, nothing here switches exhaustively on the name, and dropping the record would
+            // hide a real session whose last event simply has no canonical analogue.
+            //
+            // `data.hookInput` must be passed: an agent whose event name alone can't determine the
+            // canonical event (OpenCode's `session.status`) is resolved from the payload, so withholding
+            // it makes those names permanently unresolvable on this path — and the poll is the only way
+            // a pre-existing session enters after a window reload.
+            const canonicalEvent = resolveCanonicalHookEvent(capabilities, data.event, data.hookInput) ?? data.event;
+            // Same translation for the record's tool name — `classifyPermissionKind` and the display
+            // detail expect canonical names.
+            const polledToolName = data.toolName != null ? resolveCanonicalToolName(capabilities, data.toolName) : undefined;
             const effectiveStatus = data.status ?? 'active';
             // Archived records are excluded by the `active,ended` query; guard anyway.
             if (effectiveStatus === 'archived')
@@ -2123,39 +2569,110 @@ export class ClaudeCodeProvider {
             if (effectiveStatus === 'ended') {
                 polledIds.add(data.sessionId);
                 const endedDate = new Date(data.endedAt ?? data.updatedAt);
+                const override = liveOverrideFor(liveSessions, data.sessionId);
+                const liveCwd = override?.live.cwd;
+                const currentCwd = liveCwd ?? data.cwd;
+                const liveCwdMoved = liveCwd != null && liveCwd !== data.cwd;
+                const recordWorktreeRoot = worktreeRootFromData(data);
+                const currentWorktreeRoot = liveCwdMoved ? undefined : recordWorktreeRoot;
                 const existingIndex = this._sessions.findIndex(s => s.id === data.sessionId);
                 if (existingIndex >= 0) {
-                    // Already tracked. If the live path missed the SessionEnd (e.g. `/clear` kept the
-                    // PID alive under a new id), transition it to completed now — otherwise a live-status
-                    // row would linger as a zombie, since pruneDeadSessions can't reap a live PID.
-                    if (this._sessions[existingIndex].status !== 'completed') {
-                        this.completeSession(existingIndex, endedDate);
+                    const bookkeeping = this.getBookkeeping(data.sessionId);
+                    if (liveCwdMoved) {
+                        bookkeeping.supersededRecordCwd = data.cwd;
+                    }
+                    else if (bookkeeping.supersededRecordCwd != null &&
+                        bookkeeping.supersededRecordCwd !== data.cwd) {
+                        // The CLI rewrote the record for the resumed run — it describes the session again.
+                        bookkeeping.supersededRecordCwd = undefined;
+                    }
+                    // The record still names the cwd a resume superseded, and this poll no longer lists the
+                    // session live: the resumed process exited (or died) before the CLI rewrote the record,
+                    // so neither its cwd nor its `endedAt` describe where or when the session last ran.
+                    const recordLocationStale = override == null && bookkeeping.supersededRecordCwd === data.cwd;
+                    if (override != null) {
+                        const { live: liveSession, status: liveStatus } = override;
+                        // `claude agents --json` still lists this exact session id as live — the store's
+                        // `ended` record is stale. Keep the row alive instead of ending it, and prefer the
+                        // listing's pid — the record's own may already be dead, or reused. Background sessions
+                        // carry no pid at all, so fall back to whatever pid the row already has.
+                        //
+                        // The listing establishes LIVENESS, not status. It's a poll SAMPLE of a value that flips
+                        // many times per turn, so adopting it every poll stamps a row back to `idle` moments after
+                        // a hook event moved it to `tool_use`/`thinking` — the row then reads idle almost always
+                        // and working almost never. Hook events are strictly fresher, so the sample is only taken
+                        // when the row has nothing better: it was ended, and this poll is what revives it.
+                        const trackedSession = this._sessions[existingIndex];
+                        // The listing's pid, or none. Never fall back to the pid we already hold: the listing
+                        // omits one only for background sessions, which have no process of their own, and the
+                        // pid on the row is the dead one whose exit produced the `ended` record. Carrying it
+                        // onto a live row makes `pruneDeadSessions` reap the row later in this same poll.
+                        const nextPid = liveSession.pid;
+                        const revived = trackedSession.status === 'ended';
+                        const nextStatus = revived ? liveStatus : trackedSession.status;
+                        if (trackedSession.status !== nextStatus ||
+                            trackedSession.pid !== nextPid ||
+                            trackedSession.endReason != null ||
+                            trackedSession.endedAt != null) {
+                            this._sessions[existingIndex] = {
+                                ...trackedSession,
+                                status: nextStatus,
+                                phase: getPhaseForStatus(nextStatus),
+                                // Only re-stamp the phase/activity clocks on the revive itself; otherwise a poll
+                                // keeps resetting them under a row whose status it didn't change.
+                                phaseSince: revived ? new Date(pollStartedAt) : trackedSession.phaseSince,
+                                lastActivity: revived ? new Date(pollStartedAt) : trackedSession.lastActivity,
+                                pid: nextPid,
+                                statusDetail: revived ? undefined : trackedSession.statusDetail,
+                                endReason: undefined,
+                                endedAt: undefined,
+                            };
+                            changed = true;
+                        }
+                        keptAlive.push(`${data.sessionId.substring(0, 8)}:${nextStatus}`);
+                        polledAlive.set(data.sessionId, capabilities.providerId);
+                    }
+                    else if (this._sessions[existingIndex].status !== 'ended') {
+                        // Already tracked, and Claude no longer lists it as live. If the live path missed the
+                        // SessionEnd (e.g. `/clear` kept the PID alive under a new id), transition it to
+                        // ended now — otherwise a live-status row would linger as a zombie, since
+                        // pruneDeadSessions can't reap a live PID.
+                        // The record's `endedAt` can predate activity this window already observed — a
+                        // superseded record after a cwd move, or a same-cwd resume the CLI hasn't rewritten
+                        // the record for yet — so never move the row's clock backward.
+                        const { lastActivity } = this._sessions[existingIndex];
+                        this.endSession(existingIndex, lastActivity.getTime() > endedDate.getTime() ? lastActivity : endedDate);
                         changed = true;
                     }
-                    // Re-seat the row on the record's location. The durable record is authoritative for a
-                    // terminal session, and a `CwdChanged` hook we never received would otherwise leave the
-                    // card attached to the wrong worktree — and "Open Session" resuming from a stale
-                    // directory. Deliberately limited to location: prompts/titles have their own on-demand
-                    // transcript resolution, which holds richer values than the record does.
+                    // Re-seat the row on its current location. The durable record is authoritative for a
+                    // terminal session, but an independent Claude listing can prove that record stale and
+                    // supply the resumed process's current cwd. Keep the prior worktree attribution until
+                    // the live cwd's git probe confirms a replacement — a resumed session can legitimately
+                    // sit in scratch space — but never let a later poll move it back to the ended record's
+                    // directory. A record already known superseded stays ignored until the CLI rewrites it,
+                    // so the row survives the resumed process exiting before that write lands. Prompts get a
+                    // hole-fill from the record below when nothing has been set yet; titles keep their own
+                    // on-demand transcript resolution, which holds richer values than the record does.
                     const existing = this._sessions[existingIndex];
-                    const worktreeRoot = worktreeRootFromData(data);
-                    const cwdChanged = Boolean(data.cwd) && data.cwd !== existing.cwd;
+                    const cwdChanged = !recordLocationStale && currentCwd !== existing.cwd;
                     // Pre-`cwdTimeline` records carry no worktree data. If the cwd moved, whatever we hold
                     // is no longer trustworthy — it may point into a different repo entirely — so drop it
                     // rather than leave the card filed under the wrong branch, and re-resolve below. A cwd
-                    // change is a discrete event, so that's one probe, not the cold-start fan-out the
-                    // completed path exists to avoid.
-                    const nextWorktreePath = worktreeRoot != null
-                        ? normalizePath(worktreeRoot)
-                        : cwdChanged
-                            ? undefined
-                            : existing.worktreePath;
+                    // supplied by the live listing is different: preserve the old attribution as a fallback
+                    // until the current cwd's probe succeeds.
+                    const nextWorktreePath = recordLocationStale
+                        ? existing.worktreePath
+                        : currentWorktreeRoot != null
+                            ? normalizePath(currentWorktreeRoot)
+                            : cwdChanged && !liveCwdMoved
+                                ? undefined
+                                : existing.worktreePath;
                     const worktreeMoved = nextWorktreePath !== existing.worktreePath;
                     if (cwdChanged || worktreeMoved) {
-                        const workspacePath = this.resolveWorkspacePath(data.cwd || existing.cwd);
+                        const workspacePath = this.resolveWorkspacePath(currentCwd);
                         this._sessions[existingIndex] = {
                             ...existing,
-                            cwd: data.cwd || existing.cwd,
+                            cwd: currentCwd,
                             initialCwd: existing.initialCwd ?? data.initialCwd ?? data.cwd,
                             worktreePath: nextWorktreePath,
                             workspacePath: workspacePath,
@@ -2165,35 +2682,108 @@ export class ClaudeCodeProvider {
                             // worktree metadata, pinning the card to the wrong repo. Drop it and let the
                             // host backfill from the new worktree.
                             commonPath: worktreeMoved ? undefined : existing.commonPath,
+                            visitedWorktreePaths: unionVisited(existing.visitedWorktreePaths, visitedFromTimeline(data.cwdTimeline), data.worktrees, nextWorktreePath),
                         };
                         changed = true;
-                        // Nothing in the record to re-seat it with (older CLI), so resolve the new cwd
-                        // once rather than leaving the row location-less.
-                        if (nextWorktreePath == null && data.cwd) {
-                            void this.resolveGitInfo(data.sessionId, data.cwd);
+                        // Nothing in the record to re-seat it with (older CLI), or the record names a
+                        // NEW worktree the drop above just cleared `commonPath` for — either way, resolve
+                        // the cwd once rather than leaving the row location-less until some later event
+                        // happens to change `cwd`/`worktreePath` again (a same-worktree poll afterward
+                        // skips this branch entirely, since `worktreeMoved` goes false).
+                        if (liveCwdMoved || nextWorktreePath == null || worktreeMoved) {
+                            this.getBookkeeping(data.sessionId).cliSeatedWorktree = currentWorktreeRoot != null;
+                            void this.resolveGitInfo(data.sessionId, currentCwd);
                         }
                     }
-                    this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
+                    // Prompts backfill-only: the record's prompt/firstPrompt sanitized the same way the
+                    // discovery path does. Never overwrites a value the hook path or a transcript resolve
+                    // already set.
+                    const currentSession = this._sessions[existingIndex];
+                    const nextLastPrompt = currentSession.lastPrompt ?? prepareStoredPrompt(data.prompt ?? undefined);
+                    const nextFirstPrompt = currentSession.firstPrompt ?? prepareStoredPrompt(data.firstPrompt ?? undefined);
+                    if (nextLastPrompt !== currentSession.lastPrompt ||
+                        nextFirstPrompt !== currentSession.firstPrompt) {
+                        this._sessions[existingIndex] = {
+                            ...currentSession,
+                            lastPrompt: nextLastPrompt,
+                            firstPrompt: nextFirstPrompt,
+                        };
+                        changed = true;
+                    }
+                    const nextBookkeeping = this.getBookkeeping(data.sessionId);
+                    nextBookkeeping.polledAtLeastOnce = true;
+                    // `endSession` above drops the bookkeeping entry, but the latch has to outlive that
+                    // transition — otherwise the next poll finds none and re-seats the row onto the very
+                    // record this one already knew was superseded.
+                    nextBookkeeping.supersededRecordCwd = bookkeeping.supersededRecordCwd;
                     continue;
                 }
                 known.add(data.sessionId);
-                const workspacePath = this.resolveWorkspacePath(data.cwd);
-                const worktreeRoot = worktreeRootFromData(data);
+                const workspacePath = this.resolveWorkspacePath(currentCwd);
+                if (override != null) {
+                    const { live: liveSession, status: liveStatus } = override;
+                    // This window is learning about the session for the first time via its `ended`
+                    // record, but `claude agents --json` still lists it as live — same override as the
+                    // tracked branch above, just pushing a fresh row instead of updating one in place. The
+                    // listing's cwd is current; the ended record's worktree remains only as a fallback until
+                    // the live cwd's git probe resolves it.
+                    this._sessions.push({
+                        id: data.sessionId,
+                        providerId: capabilities.providerId,
+                        providerName: capabilities.displayName,
+                        name: data.sessionName || undefined,
+                        status: liveStatus,
+                        phase: getPhaseForStatus(liveStatus),
+                        phaseSince: new Date(pollStartedAt),
+                        // Listing's pid or none — never the record's, which is the dead process whose exit
+                        // wrote the `ended` record (see the tracked branch above).
+                        pid: liveSession.pid,
+                        lastActivity: new Date(pollStartedAt),
+                        isSubagent: false,
+                        workspacePath: workspacePath,
+                        worktreePath: recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
+                        visitedWorktreePaths: unionVisited(undefined, visitedFromTimeline(data.cwdTimeline), data.worktrees, recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined),
+                        cwd: currentCwd,
+                        initialCwd: data.initialCwd ?? data.cwd,
+                        planFile: data.planFile ?? undefined,
+                        isInWorkspace: workspacePath != null,
+                        lastPrompt: prepareStoredPrompt(data.prompt ?? undefined),
+                        firstPrompt: prepareStoredPrompt(data.firstPrompt ?? undefined),
+                        model: data.model ?? undefined,
+                    });
+                    this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
+                    this.getBookkeeping(data.sessionId).cliSeatedWorktree = currentWorktreeRoot != null;
+                    if (liveCwdMoved) {
+                        // Latch the cwd this listing superseded, so a later poll that no longer finds the
+                        // session live doesn't re-seat the row back onto the not-yet-rewritten record.
+                        this.getBookkeeping(data.sessionId).supersededRecordCwd = data.cwd;
+                    }
+                    changed = true;
+                    noteDiscovered(capabilities.providerId);
+                    keptAlive.push(`${data.sessionId.substring(0, 8)}:${liveStatus}`);
+                    polledAlive.set(data.sessionId, capabilities.providerId);
+                    if (liveCwdMoved || recordWorktreeRoot == null) {
+                        void this.resolveGitInfo(data.sessionId, currentCwd);
+                    }
+                    void this.resolveTranscriptTitles(data.sessionId, currentCwd);
+                    continue;
+                }
                 this._sessions.push({
                     id: data.sessionId,
-                    providerId: this.id,
-                    providerName: this.name,
+                    providerId: capabilities.providerId,
+                    providerName: capabilities.displayName,
                     name: data.sessionName || undefined,
-                    status: 'completed',
-                    phase: 'completed',
+                    status: 'ended',
+                    phase: 'ended',
                     phaseSince: endedDate,
                     pid: data.pid,
                     lastActivity: endedDate,
                     isSubagent: false,
                     workspacePath: workspacePath,
-                    // Read straight from the CLI's durable record so completed sessions attach to branch
+                    // Read straight from the CLI's durable record so ended sessions attach to branch
                     // cards / WIP rows / the resume picker at any age, no git probe.
-                    worktreePath: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
+                    worktreePath: recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined,
+                    visitedWorktreePaths: unionVisited(undefined, visitedFromTimeline(data.cwdTimeline), data.worktrees, recordWorktreeRoot != null ? normalizePath(recordWorktreeRoot) : undefined),
                     cwd: data.cwd,
                     initialCwd: data.initialCwd ?? data.cwd,
                     planFile: data.planFile ?? undefined,
@@ -2208,13 +2798,14 @@ export class ClaudeCodeProvider {
                 });
                 this.getBookkeeping(data.sessionId).polledAtLeastOnce = true;
                 changed = true;
-                // Titles/prompts still resolve lazily via resolveCompletedSessionDetails (a 30-day
+                this.noteTerminalTransition();
+                // Titles/prompts still resolve lazily via resolveEndedSessionDetails (a 30-day
                 // cold-start must not fan out transcript reads). worktreePath comes from the record
                 // above; only fall back to an eager git probe when the record predates that CLI field,
                 // and only for the recent (WIP-window) tail so the fallback stays bounded.
-                if (worktreeRoot == null &&
+                if (recordWorktreeRoot == null &&
                     data.cwd &&
-                    Date.now() - endedDate.getTime() < recentCompletedGitResolveThresholdMs) {
+                    Date.now() - endedDate.getTime() < recentEndedGitResolveThresholdMs) {
                     void this.resolveGitInfo(data.sessionId, data.cwd);
                 }
                 continue;
@@ -2222,7 +2813,7 @@ export class ClaudeCodeProvider {
             // Active / legacy (absent-status) path — only genuinely-live processes are discoverable.
             if (!data.pid || !isProcessAlive(data.pid))
                 continue;
-            polledAlive.add(data.sessionId);
+            polledAlive.set(data.sessionId, capabilities.providerId);
             polledIds.add(data.sessionId);
             if (known.has(data.sessionId)) {
                 // Already tracked.
@@ -2232,30 +2823,44 @@ export class ClaudeCodeProvider {
                     // The status the CLI's last event implies — a resumed session may already be mid-work
                     // (`PreToolUse` → tool_use, `UserPromptSubmit` → thinking), and hardcoding `idle` would
                     // mislabel active work and risk a concurrent-write resume.
-                    const polledStatus = deriveStatusFromEvent(data.event);
-                    if (existing.status === 'completed') {
-                        // We hold it as `completed` but the CLI now reports it as a live process (a
+                    const polledStatus = deriveStatusFromEvent(canonicalEvent);
+                    const isSynthesizedAsk = existing.status === 'permission_requested' && existing.pendingPermission?.resolvable === false;
+                    const liveEntry = isSynthesizedAsk ? liveSessions?.get(data.sessionId) : undefined;
+                    const liveStatus = liveEntry != null ? statusFromLiveSession(liveEntry) : undefined;
+                    if (isSynthesizedAsk && liveEntry != null && liveStatus == null) {
+                        // A terminal listing entry proves this active record is stale, even if its last event
+                        // advanced after the ask. It carries no authoritative terminal timestamp/details, so
+                        // remove the false live row and let the durable ended record restore it later. Run the
+                        // standard terminal teardown first so no timers or caches survive the row.
+                        this.endSession(existingIndex, new Date(pollStartedAt));
+                        this._sessions.splice(existingIndex, 1);
+                        polledAlive.delete(data.sessionId);
+                        changed = true;
+                        continue;
+                    }
+                    if (existing.status === 'ended') {
+                        // We hold it as `ended` but the CLI now reports it as a live process (a
                         // resume the live SessionStart path missed) — revive it, the symmetric backstop
-                        // to the ended-branch's live→completed transition above. Leave genuinely-live
+                        // to the ended-branch's live→ended transition above. Leave genuinely-live
                         // rows to the IPC path.
                         const revivedAt = new Date(data.updatedAt);
-                        // Only when the record is at least as new as the completion. `SessionEnd` fires
+                        // Only when the record is at least as new as the end. `SessionEnd` fires
                         // while the process is still winding down, so a poll whose CLI call started
                         // BEFORE it returns a snapshot that still says "active" with a live pid — reviving
                         // off that stale record would resurrect the row, and `pruneDeadSessions` would
-                        // then delete it outright once the process exits, losing the completed row.
+                        // then delete it outright once the process exits, losing the ended row.
                         if (revivedAt.getTime() < existing.phaseSince.getTime())
                             continue;
                         // The poll has no blocking hook entry for this ask (it's discovered off the CLI's
                         // 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)
+                            ? synthesizeUnresolvableAsk(polledToolName, data.planFile ?? undefined)
                             : undefined;
                         // Seat worktreePath from the record, mirroring the ended-record re-seat above — the
-                        // existing row is otherwise stuck with whatever (or nothing) it had while completed.
+                        // existing row is otherwise stuck with whatever (or nothing) it had while ended.
                         const revivedWorktreeRoot = worktreeRootFromData(data);
-                        // No record worktree data (older CLI): KEEP the completed row's attribution. A
+                        // No record worktree data (older CLI): KEEP the ended row's attribution. A
                         // resume whose cwd is scratch space (e.g. /tmp) still belongs to its worktree —
                         // re-rooting happens only when git affirmatively resolves a new one (the probe
                         // below, on success). Attribution persists until something better is known.
@@ -2280,10 +2885,11 @@ export class ClaudeCodeProvider {
                             workspacePath: revivedWorkspacePath ?? (data.cwd == null ? existing.workspacePath : undefined),
                             isInWorkspace: data.cwd == null ? existing.isInWorkspace : revivedWorkspacePath != null,
                             worktreePath: revivedWorktreePath,
+                            visitedWorktreePaths: unionVisited(existing.visitedWorktreePaths, visitedFromTimeline(data.cwdTimeline), data.worktrees, revivedWorktreePath),
                             // A worktree move can cross repos — drop the stale repo identity and let the
                             // probe below refill it.
                             commonPath: revivedWorktreePath !== existing.worktreePath ? undefined : existing.commonPath,
-                            // No longer terminal: leaving these set makes the row read as completed to
+                            // No longer terminal: leaving these set makes the row read as ended to
                             // consumers that key off them.
                             endReason: undefined,
                             endedAt: undefined,
@@ -2292,7 +2898,10 @@ export class ClaudeCodeProvider {
                         // The record's worktree is the CLI's own resolution; without one the probe owns
                         // attribution again.
                         this.getBookkeeping(data.sessionId).cliSeatedWorktree = revivedWorktreeRoot != null;
-                        if (data.cwd != null && data.cwd !== existing.cwd) {
+                        // A revive whose worktree moved but whose cwd happens to equal the prior one still
+                        // dropped `commonPath` above and needs the probe to refill it.
+                        if (data.cwd != null &&
+                            (data.cwd !== existing.cwd || revivedWorktreePath !== existing.worktreePath)) {
                             void this.resolveGitInfo(data.sessionId, data.cwd);
                         }
                         changed = true;
@@ -2311,12 +2920,31 @@ export class ClaudeCodeProvider {
                             // The detail described the ask's tool; carry the record's current tool for
                             // tool_use, else clear — keeping it would show the answered ask's tool as
                             // the active one.
-                            statusDetail: polledStatus === 'tool_use' ? (data.toolName ?? undefined) : undefined,
+                            statusDetail: polledStatus === 'tool_use' ? polledToolName : undefined,
                             pendingPermission: undefined,
                             lastActivity: new Date(data.updatedAt),
                         };
                         changed = true;
                     }
+                    else if (isSynthesizedAsk) {
+                        // The record never moved past the ask it froze on — the ask was resolved while no
+                        // window was listening, so nothing ever advanced it — but Claude's own listing
+                        // says the session has moved on. Correct the row so it heals on the next poll
+                        // instead of waiting for a reload or fresh hook events. Only synthesized asks
+                        // are repairable here: a routable one is bookkeeping-owned and cleared by its
+                        // own resolution paths, which the listing must never preempt.
+                        if (liveStatus != null && liveStatus !== 'permission_requested') {
+                            this._sessions[existingIndex] = {
+                                ...existing,
+                                status: liveStatus,
+                                phase: getPhaseForStatus(liveStatus),
+                                phaseSince: new Date(pollStartedAt),
+                                pendingPermission: undefined,
+                                statusDetail: undefined,
+                            };
+                            changed = true;
+                        }
+                    }
                     else if (existing.transcriptTitles?.ai == null && existing.transcriptTitles?.custom == null) {
                         // A live session we discovered via the poll (another worktree/window owns its
                         // hook flow) gets none of the local IPC re-resolves (SessionStart, idle). So one
@@ -2331,21 +2959,40 @@ export class ClaudeCodeProvider {
             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);
+            let status = deriveStatusFromEvent(canonicalEvent);
+            let phaseSince = activityDate;
+            // The record's last event can be arbitrarily stale — an ask answered while no window
+            // was listening (e.g. mid-reload), or a session stopped right there, never advances it,
+            // so every window start would re-seed the frozen state. Claude's own listing is
+            // authoritative for what the session is doing right now — same contract as the
+            // ended-record revival above. Absence from the listing (including its fail-soft empty
+            // map on spawn failure) keeps record-derived status: absence must never mean dead.
+            const liveEntry = liveSessions?.get(data.sessionId);
+            if (liveEntry != null) {
+                const liveStatus = statusFromLiveSession(liveEntry);
+                if (liveStatus == null) {
+                    polledAlive.delete(data.sessionId);
+                    continue;
+                }
+                if (liveStatus !== status) {
+                    status = liveStatus;
+                    phaseSince = new Date(pollStartedAt);
+                }
+            }
+            const phase = getPhaseForStatus(status);
             // Same rationale as the revived-session branch above: no blocking hook entry exists for a
             // poll-discovered ask, so synthesize an unresolvable one for the card.
             const pendingPermission = status === 'permission_requested'
-                ? synthesizeUnresolvableAsk(data.toolName, data.planFile ?? undefined)
+                ? synthesizeUnresolvableAsk(polledToolName, data.planFile ?? undefined)
                 : undefined;
             // Read straight from the CLI's durable record so the row attaches to the right branch
-            // card/WIP row immediately, no git probe — mirrors the completed-session push below.
+            // card/WIP row immediately, no git probe — mirrors the ended-session push below.
             const worktreeRoot = worktreeRootFromData(data);
             const subagents = data.subagents?.map(sub => ({
                 id: sub.agentId,
-                providerId: this.id,
-                providerName: this.name,
+                providerId: capabilities.providerId,
+                providerName: capabilities.displayName,
                 name: sub.agentType ?? 'Subagent',
                 status: 'thinking',
                 phase: 'working',
@@ -2357,12 +3004,12 @@ export class ClaudeCodeProvider {
             }));
             this._sessions.push({
                 id: data.sessionId,
-                providerId: this.id,
-                providerName: this.name,
+                providerId: capabilities.providerId,
+                providerName: capabilities.displayName,
                 name: data.sessionName || undefined,
                 status: status,
                 phase: phase,
-                phaseSince: activityDate,
+                phaseSince: phaseSince,
                 pid: data.pid,
                 lastActivity: activityDate,
                 isSubagent: false,
@@ -2380,9 +3027,10 @@ export class ClaudeCodeProvider {
                 subagents: subagents,
                 pendingPermission: pendingPermission,
                 worktreePath: worktreeRoot != null ? normalizePath(worktreeRoot) : undefined,
+                visitedWorktreePaths: unionVisited(undefined, visitedFromTimeline(data.cwdTimeline), data.worktrees, worktreeRoot != null ? normalizePath(worktreeRoot) : undefined),
             });
             changed = true;
-            discovered++;
+            noteDiscovered(capabilities.providerId);
             // The record's worktree is the CLI's own resolution — mark it seated so the probe below
             // (still wanted for `commonPath`) can't clobber it for a nested worktree. Mirrors the
             // revival branch above.
@@ -2392,32 +3040,35 @@ export class ClaudeCodeProvider {
             }
             void this.resolveTranscriptTitles(data.sessionId, data.cwd);
         }
-        // The poll is authoritative for completed-session removal (archived elsewhere or 30-day-purged).
+        // The poll is authoritative for ended-session removal (archived elsewhere or 30-day-purged).
         // Only remove ones a prior poll confirmed present — never a session the live SessionEnd path just
         // transitioned, which an already-in-flight poll can legitimately miss (guarded by polledAtLeastOnce).
-        // On a legacy CLI (no `--status`) no poll can ever confirm a completed row, so the guard would
+        // On a legacy CLI (no `--status`) no poll can ever confirm an ended row, so the guard would
         // instead pin it forever — there, absence from the poll is the confirmation.
-        const staleCompleted = this._sessions.filter(s => s.status === 'completed' &&
+        const staleEnded = this._sessions.filter(s => s.status === 'ended' &&
             !polledIds.has(s.id) &&
             (!this._statusFilterSupported ||
                 this._sessionBookkeeping.get(s.id)?.polledAtLeastOnce === true ||
-                // Or this poll's snapshot postdates the completion, so its absence is authoritative.
+                // Or this poll's snapshot postdates the end, so its absence is authoritative.
                 // `polledAtLeastOnce` alone can never be set for a session whose record disappeared
                 // (archived from another window, or purged) before any poll observed it — and
-                // `completeSession` drops the bookkeeping — so without this the row is unremovable for
+                // `endSession` drops the bookkeeping — so without this the row is unremovable for
                 // the window's lifetime. The timestamp answers the same question the flag was proxying:
-                // could this poll have seen it? The grace keeps a just-completed row out of reach of
+                // could this poll have seen it? The grace keeps a just-ended row out of reach of
                 // an absence that's really a not-yet-visible record.
-                s.phaseSince.getTime() < pollStartedAt - completedRemovalGraceMs));
-        if (staleCompleted.length > 0) {
-            const staleIds = new Set(staleCompleted.map(s => s.id));
+                s.phaseSince.getTime() < pollStartedAt - endedRemovalGraceMs));
+        if (staleEnded.length > 0) {
+            const staleIds = new Set(staleEnded.map(s => s.id));
             this._sessions = this._sessions.filter(s => !staleIds.has(s.id));
-            for (const s of staleCompleted) {
+            for (const s of staleEnded) {
                 this._sessionBookkeeping.delete(s.id);
                 this._transcriptReader.forget(s.id);
             }
             changed = true;
         }
+        if (liveSessions != null) {
+            Logger.debug(`GkAgentProvider.syncSessions: Claude lists ${liveSessions.size} session(s); kept ${keptAlive.length} alive against a stale ended record${keptAlive.length > 0 ? `: ${keptAlive.join(', ')}` : ''}`);
+        }
         if (this.pruneDeadSessions()) {
             changed = true;
         }
@@ -2430,20 +3081,35 @@ export class ClaudeCodeProvider {
         // live sessions we still track that the poll no longer reports alive (a teardown the live path
         // missed, e.g. an agent killed without firing `SessionEnd`).
         if (options?.gate) {
-            let missing = 0;
-            for (const id of trackedLiveBefore) {
+            const driftByAgent = new Map();
+            const driftFor = (providerId) => {
+                let drift = driftByAgent.get(providerId);
+                if (drift == null) {
+                    drift = { discovered: 0, missing: 0, polled: 0, tracked: 0 };
+                    driftByAgent.set(providerId, drift);
+                }
+                return drift;
+            };
+            for (const [providerId, count] of discoveredByAgent) {
+                driftFor(providerId).discovered += count;
+            }
+            for (const [id, providerId] of trackedLiveBefore) {
+                const drift = driftFor(providerId);
+                drift.tracked++;
                 if (!polledAlive.has(id)) {
-                    missing++;
+                    drift.missing++;
                 }
             }
-            if (discovered > 0 || missing > 0) {
-                this.callbacks.onSyncDiscrepancy?.({
-                    provider: this.id,
-                    discovered: discovered,
-                    missing: missing,
-                    polled: polledAlive.size,
-                    tracked: trackedLiveBefore.size,
-                });
+            for (const providerId of polledAlive.values()) {
+                driftFor(providerId).polled++;
+            }
+            // One report per agent, not one pooled report: the counts describe how well the live path
+            // and the poll agree, which is a per-agent property. A single agent's numbers are unchanged
+            // from the pre-multi-agent shape.
+            for (const [providerId, drift] of driftByAgent) {
+                if (drift.discovered === 0 && drift.missing === 0)
+                    continue;
+                this.callbacks.onSyncDiscrepancy?.({ provider: providerId, ...drift });
             }
         }
     }
@@ -2474,15 +3140,17 @@ 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
+                // Skip terminal rows a peer published: ended sessions live in the machine-global CLI
                 // store, so our own poll surfaces them with proper reconciliation. Importing them from a
                 // peer would add a row with no `polledAtLeastOnce` that our poll can't confirm — a ghost
-                // pinned for this window's lifetime if the store later drops it.
-                if (peerSession.status === 'completed')
+                // pinned for this window's lifetime if the store later drops it. (The publish endpoint
+                // filters ended rows out anyway; this also keeps a version-skewed peer's terminal claim
+                // from ending a row we still track live.)
+                if (peerSession.status === 'ended')
                     continue;
+                const existing = this._sessions.find(s => s.id === peerSession.id);
                 const peerActivity = new Date(peerSession.lastActivity);
                 const peerPhaseSince = new Date(peerSession.phaseSince);
-                const existing = this._sessions.find(s => s.id === peerSession.id);
                 if (existing != null) {
                     // If the peer reports a different `cwd` than we last saw, the agent moved
                     // (peer fired a `CwdChanged` event we don't receive locally). Pick up the new
@@ -2498,7 +3166,7 @@ export class ClaudeCodeProvider {
                         // poll/SessionStart revive paths: take the peer's pid (retaining the terminal
                         // record's dead — and possibly reused — pid would let dispatch focus an unrelated
                         // process) and mark it peer-owned so opens route through the peer's IPC.
-                        const revivedFromCompleted = existing.status === 'completed';
+                        const revivedFromEnded = existing.status === 'ended';
                         // Peer is the authoritative hook recipient for this session, so wipe any
                         // local bookkeeping that survived from a previous local-ownership window.
                         // Without this, refcounts/timers from a prior local-hosting stretch would
@@ -2525,7 +3193,7 @@ export class ClaudeCodeProvider {
                                 (peerSession.pendingPermission != null
                                     ? { ...peerSession.pendingPermission, resolvable: false }
                                     : undefined),
-                            ...(revivedFromCompleted ? { pid: peerSession.pid, isPeerOwned: true } : undefined),
+                            ...(revivedFromEnded ? { pid: peerSession.pid, isPeerOwned: true } : undefined),
                             subagents: rehydrateSubagents(peerSession.subagents),
                             // Carry the peer's published fileActivity across so peer-window WIP
                             // decorations + treemap heatmap follow the agent. Owned by the peer (it's
@@ -2537,6 +3205,7 @@ export class ClaudeCodeProvider {
                             // but `worktreePath` changed) only reaches us if we carry BOTH. Carrying
                             // `commonPath` alone froze the displayed worktree at first-discovery.
                             worktreePath: peerSession.worktreePath ?? existing.worktreePath,
+                            visitedWorktreePaths: unionVisitedAppendOnly(existing.visitedWorktreePaths, peerSession.visitedWorktreePaths),
                             commonPath: peerSession.commonPath ?? existing.commonPath,
                             // Pick up the peer's latest cwd so our backfill probe (queued below)
                             // targets the right path. Stale-cwd locally would just re-probe the
@@ -2548,6 +3217,10 @@ export class ClaudeCodeProvider {
                             initialCwd: existing.initialCwd ?? peerSession.initialCwd,
                             initialWorktreePath: existing.initialWorktreePath ?? peerSession.initialWorktreePath,
                             initialCommonPath: existing.initialCommonPath ?? peerSession.initialCommonPath,
+                            // The hook path, when present, carries richer un-truncated prompts than what a
+                            // peer forwards — prefer our own value over the peer's.
+                            lastPrompt: existing.lastPrompt ?? peerSession.lastPrompt,
+                            firstPrompt: existing.firstPrompt ?? peerSession.firstPrompt,
                             // Forward peer-discovered transcript titles. Both windows can resolve them
                             // independently against the same on-disk transcript, but only the peer's
                             // hook flow drives its updates — without this, we'd freeze the snapshot
@@ -2683,7 +3356,7 @@ export class ClaudeCodeProvider {
                     signal: AbortSignal.timeout(2000),
                 });
                 if (!response.ok) {
-                    Logger.warn(`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} returned ${response.status}`);
+                    Logger.warn(`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} returned ${response.status}`);
                 }
                 else {
                     // Log a peer that failed to open the specific session, but still treat it
@@ -2691,7 +3364,7 @@ export class ClaudeCodeProvider {
                     // what the user wants.
                     const body = (await response.json().catch(() => undefined));
                     if (body?.opened === false) {
-                        Logger.warn(`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} could not open session ${sessionId}`);
+                        Logger.warn(`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} could not open session ${sessionId}`);
                     }
                 }
                 return true;
@@ -2699,7 +3372,7 @@ export class ClaudeCodeProvider {
             catch (ex) {
                 // Peer advertised but unreachable (timeout, RST, etc.). Treat as no match so
                 // the caller opens a new window instead of trying to focus a dead window.
-                Logger.warn(`ClaudeCodeProvider.notifyPeerOpenSession: peer at ${discovery.address} unreachable: ${ex instanceof Error ? ex.message : String(ex)}`);
+                Logger.warn(`GkAgentProvider.notifyPeerOpenSession: peer at ${discovery.address} unreachable: ${ex instanceof Error ? ex.message : String(ex)}`);
                 return false;
             }
         }));
@@ -2708,5 +3381,5 @@ export class ClaudeCodeProvider {
 }
 __decorate([
     gate()
-], ClaudeCodeProvider.prototype, "ensureIpcServer", null);
-//# sourceMappingURL=claudeCodeProvider.js.map
+], GkAgentProvider.prototype, "ensureIpcServer", null);
+//# sourceMappingURL=gkAgentProvider.js.map