@imdeadpool/guardex 7.0.24 → 7.0.25

package/templates/vscode/guardex-active-agents/extension.js

@@ -17,17 +17,40 @@ const LOCK_FILE_RELATIVE = path.join('.omx', 'state', 'agent-file-locks.json');
 const ACTIVE_SESSION_FILES_GLOB = '**/.omx/state/active-sessions/*.json';
 const AGENT_FILE_LOCKS_GLOB = '**/.omx/state/agent-file-locks.json';
 const WORKTREE_AGENT_LOCKS_GLOB = '**/{.omx,.omc}/agent-worktrees/**/AGENT.lock';
+const MANAGED_WORKTREE_GIT_FILES_GLOB = '**/{.omx,.omc}/agent-worktrees/*/.git';
+const MANAGED_WORKTREE_RELATIVE_ROOTS = [
+  path.join('.omx', 'agent-worktrees'),
+  path.join('.omc', 'agent-worktrees'),
+];
 const AGENT_LOG_FILES_GLOB = '**/.omx/logs/*.log';
 const SESSION_SCAN_EXCLUDE_GLOB = '**/{node_modules,.git,.omx/agent-worktrees,.omc/agent-worktrees}/**';
 const WORKTREE_LOCK_SCAN_EXCLUDE_GLOB = '**/{node_modules,.git}/**';
+const MANAGED_WORKTREE_GIT_SCAN_EXCLUDE_GLOB = '**/node_modules/**';
 const SESSION_SCAN_LIMIT = 200;
 const REFRESH_DEBOUNCE_MS = 250;
+const RECENTLY_ACTIVE_WINDOW_MS = 10 * 60 * 1000;
+const SESSION_TOP_FILE_COUNT = 3;
 const ACTIVE_AGENTS_MANIFEST_RELATIVE = path.join('vscode', 'guardex-active-agents', 'package.json');
 const ACTIVE_AGENTS_INSTALL_SCRIPT_RELATIVE = path.join('scripts', 'install-vscode-active-agents-extension.js');
 const RELOAD_WINDOW_ACTION = 'Reload Window';
 const UPDATE_LATER_ACTION = 'Later';
+const ACTIVE_AGENTS_EXTENSION_ID = 'recodeee.gitguardex-active-agents';
+const RESTART_EXTENSION_HOST_COMMAND = 'workbench.action.restartExtensionHost';
 const REFRESH_POLL_INTERVAL_MS = 30_000;
 const INSPECT_PANEL_VIEW_TYPE = 'gitguardex.activeAgents.inspect';
+const GIT_CONFIGURATION_SECTION = 'git';
+const REPO_SCAN_IGNORED_FOLDERS_SETTING = 'repositoryScanIgnoredFolders';
+const BUNDLED_FILE_ICONS_MANIFEST_RELATIVE = path.join('fileicons', 'gitguardex-fileicons.json');
+const MANAGED_REPO_SCAN_IGNORED_FOLDERS = [
+  '.omx/agent-worktrees',
+  '**/.omx/agent-worktrees',
+  '.omx/.tmp-worktrees',
+  '**/.omx/.tmp-worktrees',
+  '.omc/agent-worktrees',
+  '**/.omc/agent-worktrees',
+  '.omc/.tmp-worktrees',
+  '**/.omc/.tmp-worktrees',
+];
 const SESSION_ACTIVITY_GROUPS = [
   { kind: 'blocked', label: 'BLOCKED' },
   { kind: 'working', label: 'WORKING NOW' },
@@ -42,11 +65,134 @@ const SESSION_ACTIVITY_ICON_IDS = {
   stalled: 'clock',
   dead: 'error',
 };
+const SESSION_PROVIDER_BRANDS = {
+  openai: {
+    id: 'openai',
+    label: 'OpenAI',
+    badge: 'AI',
+  },
+  claude: {
+    id: 'claude',
+    label: 'Claude',
+    badge: 'CL',
+  },
+};
+let bundledTreeIconThemeCache = null;
+
+function iconColorId(iconId) {
+  switch (iconId) {
+    case 'warning':
+    case 'clock':
+      return 'list.warningForeground';
+    case 'error':
+      return 'list.errorForeground';
+    case 'loading~spin':
+      return 'gitDecoration.addedResourceForeground';
+    case 'comment-discussion':
+    case 'info':
+    case 'repo':
+    case 'folder':
+    case 'graph':
+    case 'history':
+      return 'textLink.foreground';
+    case 'git-branch':
+      return 'gitDecoration.modifiedResourceForeground';
+    case 'account':
+      return 'terminal.ansiYellow';
+    case 'sparkle':
+      return 'terminal.ansiMagenta';
+    case 'list-flat':
+      return 'terminal.ansiCyan';
+    case 'list-tree':
+      return 'terminal.ansiBlue';
+    default:
+      return '';
+  }
+}
+
+function themeIcon(iconId, colorId = iconColorId(iconId)) {
+  if (!iconId) {
+    return undefined;
+  }
+  return colorId
+    ? new vscode.ThemeIcon(iconId, new vscode.ThemeColor(colorId))
+    : new vscode.ThemeIcon(iconId);
+}
 
 function sessionDecorationUri(branch) {
   return vscode.Uri.parse(`${SESSION_DECORATION_SCHEME}://${sanitizeBranchForFile(branch)}`);
 }
 
+function emptyBundledTreeIconTheme() {
+  return {
+    iconPathById: new Map(),
+    fileNames: {},
+    folderNames: {},
+    fileExtensions: {},
+  };
+}
+
+function loadBundledTreeIconTheme() {
+  if (bundledTreeIconThemeCache) {
+    return bundledTreeIconThemeCache;
+  }
+
+  const manifestPath = path.join(__dirname, BUNDLED_FILE_ICONS_MANIFEST_RELATIVE);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const manifestDir = path.dirname(manifestPath);
+    const iconPathById = new Map();
+    for (const [iconId, definition] of Object.entries(parsed?.iconDefinitions || {})) {
+      if (typeof definition?.iconPath !== 'string' || !definition.iconPath.trim()) {
+        continue;
+      }
+      const iconUri = vscode.Uri.file(path.resolve(manifestDir, definition.iconPath));
+      iconPathById.set(iconId, {
+        light: iconUri,
+        dark: iconUri,
+      });
+    }
+    bundledTreeIconThemeCache = {
+      iconPathById,
+      fileNames: parsed?.fileNames || {},
+      folderNames: parsed?.folderNames || {},
+      fileExtensions: parsed?.fileExtensions || {},
+    };
+  } catch (_error) {
+    bundledTreeIconThemeCache = emptyBundledTreeIconTheme();
+  }
+
+  return bundledTreeIconThemeCache;
+}
+
+function resolveBundledTreeItemIconId(relativePath, kind = 'file') {
+  const normalizedRelativePath = normalizeRelativePath(relativePath);
+  const entryName = path.posix.basename(normalizedRelativePath || '');
+  if (!entryName) {
+    return '';
+  }
+
+  const bundledTheme = loadBundledTreeIconTheme();
+  if (kind === 'folder') {
+    return bundledTheme.folderNames[entryName] || '';
+  }
+
+  if (bundledTheme.fileNames[entryName]) {
+    return bundledTheme.fileNames[entryName];
+  }
+
+  const matchingExtension = Object.keys(bundledTheme.fileExtensions)
+    .sort((left, right) => right.length - left.length)
+    .find((extension) => entryName === extension || entryName.endsWith(`.${extension}`));
+  return matchingExtension ? bundledTheme.fileExtensions[matchingExtension] : '';
+}
+
+function resolveBundledTreeItemIcon(relativePath, kind = 'file') {
+  const bundledTheme = loadBundledTreeIconTheme();
+  const iconId = resolveBundledTreeItemIconId(relativePath, kind);
+  return iconId ? bundledTheme.iconPathById.get(iconId) : undefined;
+}
+
 function sessionIdleDecoration(session, now = Date.now()) {
   if (!session) {
     return undefined;
@@ -105,9 +251,182 @@ function formatCountLabel(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
 
+function branchSegments(branch) {
+  return String(branch || '')
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+}
+
+function compactBranchLabel(branch) {
+  const segments = branchSegments(branch);
+  if (segments.length >= 3 && segments[0] === 'agent') {
+    return `${segments[1]}/${segments.slice(2).join('/')}`;
+  }
+  return segments.join('/');
+}
+
+function sessionFileCountLabel(session) {
+  const activityCountLabel = typeof session?.activityCountLabel === 'string'
+    ? session.activityCountLabel.trim()
+    : '';
+  if (activityCountLabel) {
+    return activityCountLabel;
+  }
+  if ((session?.changeCount || 0) > 0) {
+    return formatCountLabel(session.changeCount, 'file');
+  }
+  return '';
+}
+
+function uniqueStringList(values) {
+  const seen = new Set();
+  const result = [];
+
+  for (const value of values) {
+    if (typeof value !== 'string' || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.push(value);
+  }
+
+  return result;
+}
+
+function normalizeSessionProviderToken(value) {
+  return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function resolveSessionProvider(session) {
+  const signals = [
+    session?.cliName,
+    session?.agentName,
+    session?.branch,
+  ]
+    .map(normalizeSessionProviderToken)
+    .filter(Boolean);
+
+  if (signals.some((value) => value.includes('claude'))) {
+    return {
+      ...SESSION_PROVIDER_BRANDS.claude,
+      cliName: typeof session?.cliName === 'string' ? session.cliName.trim() : '',
+    };
+  }
+  if (signals.some((value) => value.includes('codex') || value.includes('openai'))) {
+    return {
+      ...SESSION_PROVIDER_BRANDS.openai,
+      cliName: typeof session?.cliName === 'string' ? session.cliName.trim() : '',
+    };
+  }
+  return null;
+}
+
+function sessionProviderDecoration(session) {
+  const provider = resolveSessionProvider(session);
+  if (!provider) {
+    return undefined;
+  }
+
+  const cliName = provider.cliName || provider.id;
+  return {
+    badge: provider.badge,
+    tooltip: `${provider.label} session via ${cliName}`,
+  };
+}
+
+function normalizeSnapshotIdentityValue(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function sessionSnapshotDisplayName(session) {
+  return normalizeSnapshotIdentityValue(session?.snapshotName)
+    || normalizeSnapshotIdentityValue(session?.snapshotEmail);
+}
+
+function sessionSnapshotBadge(session) {
+  const displayName = sessionSnapshotDisplayName(session);
+  const match = displayName.match(/[a-z0-9]/i);
+  return match ? match[0].toUpperCase() : '';
+}
+
+function sessionSnapshotDescription(session) {
+  const displayName = sessionSnapshotDisplayName(session);
+  return displayName ? `snapshot ${displayName}` : '';
+}
+
+function sessionSnapshotDecoration(session) {
+  const badge = sessionSnapshotBadge(session);
+  const displayName = sessionSnapshotDisplayName(session);
+  if (!badge || !displayName) {
+    return undefined;
+  }
+
+  return {
+    badge,
+    tooltip: `Snapshot ${displayName}`,
+  };
+}
+
+function sessionIdentityDecoration(session) {
+  return sessionSnapshotDecoration(session) || sessionProviderDecoration(session);
+}
+
+function stringListsEqual(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+    return false;
+  }
+
+  return left.every((value, index) => value === right[index]);
+}
+
+async function ensureManagedRepoScanIgnores() {
+  if (typeof vscode.workspace.getConfiguration !== 'function') {
+    return;
+  }
+
+  const workspaceFolders = vscode.workspace.workspaceFolders || [];
+  if (workspaceFolders.length === 0) {
+    return;
+  }
+
+  const workspaceFolderTarget = workspaceFolders.length > 1
+    ? vscode.ConfigurationTarget?.WorkspaceFolder
+    : vscode.ConfigurationTarget?.Workspace;
+  if (workspaceFolderTarget === undefined) {
+    return;
+  }
+
+  for (const workspaceFolder of workspaceFolders) {
+    const gitConfig = vscode.workspace.getConfiguration(GIT_CONFIGURATION_SECTION, workspaceFolder);
+    const configuredIgnoredFolders = gitConfig.get(REPO_SCAN_IGNORED_FOLDERS_SETTING);
+    const existingIgnoredFolders = Array.isArray(configuredIgnoredFolders)
+      ? configuredIgnoredFolders
+      : [];
+    const nextIgnoredFolders = uniqueStringList([
+      ...existingIgnoredFolders,
+      ...MANAGED_REPO_SCAN_IGNORED_FOLDERS,
+    ]);
+
+    if (stringListsEqual(existingIgnoredFolders, nextIgnoredFolders)) {
+      continue;
+    }
+
+    try {
+      await gitConfig.update(
+        REPO_SCAN_IGNORED_FOLDERS_SETTING,
+        nextIgnoredFolders,
+        workspaceFolderTarget,
+      );
+    } catch {
+      // Leave the extension usable even when the current workspace settings cannot be updated.
+    }
+  }
+}
+
 function sessionIdentityLabel(session) {
   const agentName = typeof session?.agentName === 'string' ? session.agentName.trim() : '';
-  const taskName = typeof session?.taskName === 'string' ? session.taskName.trim() : '';
+  const taskName = sessionDisplayLabel(session);
   const label = typeof session?.label === 'string' ? session.label.trim() : '';
 
   if (agentName && taskName) {
@@ -145,9 +464,10 @@ function agentBadgeFromBranch(branch) {
 }
 
 function buildActiveAgentsStatusSummary(summary) {
-  const activeCount = Math.max(0, (summary?.sessionCount || 0) - (summary?.deadCount || 0));
-  if (activeCount > 0) {
-    return `$(git-branch) ${formatCountLabel(activeCount, 'active agent')}`;
+  const workingCount = summary?.workingCount || 0;
+  const idleCount = summary?.idleCount || 0;
+  if (workingCount > 0 || idleCount > 0) {
+    return `$(git-branch) ${workingCount} working · ${idleCount} idle`;
   }
   return `$(git-branch) ${formatCountLabel(summary?.sessionCount || 0, 'tracked session')}`;
 }
@@ -159,7 +479,7 @@ function buildActiveAgentsStatusTooltip(selectedSession, summary) {
       sessionIdentityLabel(selectedSession),
       formatCountLabel(selectedSession.lockCount || 0, 'lock'),
       selectedSession.worktreePath,
-      'Click to open Source Control.',
+      'Click to open Active Agents.',
     ].filter(Boolean).join('\n');
   }
 
@@ -167,11 +487,490 @@ function buildActiveAgentsStatusTooltip(selectedSession, summary) {
   return [
     formatCountLabel(activeCount, 'active agent'),
     formatCountLabel(summary?.workingCount || 0, 'working now session', 'working now sessions'),
+    formatCountLabel(summary?.idleCount || 0, 'idle session'),
+    formatCountLabel(summary?.unassignedChangeCount || 0, 'unassigned change'),
+    formatCountLabel(summary?.lockedFileCount || 0, 'locked file'),
     summary?.deadCount ? formatCountLabel(summary.deadCount, 'dead session') : '',
-    'Click to open Source Control.',
+    'Click to open Active Agents.',
+  ].filter(Boolean).join('\n');
+}
+
+function compactRelativePath(relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized) {
+    return '';
+  }
+
+  const segments = normalized.split('/').filter(Boolean);
+  if (segments.length <= 2) {
+    return normalized;
+  }
+
+  return `${segments[0]}/.../${segments[segments.length - 1]}`;
+}
+
+function summarizeCompactPaths(paths, maxCount = SESSION_TOP_FILE_COUNT) {
+  const compactPaths = uniqueStringList((paths || [])
+    .map(normalizeRelativePath)
+    .filter(Boolean)
+    .map((relativePath) => compactRelativePath(relativePath)))
+    .slice(0, maxCount);
+  if (compactPaths.length === 0) {
+    return '';
+  }
+  return compactPaths.join(', ');
+}
+
+function isProtectedBranchName(branch) {
+  return branch === 'main' || branch === 'dev';
+}
+
+function countWorkingSessions(sessions) {
+  return sessions.filter((session) => (
+    session.activityKind === 'working' || session.activityKind === 'blocked'
+  )).length;
+}
+
+function countIdleSessions(sessions) {
+  return sessions.filter((session) => (
+    session.activityKind === 'idle' || session.activityKind === 'stalled'
+  )).length;
+}
+
+function sessionLastActiveAt(session) {
+  return [
+    session?.lastHeartbeatAt,
+    session?.lastFileActivityAt,
+    session?.telemetryUpdatedAt,
+    session?.startedAt,
+  ].find((value) => typeof value === 'string' && value.trim().length > 0) || '';
+}
+
+function sessionLastActiveLabel(session) {
+  const lastActiveAt = sessionLastActiveAt(session);
+  if (!lastActiveAt) {
+    return '';
+  }
+  return formatElapsedFrom(lastActiveAt);
+}
+
+function sessionLastActiveAgeMs(session, now = Date.now()) {
+  const lastActiveAt = sessionLastActiveAt(session);
+  const timestamp = Date.parse(lastActiveAt);
+  if (!Number.isFinite(timestamp)) {
+    return null;
+  }
+  return Math.max(0, now - timestamp);
+}
+
+function sessionFreshnessLabel(session, now = Date.now()) {
+  const ageMs = sessionLastActiveAgeMs(session, now);
+  if (session.activityKind === 'blocked') {
+    return 'Needs attention';
+  }
+  if (session.activityKind === 'stalled') {
+    return 'Possibly stale';
+  }
+  if (session.activityKind === 'dead') {
+    return 'Stopped';
+  }
+  if (ageMs === null) {
+    return '';
+  }
+  if (ageMs <= IDLE_WARNING_MS) {
+    return 'Fresh';
+  }
+  if (ageMs <= RECENTLY_ACTIVE_WINDOW_MS) {
+    return 'Recently active';
+  }
+  if (session.activityKind === 'idle') {
+    return 'Idle';
+  }
+  return 'Recently active';
+}
+
+function sessionStatusLabel(session) {
+  switch (session.activityKind) {
+    case 'blocked':
+      return 'Blocked';
+    case 'working':
+      return 'Working';
+    case 'idle':
+      return 'Idle';
+    case 'stalled':
+      return 'Stale';
+    case 'dead':
+      return 'Dead';
+    default:
+      return 'Thinking';
+  }
+}
+
+function sessionHealthScore(session) {
+  return Number.isInteger(session?.sessionHealth?.score) ? session.sessionHealth.score : null;
+}
+
+function buildSessionHealthCompactLabel(session) {
+  const score = sessionHealthScore(session);
+  return score === null ? '' : `${score}/100`;
+}
+
+function buildSessionHealthSummary(session) {
+  const compactLabel = buildSessionHealthCompactLabel(session);
+  if (!compactLabel) {
+    return '';
+  }
+
+  const label = typeof session?.sessionHealth?.label === 'string'
+    ? session.sessionHealth.label.trim()
+    : '';
+  return label ? `${compactLabel} · ${label}` : compactLabel;
+}
+
+function buildSessionHealthDriversSummary(session) {
+  const primaryDriver = typeof session?.sessionHealth?.primaryDriver === 'string'
+    ? session.sessionHealth.primaryDriver.trim()
+    : '';
+  const secondaries = uniqueStringList(Array.isArray(session?.sessionHealth?.secondaries)
+    ? session.sessionHealth.secondaries.map((value) => String(value || '').trim())
+    : []);
+  return [
+    primaryDriver ? `Primary: ${primaryDriver}` : '',
+    secondaries.length > 0 ? `Secondary: ${secondaries.join(', ')}` : '',
+  ].filter(Boolean).join(' | ');
+}
+
+function buildSessionHealthTooltip(session) {
+  const outputLine = typeof session?.sessionHealth?.outputLine === 'string'
+    ? session.sessionHealth.outputLine.trim()
+    : '';
+  if (outputLine) {
+    return outputLine;
+  }
+
+  return [
+    buildSessionHealthSummary(session),
+    buildSessionHealthDriversSummary(session),
   ].filter(Boolean).join('\n');
 }
 
+function buildSessionTopFiles(session) {
+  return uniqueStringList((session?.worktreeChangedPaths || [])
+    .map(normalizeRelativePath)
+    .filter(Boolean))
+    .slice(0, SESSION_TOP_FILE_COUNT);
+}
+
+function buildSessionRecentChangeSummary(session) {
+  if (session?.latestTaskPreview && session.latestTaskPreview !== session.taskName) {
+    return session.latestTaskPreview;
+  }
+  const topFiles = summarizeCompactPaths(session?.worktreeChangedPaths || []);
+  if (topFiles) {
+    return `Changed ${topFiles}`;
+  }
+  if (session?.activitySummary) {
+    return session.activitySummary;
+  }
+  return 'No recent change summary.';
+}
+
+function sessionRiskBadges(session) {
+  return uniqueStringList([
+    session?.activityKind === 'blocked' ? 'Blocked' : '',
+    session?.activityKind === 'stalled' ? 'Stale' : '',
+    session?.conflictCount > 0 ? 'Conflict' : '',
+    session?.lockCount > 0 ? 'Locked' : '',
+  ].filter(Boolean));
+}
+
+function changeRiskBadges(change) {
+  return uniqueStringList([
+    change?.protectedBranch ? 'Protected branch' : '',
+    change?.hasForeignLock ? 'Conflict' : '',
+    !change?.hasForeignLock && change?.lockOwnerBranch ? 'Locked' : '',
+    change?.deltaLabel || '',
+  ].filter(Boolean));
+}
+
+function buildSessionCardDescription(session) {
+  const provider = resolveSessionProvider(session);
+  const statusAgentLabel = `${sessionStatusLabel(session)}: ${session.agentName || 'agent'}`;
+  const descriptionParts = [
+    statusAgentLabel,
+    provider?.label ? `via ${provider.label}` : '',
+    sessionSnapshotDescription(session),
+    session.deltaLabel || '',
+    session.changeCount > 0 ? formatCountLabel(session.changeCount, 'changed file') : '',
+    session.lockCount > 0 ? formatCountLabel(session.lockCount, 'lock') : '',
+    buildSessionHealthCompactLabel(session),
+    session.freshnessLabel || '',
+    session.lastActiveLabel ? `${session.lastActiveLabel} ago` : '',
+  ].filter(Boolean);
+  return descriptionParts.join(' · ');
+}
+
+function buildRawSessionDescription(session) {
+  const provider = resolveSessionProvider(session);
+  const descriptionParts = [sessionStatusLabel(session)];
+  const fileCountLabel = sessionFileCountLabel(session);
+  if (fileCountLabel) {
+    descriptionParts.push(fileCountLabel);
+  }
+  if (provider?.label) {
+    descriptionParts.push(provider.label);
+  }
+  const snapshot = sessionSnapshotDescription(session);
+  if (snapshot) {
+    descriptionParts.push(snapshot);
+  }
+  descriptionParts.push(session.elapsedLabel || formatElapsedFrom(session.startedAt));
+  const sessionHealthLabel = buildSessionHealthCompactLabel(session);
+  if (sessionHealthLabel) {
+    descriptionParts.push(sessionHealthLabel);
+  }
+  if (session.lockCount > 0) {
+    descriptionParts.push(formatCountLabel(session.lockCount, 'lock'));
+  }
+  return descriptionParts.join(' · ');
+}
+
+function buildSessionTooltip(session, description) {
+  const provider = resolveSessionProvider(session);
+  const riskSummary = uniqueStringList([
+    ...(session?.riskBadges || []),
+    session?.deltaLabel || '',
+  ].filter(Boolean)).join(', ');
+  const topFiles = session?.topChangedFilesLabel || summarizeCompactPaths(session?.worktreeChangedPaths || []);
+  const sessionHealthSummary = buildSessionHealthSummary(session);
+  const sessionHealthDrivers = buildSessionHealthDriversSummary(session);
+  return [
+    session.branch,
+    provider?.label
+      ? `Provider ${provider.label}${provider.cliName ? ` (${provider.cliName})` : ''}`
+      : '',
+    sessionSnapshotDisplayName(session) ? `Snapshot ${sessionSnapshotDisplayName(session)}` : '',
+    `${session.agentName} · ${sessionDisplayLabel(session)}`,
+    `Status ${description}`,
+    sessionHealthSummary ? `Session health ${sessionHealthSummary}` : '',
+    sessionHealthDrivers ? `Drivers ${sessionHealthDrivers}` : '',
+    session.recentChangeSummary ? `Recent ${session.recentChangeSummary}` : '',
+    topFiles ? `Top files ${topFiles}` : '',
+    riskSummary ? `Signals ${riskSummary}` : '',
+    session.conflictCount > 0 ? `Conflicts ${session.conflictCount}` : '',
+    session.lastActiveAt ? `Last active ${session.lastActiveAt}` : '',
+    session.sourceKind === 'worktree-lock'
+      ? `Telemetry updated ${session.telemetryUpdatedAt || session.startedAt}`
+      : `Started ${session.startedAt}`,
+    session.worktreePath,
+  ].filter(Boolean).join('\n');
+}
+
+function buildUnassignedChangeDescription(change) {
+  return [
+    change.statusLabel,
+    ...changeRiskBadges(change),
+  ].filter(Boolean).join(' · ');
+}
+
+function buildWorktreeBranchDescription(sessions) {
+  const sessionList = Array.isArray(sessions) ? sessions : [];
+  const primarySession = sessionList[0] || null;
+  if (!primarySession) {
+    return '';
+  }
+
+  const descriptionParts = [
+    `${sessionStatusLabel(primarySession).toLowerCase()}: ${primarySession.agentName || 'agent'}`,
+    sessionSnapshotDescription(primarySession),
+  ];
+  if (sessionList.length > 1) {
+    descriptionParts.push(formatCountLabel(sessionList.length, 'agent'));
+  }
+  return descriptionParts.filter(Boolean).join(' · ');
+}
+
+function buildOverviewDescription(summary) {
+  return [
+    formatCountLabel(summary?.workingCount || 0, 'working agent'),
+    formatCountLabel(summary?.idleCount || 0, 'idle agent'),
+    formatCountLabel(summary?.unassignedChangeCount || 0, 'unassigned change'),
+    formatCountLabel(summary?.lockedFileCount || 0, 'locked file'),
+    formatCountLabel(summary?.conflictCount || 0, 'conflict'),
+  ].join(' · ');
+}
+
+function buildRepoDescription(summary) {
+  return buildOverviewDescription(summary);
+}
+
+function buildRepoTooltip(repoRoot, summary) {
+  return [
+    repoRoot,
+    buildOverviewDescription(summary),
+  ].join('\n');
+}
+
+function repoRootDisplayLabel(repoRoot) {
+  const normalizedRepoRoot = path.resolve(repoRoot);
+  const matchingWorkspaceRoots = (vscode.workspace.workspaceFolders || [])
+    .map((folder) => (typeof folder?.uri?.fsPath === 'string' ? path.resolve(folder.uri.fsPath) : ''))
+    .filter((workspaceRoot) => workspaceRoot && isPathWithin(workspaceRoot, normalizedRepoRoot))
+    .sort((left, right) => right.length - left.length);
+
+  const workspaceRoot = matchingWorkspaceRoots[0];
+  if (!workspaceRoot) {
+    return path.basename(normalizedRepoRoot);
+  }
+
+  const workspaceLabel = path.basename(workspaceRoot);
+  const relativePath = normalizeRelativePath(path.relative(workspaceRoot, normalizedRepoRoot));
+  if (!relativePath) {
+    return workspaceLabel;
+  }
+
+  return [
+    workspaceLabel,
+    ...relativePath.split('/').filter(Boolean),
+  ].join('/');
+}
+
+function sessionSnapshotKey(session) {
+  return `${session?.repoRoot || ''}::${session?.branch || ''}`;
+}
+
+function changeSnapshotKey(repoRoot, change) {
+  return `${repoRoot || ''}::${normalizeRelativePath(change?.relativePath)}`;
+}
+
+function buildSessionSnapshot(session) {
+  return {
+    activityKind: session.activityKind,
+    changeCount: session.changeCount || 0,
+    conflictCount: session.conflictCount || 0,
+    lockCount: session.lockCount || 0,
+    changedPaths: [...(session.changedPaths || [])],
+  };
+}
+
+function buildChangeSnapshot(change) {
+  return {
+    statusLabel: change.statusLabel,
+    hasForeignLock: Boolean(change.hasForeignLock),
+    lockOwnerBranch: change.lockOwnerBranch || '',
+  };
+}
+
+function deriveSessionDelta(previousSnapshot, currentSession) {
+  if (!previousSnapshot) {
+    return '';
+  }
+  if (currentSession.conflictCount > previousSnapshot.conflictCount) {
+    return 'Conflict';
+  }
+  if (currentSession.activityKind !== previousSnapshot.activityKind) {
+    return sessionStatusLabel(currentSession);
+  }
+  if (
+    currentSession.changeCount !== previousSnapshot.changeCount
+    || !stringListsEqual(currentSession.changedPaths || [], previousSnapshot.changedPaths || [])
+  ) {
+    return 'New';
+  }
+  if (currentSession.lockCount !== previousSnapshot.lockCount) {
+    return 'Updated';
+  }
+  return '';
+}
+
+function deriveChangeDelta(previousSnapshot, currentChange) {
+  if (!previousSnapshot) {
+    return '';
+  }
+  if (currentChange.hasForeignLock && !previousSnapshot.hasForeignLock) {
+    return 'Conflict';
+  }
+  if (
+    currentChange.statusLabel !== previousSnapshot.statusLabel
+    || currentChange.lockOwnerBranch !== previousSnapshot.lockOwnerBranch
+  ) {
+    return 'Updated';
+  }
+  return '';
+}
+
+function workingSessionSortKey(session) {
+  if (session.activityKind === 'blocked') {
+    return 0;
+  }
+  if (session.conflictCount > 0) {
+    return 1;
+  }
+  if (session.deltaLabel === 'Conflict') {
+    return 2;
+  }
+  if (session.deltaLabel === 'New') {
+    return 3;
+  }
+  return 4;
+}
+
+function idleSessionSortKey(session) {
+  if (session.activityKind === 'stalled') {
+    return 0;
+  }
+  if (session.activityKind === 'idle') {
+    return 1;
+  }
+  if (session.activityKind === 'dead') {
+    return 2;
+  }
+  return 3;
+}
+
+function sortSessionsForWorkingNow(sessions) {
+  return [...sessions].sort((left, right) => {
+    const keyDelta = workingSessionSortKey(left) - workingSessionSortKey(right);
+    if (keyDelta !== 0) {
+      return keyDelta;
+    }
+    const timeDelta = sessionLastActiveAgeMs(left) - sessionLastActiveAgeMs(right);
+    if (Number.isFinite(timeDelta) && timeDelta !== 0) {
+      return timeDelta;
+    }
+    const changeDelta = (right.changeCount || 0) - (left.changeCount || 0);
+    if (changeDelta !== 0) {
+      return changeDelta;
+    }
+    return sessionDisplayLabel(left).localeCompare(sessionDisplayLabel(right));
+  });
+}
+
+function sortSessionsForIdleThinking(sessions) {
+  return [...sessions].sort((left, right) => {
+    const keyDelta = idleSessionSortKey(left) - idleSessionSortKey(right);
+    if (keyDelta !== 0) {
+      return keyDelta;
+    }
+    const timeDelta = sessionLastActiveAgeMs(right) - sessionLastActiveAgeMs(left);
+    if (Number.isFinite(timeDelta) && timeDelta !== 0) {
+      return timeDelta;
+    }
+    return sessionDisplayLabel(left).localeCompare(sessionDisplayLabel(right));
+  });
+}
+
+function sortUnassignedChanges(changes) {
+  return [...changes].sort((left, right) => {
+    const leftBadges = changeRiskBadges(left).length;
+    const rightBadges = changeRiskBadges(right).length;
+    if (leftBadges !== rightBadges) {
+      return rightBadges - leftBadges;
+    }
+    return normalizeRelativePath(left.relativePath).localeCompare(normalizeRelativePath(right.relativePath));
+  });
+}
+
 function escapeHtml(value) {
   return String(value || '')
     .replace(/&/g, '&amp;')
@@ -366,7 +1165,12 @@ class SessionDecorationProvider {
       };
     }
 
-    return sessionIdleDecoration(this.sessionsByUri.get(uri.toString()), this.nowProvider());
+    const session = this.sessionsByUri.get(uri.toString());
+    const idleDecoration = sessionIdleDecoration(session, this.nowProvider());
+    if (idleDecoration) {
+      return idleDecoration;
+    }
+    return sessionIdentityDecoration(session);
   }
 }
 
@@ -374,49 +1178,50 @@ class InfoItem extends vscode.TreeItem {
   constructor(label, description = '') {
     super(label, vscode.TreeItemCollapsibleState.None);
     this.description = description;
-    this.iconPath = new vscode.ThemeIcon('info');
+    this.iconPath = themeIcon('info');
+    this.tooltip = [label, description].filter(Boolean).join('\n');
+  }
+}
+
+class DetailItem extends vscode.TreeItem {
+  constructor(label, description = '', options = {}) {
+    super(label, vscode.TreeItemCollapsibleState.None);
+    this.description = description;
+    this.tooltip = options.tooltip || [label, description].filter(Boolean).join('\n');
+    this.iconPath = options.iconId ? themeIcon(options.iconId, options.iconColorId) : undefined;
   }
 }
 
 class RepoItem extends vscode.TreeItem {
-  constructor(repoRoot, sessions, changes) {
-    super(path.basename(repoRoot), vscode.TreeItemCollapsibleState.Expanded);
+  constructor(repoRoot, sessions, changes, options = {}) {
+    const label = typeof options.label === 'string' && options.label.trim()
+      ? options.label.trim()
+      : repoRootDisplayLabel(repoRoot);
+    super(label, vscode.TreeItemCollapsibleState.Expanded);
     this.repoRoot = repoRoot;
     this.sessions = sessions;
     this.changes = changes;
-    const descriptionParts = [];
-    const activeCount = countActiveSessions(sessions);
-    const deadCount = countSessionsByActivityKind(sessions, 'dead');
-    const workingCount = countWorkingSessions(sessions);
-    if (activeCount > 0) {
-      descriptionParts.push(`${activeCount} active`);
-    }
-    if (deadCount > 0) {
-      descriptionParts.push(`${deadCount} dead`);
-    }
-    if (workingCount > 0) {
-      descriptionParts.push(`${workingCount} working`);
-    }
-    const changedCount = countChangedPaths(repoRoot, sessions, changes);
-    if (changedCount > 0) {
-      descriptionParts.push(`${changedCount} changed`);
-    }
-    this.description = descriptionParts.join(' · ');
-    this.tooltip = [
-      repoRoot,
-      this.description,
-    ].join('\n');
-    this.iconPath = new vscode.ThemeIcon('repo');
+    this.unassignedChanges = options.unassignedChanges || [];
+    this.lockEntries = options.lockEntries || [];
+    this.overview = options.overview || buildRepoOverview(sessions, this.unassignedChanges, this.lockEntries);
+    this.description = buildRepoDescription(this.overview);
+    this.tooltip = buildRepoTooltip(repoRoot, this.overview);
+    this.iconPath = themeIcon('repo');
     this.contextValue = 'gitguardex.repo';
   }
 }
 
 class SectionItem extends vscode.TreeItem {
   constructor(label, items, options = {}) {
-    super(label, vscode.TreeItemCollapsibleState.Expanded);
+    const collapsibleState = items.length > 0
+      ? (options.collapsedState ?? vscode.TreeItemCollapsibleState.Expanded)
+      : vscode.TreeItemCollapsibleState.None;
+    super(label, collapsibleState);
     this.items = items;
     this.description = options.description
       || (items.length > 0 ? String(items.length) : '');
+    this.tooltip = options.tooltip || [label, this.description].filter(Boolean).join('\n');
+    this.iconPath = options.iconId ? themeIcon(options.iconId, options.iconColorId) : undefined;
     this.contextValue = 'gitguardex.section';
   }
 }
@@ -425,32 +1230,35 @@ class WorktreeItem extends vscode.TreeItem {
   constructor(worktreePath, sessions, items = [], options = {}) {
     const normalizedWorktreePath = typeof worktreePath === 'string' ? worktreePath.trim() : '';
     const sessionList = Array.isArray(sessions) ? sessions : [];
+    const primarySession = options.resourceSession || sessionList[0] || null;
     const changedCount = Number.isInteger(options.changedCount)
       ? options.changedCount
       : sessionList.reduce((total, session) => total + (session.changeCount || 0), 0);
-    const descriptionParts = [formatCountLabel(sessionList.length, 'agent')];
-    if (changedCount > 0) {
-      descriptionParts.push(`${changedCount} changed`);
-    }
+    const label = typeof options.label === 'string' && options.label.trim()
+      ? options.label.trim()
+      : worktreeDisplayLabel(normalizedWorktreePath, sessionList);
     super(
-      path.basename(normalizedWorktreePath || '') || 'worktree',
+      label,
       items.length > 0 ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.None,
     );
     this.worktreePath = normalizedWorktreePath;
     this.sessions = sessionList;
     this.items = items;
-    this.description = options.description || descriptionParts.join(' · ');
+    this.description = options.description || buildWorktreeDescription(sessionList, changedCount);
     this.tooltip = [
       normalizedWorktreePath,
       ...sessionList.map((session) => session.branch).filter(Boolean),
     ].filter(Boolean).join('\n');
-    this.iconPath = new vscode.ThemeIcon('folder');
+    this.iconPath = themeIcon(options.iconId || 'folder', options.iconColorId);
+    if (options.useSessionDecoration && primarySession?.branch) {
+      this.resourceUri = sessionDecorationUri(primarySession.branch);
+    }
     this.contextValue = 'gitguardex.worktree';
-    if (sessionList[0]?.worktreePath) {
+    if (primarySession?.worktreePath) {
       this.command = {
         command: 'gitguardex.activeAgents.openWorktree',
         title: 'Open Agent Worktree',
-        arguments: [sessionList[0]],
+        arguments: [primarySession],
       };
     }
   }
@@ -458,51 +1266,29 @@ class WorktreeItem extends vscode.TreeItem {
 
 class SessionItem extends vscode.TreeItem {
   constructor(session, items = [], options = {}) {
-    const lockCount = Number.isFinite(session.lockCount) ? session.lockCount : 0;
+    const variant = options.variant === 'raw' ? 'raw' : 'card';
     const label = typeof options.label === 'string' && options.label.trim()
       ? options.label.trim()
-      : session.label;
+      : (variant === 'raw' ? session.label : sessionDisplayLabel(session));
+    const collapsibleState = items.length > 0
+      ? (options.collapsedState ?? (
+        variant === 'raw'
+          ? vscode.TreeItemCollapsibleState.Expanded
+          : vscode.TreeItemCollapsibleState.Collapsed
+      ))
+      : vscode.TreeItemCollapsibleState.None;
     super(
       label,
-      items.length > 0 ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.None,
+      collapsibleState,
     );
     this.session = session;
     this.items = items;
     this.resourceUri = sessionDecorationUri(session.branch);
-    const descriptionParts = [session.activityLabel || 'thinking'];
-    if (session.activityCountLabel) {
-      descriptionParts.push(session.activityCountLabel);
-    }
-    descriptionParts.push(session.elapsedLabel || formatElapsedFrom(session.startedAt));
-    if (lockCount > 0) {
-      descriptionParts.push(`${lockCount} $(lock)`);
-    }
-    this.description = descriptionParts.join(' · ');
-    const tooltipLines = [
-      session.branch,
-      `${session.agentName} · ${session.taskName}`,
-      session.latestTaskPreview && session.latestTaskPreview !== session.taskName
-        ? `Live task ${session.latestTaskPreview}`
-        : '',
-      `Status ${this.description}`,
-      session.changeCount > 0
-        ? `Changed ${session.activityCountLabel}: ${session.activitySummary}`
-        : session.activitySummary,
-      `Locks ${lockCount}`,
-      session.conflictCount > 0 ? `Conflicts ${session.conflictCount}` : '',
-      Number.isInteger(session.pid) && session.pid > 0
-        ? session.pidAlive === false
-          ? `PID ${session.pid} not alive`
-          : `PID ${session.pid} alive`
-        : '',
-      session.lastFileActivityAt ? `Last file activity ${session.lastFileActivityAt}` : '',
-      session.sourceKind === 'worktree-lock'
-        ? `Telemetry updated ${session.telemetryUpdatedAt || session.startedAt}`
-        : `Started ${session.startedAt}`,
-      session.worktreePath,
-    ];
-    this.tooltip = tooltipLines.filter(Boolean).join('\n');
-    this.iconPath = new vscode.ThemeIcon(resolveSessionActivityIconId(session.activityKind));
+    this.description = variant === 'raw'
+      ? buildRawSessionDescription(session)
+      : buildSessionCardDescription(session);
+    this.tooltip = buildSessionTooltip(session, this.description);
+    this.iconPath = themeIcon(resolveSessionActivityIconId(session.activityKind));
     this.contextValue = 'gitguardex.session';
     this.command = {
       command: 'gitguardex.activeAgents.openWorktree',
@@ -513,31 +1299,47 @@ class SessionItem extends vscode.TreeItem {
 }
 
 class FolderItem extends vscode.TreeItem {
-  constructor(label, relativePath, items) {
-    super(label, vscode.TreeItemCollapsibleState.Expanded);
+  constructor(label, relativePath, items, options = {}) {
+    super(
+      label,
+      items.length > 0
+        ? (options.collapsedState ?? vscode.TreeItemCollapsibleState.Expanded)
+        : vscode.TreeItemCollapsibleState.None,
+    );
     this.relativePath = relativePath;
     this.items = items;
-    this.tooltip = relativePath;
-    this.iconPath = new vscode.ThemeIcon('folder');
-    this.contextValue = 'gitguardex.folder';
+    this.description = typeof options.description === 'string' ? options.description : '';
+    this.tooltip = options.tooltip || relativePath || label;
+    this.iconPath = options.iconPath
+      || (!options.iconId ? resolveBundledTreeItemIcon(relativePath || label, 'folder') : undefined)
+      || themeIcon(options.iconId || 'folder', options.iconColorId);
+    this.contextValue = options.contextValue || 'gitguardex.folder';
   }
 }
 
 class ChangeItem extends vscode.TreeItem {
-  constructor(change) {
-    super(path.basename(change.relativePath), vscode.TreeItemCollapsibleState.None);
+  constructor(change, options = {}) {
+    const label = typeof options.label === 'string' && options.label.trim()
+      ? options.label.trim()
+      : path.basename(change.relativePath);
+    super(label, vscode.TreeItemCollapsibleState.None);
     this.change = change;
-    this.description = change.statusLabel;
+    this.description = typeof options.description === 'string'
+      ? options.description
+      : change.statusLabel;
     this.tooltip = [
       change.relativePath,
+      `Summary ${this.description}`,
       `Status ${change.statusText}`,
       change.originalPath ? `Renamed from ${change.originalPath}` : '',
       change.hasForeignLock ? `Locked by ${change.lockOwnerBranch}` : '',
       change.absolutePath,
     ].filter(Boolean).join('\n');
     this.resourceUri = vscode.Uri.file(change.absolutePath);
-    if (change.hasForeignLock) {
-      this.iconPath = new vscode.ThemeIcon('warning');
+    if (options.iconId || change.hasForeignLock) {
+      this.iconPath = themeIcon(options.iconId || 'warning', options.iconColorId || 'list.warningForeground');
+    } else {
+      this.iconPath = options.iconPath || resolveBundledTreeItemIcon(change.relativePath || label, 'file');
     }
     this.contextValue = 'gitguardex.change';
     this.command = {
@@ -562,32 +1364,278 @@ function readPackageJson(repoRoot) {
   }
 }
 
-function resolveStartAgentCommand(repoRoot, details) {
-  const taskArg = shellQuote(details.taskName);
-  const agentArg = shellQuote(details.agentName);
-  const localCodexAgentPath = path.join(repoRoot, 'scripts', 'codex-agent.sh');
-  if (fs.existsSync(localCodexAgentPath)) {
-    return `bash ./scripts/codex-agent.sh ${taskArg} ${agentArg}`;
+function resolveStartAgentCommand(repoRoot, details) {
+  const taskArg = shellQuote(details.taskName);
+  const agentArg = shellQuote(details.agentName);
+  const localCodexAgentPath = path.join(repoRoot, 'scripts', 'codex-agent.sh');
+  if (fs.existsSync(localCodexAgentPath)) {
+    return `bash ./scripts/codex-agent.sh ${taskArg} ${agentArg}`;
+  }
+
+  const agentCodexScript = readPackageJson(repoRoot)?.scripts?.['agent:codex'];
+  if (typeof agentCodexScript === 'string' && agentCodexScript.trim().length > 0) {
+    return `npm run agent:codex -- ${taskArg} ${agentArg}`;
+  }
+
+  return `gx branch start ${taskArg} ${agentArg}`;
+}
+
+function sessionTaskLabel(session) {
+  const latestTaskPreview = typeof session?.latestTaskPreview === 'string'
+    ? session.latestTaskPreview.trim()
+    : '';
+  if (latestTaskPreview) {
+    return latestTaskPreview;
+  }
+
+  const taskName = typeof session?.taskName === 'string' ? session.taskName.trim() : '';
+  if (taskName) {
+    return taskName;
+  }
+
+  return '';
+}
+
+function sessionDisplayLabel(session) {
+  return sessionTaskLabel(session)
+    || session?.label
+    || compactBranchLabel(session?.branch)
+    || session?.branch
+    || path.basename(session?.worktreePath || '')
+    || 'session';
+}
+
+function sessionTreeLabel(session) {
+  return sessionTaskLabel(session) || compactBranchLabel(session?.branch) || sessionDisplayLabel(session);
+}
+
+function worktreeDisplayLabel(worktreePath, sessions) {
+  const sessionList = Array.isArray(sessions)
+    ? sessions.filter(Boolean)
+    : [];
+  if (sessionList.length === 1) {
+    return sessionDisplayLabel(sessionList[0]);
+  }
+
+  return path.basename(String(worktreePath || '').trim()) || 'worktree';
+}
+
+function buildWorktreeDescription(sessions, changedCount) {
+  const sessionList = Array.isArray(sessions)
+    ? sessions.filter(Boolean)
+    : [];
+  const primarySession = sessionList.length === 1 ? sessionList[0] : null;
+  const totalLocks = sessionList.reduce((total, session) => total + (session.lockCount || 0), 0);
+  const descriptionParts = [];
+
+  if (primarySession?.agentName) {
+    descriptionParts.push(primarySession.agentName);
+  } else {
+    descriptionParts.push(formatCountLabel(sessionList.length, 'agent'));
+  }
+
+  const fileCountLabel = primarySession
+    ? sessionFileCountLabel(primarySession)
+    : changedCount > 0
+      ? formatCountLabel(changedCount, 'file')
+      : '';
+  if (fileCountLabel) {
+    descriptionParts.push(fileCountLabel);
+  }
+  if (totalLocks > 0) {
+    descriptionParts.push(formatCountLabel(totalLocks, 'lock'));
+  }
+
+  return descriptionParts.join(' · ');
+}
+
+function sessionWorktreePath(session) {
+  return typeof session?.worktreePath === 'string' ? session.worktreePath.trim() : '';
+}
+
+function resolveSessionProjectRelativePath(session) {
+  const repoRoot = typeof session?.repoRoot === 'string' ? session.repoRoot.trim() : '';
+  if (!repoRoot) {
+    return '';
+  }
+
+  const resolveCandidate = (candidatePath) => {
+    const normalizedCandidate = typeof candidatePath === 'string' ? candidatePath.trim() : '';
+    if (!normalizedCandidate) {
+      return '';
+    }
+
+    const absolutePath = path.isAbsolute(normalizedCandidate)
+      ? path.resolve(normalizedCandidate)
+      : path.resolve(repoRoot, normalizedCandidate);
+    if (!isPathWithin(repoRoot, absolutePath) || !fs.existsSync(absolutePath)) {
+      return '';
+    }
+
+    return normalizeRelativePath(path.relative(repoRoot, absolutePath));
+  };
+
+  const isManagedWorktreeRelativePath = (relativePath) => {
+    const normalizedRelativePath = normalizeRelativePath(relativePath);
+    return MANAGED_WORKTREE_RELATIVE_ROOTS.some((managedRoot) => {
+      const normalizedManagedRoot = normalizeRelativePath(managedRoot);
+      return normalizedRelativePath === normalizedManagedRoot
+        || normalizedRelativePath.startsWith(`${normalizedManagedRoot}/`);
+    });
+  };
+
+  const explicitProjectPath = resolveCandidate(session?.projectPath);
+  if (explicitProjectPath && !isManagedWorktreeRelativePath(explicitProjectPath)) {
+    return explicitProjectPath;
+  }
+
+  const namedProjectPath = resolveCandidate(session?.projectName);
+  if (namedProjectPath && !isManagedWorktreeRelativePath(namedProjectPath)) {
+    return namedProjectPath;
+  }
+  return '';
+}
+
+function worktreeProjectRelativePath(sessions) {
+  const projectPaths = uniqueStringList((sessions || [])
+    .map((session) => resolveSessionProjectRelativePath(session))
+    .filter(Boolean));
+  return projectPaths.length === 1 ? projectPaths[0] : '';
+}
+
+function repoEntryDisplayLabel(repoRoot, sessions) {
+  const repoLabel = repoRootDisplayLabel(repoRoot);
+  const projectPaths = uniqueStringList((sessions || [])
+    .map((session) => resolveSessionProjectRelativePath(session))
+    .filter(Boolean));
+  if (projectPaths.length !== 1) {
+    return repoLabel;
+  }
+
+  const [projectRelativePath] = projectPaths;
+  const hasRootScopedSession = (sessions || []).some(
+    (session) => !resolveSessionProjectRelativePath(session),
+  );
+  if (!projectRelativePath || hasRootScopedSession) {
+    return repoLabel;
+  }
+  if (repoLabel.endsWith(`/${projectRelativePath}`)) {
+    return repoLabel;
+  }
+  return `${repoLabel}/${projectRelativePath}`;
+}
+
+function buildProjectScopedDescription(entries) {
+  const sessions = (entries || []).flatMap((entry) => Array.isArray(entry?.sessions) ? entry.sessions : []);
+  if (sessions.length === 0) {
+    return '';
+  }
+
+  const changedCount = sessions.reduce((total, session) => total + (session.changeCount || 0), 0);
+  const lockCount = sessions.reduce((total, session) => total + (session.lockCount || 0), 0);
+  const descriptionParts = [formatCountLabel(sessions.length, 'agent')];
+  if (changedCount > 0) {
+    descriptionParts.push(formatCountLabel(changedCount, 'file'));
+  }
+  if (lockCount > 0) {
+    descriptionParts.push(formatCountLabel(lockCount, 'lock'));
+  }
+  return descriptionParts.join(' · ');
+}
+
+function buildProjectScopedItems(entries, options = {}) {
+  const normalizedEntries = Array.isArray(entries)
+    ? entries.filter((entry) => entry?.item)
+    : [];
+  const projectRoots = [];
+  const rootEntries = [];
+  let hasProjectFolders = false;
+
+  function sortFolders(nodes) {
+    nodes.sort((left, right) => left.label.localeCompare(right.label));
+    for (const node of nodes) {
+      sortFolders(node.children);
+    }
+  }
+
+  for (const entry of normalizedEntries) {
+    const projectRelativePath = normalizeRelativePath(entry.projectRelativePath);
+    if (!projectRelativePath) {
+      rootEntries.push(entry);
+      continue;
+    }
+
+    hasProjectFolders = true;
+    let nodes = projectRoots;
+    let folderPath = '';
+    let parentNode = null;
+    for (const segment of projectRelativePath.split('/').filter(Boolean)) {
+      folderPath = folderPath ? path.posix.join(folderPath, segment) : segment;
+      let folderNode = nodes.find((node) => node.relativePath === folderPath);
+      if (!folderNode) {
+        folderNode = {
+          label: segment,
+          relativePath: folderPath,
+          children: [],
+          entries: [],
+          directEntries: [],
+        };
+        nodes.push(folderNode);
+      }
+      folderNode.entries.push(entry);
+      parentNode = folderNode;
+      nodes = folderNode.children;
+    }
+
+    if (parentNode) {
+      parentNode.directEntries.push(entry);
+    } else {
+      rootEntries.push(entry);
+    }
   }
 
-  const agentCodexScript = readPackageJson(repoRoot)?.scripts?.['agent:codex'];
-  if (typeof agentCodexScript === 'string' && agentCodexScript.trim().length > 0) {
-    return `npm run agent:codex -- ${taskArg} ${agentArg}`;
+  if (!hasProjectFolders) {
+    return rootEntries.map((entry) => entry.item);
   }
 
-  return `gx branch start ${taskArg} ${agentArg}`;
-}
+  sortFolders(projectRoots);
 
-function sessionDisplayLabel(session) {
-  return session?.taskName || session?.label || session?.branch || path.basename(session?.worktreePath || '') || 'session';
-}
+  function materialize(nodes) {
+    return nodes.map((node) => new FolderItem(
+      node.label,
+      node.relativePath,
+      [
+        ...materialize(node.children),
+        ...node.directEntries.map((entry) => entry.item),
+      ],
+      {
+        description: buildProjectScopedDescription(node.entries),
+        tooltip: [node.relativePath, buildProjectScopedDescription(node.entries)].filter(Boolean).join('\n'),
+      },
+    ));
+  }
 
-function sessionTreeLabel(session) {
-  return session?.branch || sessionDisplayLabel(session);
-}
+  const items = materialize(projectRoots);
+  if (rootEntries.length === 0) {
+    return items;
+  }
 
-function sessionWorktreePath(session) {
-  return typeof session?.worktreePath === 'string' ? session.worktreePath.trim() : '';
+  const rootLabel = typeof options.rootLabel === 'string' ? options.rootLabel.trim() : '';
+  if (!rootLabel) {
+    items.push(...rootEntries.map((entry) => entry.item));
+    return items;
+  }
+
+  items.push(new FolderItem(
+    rootLabel,
+    '',
+    rootEntries.map((entry) => entry.item),
+    {
+      description: buildProjectScopedDescription(rootEntries),
+      tooltip: rootLabel,
+    },
+  ));
+  return items;
 }
 
 function showSessionMessage(message) {
@@ -622,6 +1670,82 @@ function runSessionTerminalCommand(session, actionLabel, iconId, commandText) {
   terminal.sendText(commandText, true);
 }
 
+function sessionTerminalLabel(session) {
+  return `GitGuardex Terminal: ${sessionDisplayLabel(session)}`;
+}
+
+function listWindowTerminals() {
+  return Array.isArray(vscode.window.terminals) ? vscode.window.terminals : [];
+}
+
+function focusTerminal(terminal) {
+  terminal?.show?.(false);
+}
+
+async function terminalProcessId(terminal) {
+  if (!terminal?.processId) {
+    return null;
+  }
+
+  try {
+    const pid = await terminal.processId;
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function findFallbackSessionTerminal(session) {
+  const label = sessionTerminalLabel(session);
+  return listWindowTerminals().find((terminal) => terminal?.name === label) || null;
+}
+
+async function findSessionTerminal(session) {
+  const pid = Number(session?.pid);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+
+  for (const terminal of listWindowTerminals()) {
+    if (await terminalProcessId(terminal) === pid) {
+      return terminal;
+    }
+  }
+
+  return null;
+}
+
+function openFallbackSessionTerminal(session, worktreePath) {
+  const existingTerminal = findFallbackSessionTerminal(session);
+  if (existingTerminal) {
+    focusTerminal(existingTerminal);
+    return existingTerminal;
+  }
+
+  const terminal = vscode.window.createTerminal({
+    name: sessionTerminalLabel(session),
+    cwd: worktreePath,
+    iconPath: new vscode.ThemeIcon('terminal'),
+  });
+  focusTerminal(terminal);
+  return terminal;
+}
+
+async function showSessionTerminal(session) {
+  const worktreePath = ensureSessionWorktree(session, 'show terminal');
+  if (!worktreePath) {
+    return;
+  }
+
+  const terminal = await findSessionTerminal(session);
+  if (terminal) {
+    focusTerminal(terminal);
+    return;
+  }
+
+  openFallbackSessionTerminal(session, worktreePath);
+}
+
 function finishSession(session) {
   if (!session?.branch) {
     showSessionMessage('Cannot finish session: missing branch name.');
@@ -639,6 +1763,13 @@ function syncSession(session) {
   runSessionTerminalCommand(session, 'Sync', 'sync', 'gx sync');
 }
 
+async function restartActiveAgents(extensionId) {
+  if (extensionId && extensionId !== ACTIVE_AGENTS_EXTENSION_ID) {
+    return;
+  }
+  await vscode.commands.executeCommand(RESTART_EXTENSION_HOST_COMMAND);
+}
+
 function execFileAsync(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     cp.execFile(command, args, options, (error, stdout = '', stderr = '') => {
@@ -653,6 +1784,14 @@ function execFileAsync(command, args, options = {}) {
   });
 }
 
+function buildStopSessionCommandText(session, pid) {
+  const parts = ['gx', 'agents', 'stop', '--pid', String(pid)];
+  if (session?.repoRoot) {
+    parts.push('--target', session.repoRoot);
+  }
+  return parts.map(shellQuote).join(' ');
+}
+
 async function stopSession(session, refresh) {
   const pid = Number(session?.pid);
   if (!Number.isInteger(pid) || pid <= 0) {
@@ -664,15 +1803,29 @@ async function stopSession(session, refresh) {
     return;
   }
 
+  const sessionTerminal = await findSessionTerminal(session);
+  const stopCommandText = buildStopSessionCommandText(session, pid);
   const confirmed = await vscode.window.showWarningMessage(
     `Stop ${sessionDisplayLabel(session)}?`,
-    { modal: true, detail: `Run gx agents stop --pid ${pid}.` },
+    {
+      modal: true,
+      detail: sessionTerminal
+        ? 'Send Ctrl+C to the live session terminal.'
+        : `No live session terminal found. Run ${stopCommandText}.`,
+    },
     'Stop',
   );
   if (confirmed !== 'Stop') {
     return;
   }
 
+  if (sessionTerminal) {
+    focusTerminal(sessionTerminal);
+    sessionTerminal.sendText('\u0003', false);
+    refresh();
+    return;
+  }
+
   try {
     const commandCwd = session?.repoRoot || sessionWorktreePath(session) || process.cwd();
     const args = ['agents', 'stop', '--pid', String(pid)];
@@ -692,69 +1845,87 @@ async function stopSession(session, refresh) {
   }
 }
 
-function sessionChangedPaths(session) {
-  const directPaths = Array.isArray(session?.changedPaths)
-    ? session.changedPaths.map(normalizeRelativePath).filter(Boolean)
-    : [];
-  if (directPaths.length > 0) {
-    return [...new Set(directPaths)];
+function readGitDirPath(targetPath) {
+  const normalizedTargetPath = typeof targetPath === 'string' ? targetPath.trim() : '';
+  if (!normalizedTargetPath) {
+    return '';
   }
-  if (!session?.repoRoot || !session?.branch) {
-    return [];
+
+  const gitPath = path.join(path.resolve(normalizedTargetPath), '.git');
+  try {
+    if (fs.statSync(gitPath).isDirectory()) {
+      return gitPath;
+    }
+  } catch (_error) {
+    return '';
   }
 
-  const liveSession = readActiveSessions(session.repoRoot)
-    .find((entry) => sessionSelectionKey(entry) === sessionSelectionKey(session));
-  return Array.isArray(liveSession?.changedPaths)
-    ? [...new Set(liveSession.changedPaths.map(normalizeRelativePath).filter(Boolean))]
-    : [];
+  try {
+    const gitPointer = fs.readFileSync(gitPath, 'utf8');
+    const match = gitPointer.match(/^gitdir:\s*(.+)$/m);
+    if (match?.[1]) {
+      return path.resolve(path.dirname(gitPath), match[1].trim());
+    }
+  } catch (_error) {
+    return '';
+  }
+
+  return '';
 }
 
-async function pickSessionDiffPath(session) {
-  const changedPaths = sessionChangedPaths(session);
-  if (changedPaths.length === 0) {
+function resolveRepoRootFromGitDir(targetPath) {
+  const gitDir = readGitDirPath(targetPath);
+  if (!gitDir) {
     return '';
   }
-  if (changedPaths.length === 1 || !vscode.window.showQuickPick) {
-    return changedPaths[0];
+
+  let commonDir = gitDir;
+  try {
+    const commonDirPath = path.join(gitDir, 'commondir');
+    if (fs.existsSync(commonDirPath)) {
+      const rawCommonDir = fs.readFileSync(commonDirPath, 'utf8').trim();
+      if (rawCommonDir) {
+        commonDir = path.resolve(gitDir, rawCommonDir);
+      }
+    }
+  } catch (_error) {
+    // Fall back to the direct git dir when commondir is unreadable.
   }
 
-  const picks = changedPaths.map((relativePath) => ({
-    label: path.basename(relativePath),
-    description: relativePath,
-    relativePath,
-  }));
-  const selection = await vscode.window.showQuickPick(picks, {
-    placeHolder: `Select a changed file for ${sessionDisplayLabel(session)}`,
-    ignoreFocusOut: true,
-  });
-  return selection?.relativePath || '';
+  return path.basename(commonDir) === '.git'
+    ? path.resolve(path.dirname(commonDir))
+    : '';
 }
 
-async function openSessionDiff(session) {
-  const worktreePath = ensureSessionWorktree(session, 'open diff');
-  if (!worktreePath) {
-    return;
+function readGitTopLevel(targetPath) {
+  try {
+    return cp.execFileSync('git', ['-C', targetPath, 'rev-parse', '--show-toplevel'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch (_error) {
+    return '';
   }
+}
 
-  const relativePath = await pickSessionDiffPath(session);
-  if (!relativePath) {
-    showSessionMessage(`No changed files to diff for ${sessionDisplayLabel(session)}.`);
-    return;
+function resolveWorkspaceFolderRepoRoot(workspacePath) {
+  const normalizedWorkspacePath = typeof workspacePath === 'string' ? workspacePath.trim() : '';
+  if (!normalizedWorkspacePath) {
+    return '';
   }
 
-  const repoRoot = session?.repoRoot || worktreePath;
-  const absolutePath = path.resolve(repoRoot, relativePath);
-  const resourceUri = vscode.Uri.file(absolutePath);
-  try {
-    await vscode.commands.executeCommand('git.openChange', resourceUri);
-  } catch (error) {
-    if (fs.existsSync(absolutePath)) {
-      await vscode.commands.executeCommand('vscode.open', resourceUri);
-      return;
-    }
-    showSessionMessage(`Failed to open diff for ${sessionDisplayLabel(session)}: ${formatGitCommandFailure(error)}`);
+  const absoluteWorkspacePath = path.resolve(normalizedWorkspacePath);
+  const directRepoRoot = resolveRepoRootFromGitDir(absoluteWorkspacePath);
+  if (directRepoRoot) {
+    return directRepoRoot;
   }
+
+  const gitTopLevel = readGitTopLevel(absoluteWorkspacePath);
+  if (!gitTopLevel) {
+    return absoluteWorkspacePath;
+  }
+
+  return resolveRepoRootFromGitDir(gitTopLevel) || path.resolve(gitTopLevel);
 }
 
 function repoRootFromSessionFile(filePath) {
@@ -765,6 +1936,10 @@ function repoRootFromWorktreeLockFile(filePath) {
   return path.resolve(path.dirname(filePath), '..', '..', '..');
 }
 
+function repoRootFromManagedWorktreeGitFile(filePath) {
+  return path.resolve(path.dirname(filePath), '..', '..', '..');
+}
+
 function repoRootFromLockFile(filePath) {
   return path.resolve(path.dirname(filePath), '..', '..');
 }
@@ -952,22 +2127,33 @@ async function maybeAutoUpdateActiveAgentsExtension(context) {
 
 function decorateSession(session, lockRegistry) {
   const touchedChanges = buildSessionTouchedChanges(session, lockRegistry);
-  return {
+  const decorated = {
     ...session,
     lockCount: lockRegistry.countsByBranch.get(session.branch) || 0,
     touchedChanges,
     conflictCount: touchedChanges.filter((change) => change.hasForeignLock).length,
   };
+  decorated.lastActiveAt = sessionLastActiveAt(decorated);
+  decorated.lastActiveLabel = sessionLastActiveLabel(decorated);
+  decorated.freshnessLabel = sessionFreshnessLabel(decorated);
+  decorated.topChangedFiles = buildSessionTopFiles(decorated);
+  decorated.topChangedFilesLabel = summarizeCompactPaths(decorated.topChangedFiles);
+  decorated.recentChangeSummary = buildSessionRecentChangeSummary(decorated);
+  decorated.riskBadges = sessionRiskBadges(decorated);
+  return decorated;
 }
 
 function decorateChange(change, lockRegistry, owningBranch) {
   const lockEntry = lockRegistry.entriesByPath.get(normalizeRelativePath(change.relativePath));
   const lockOwnerBranch = lockEntry?.branch || '';
-  return {
+  const decorated = {
     ...change,
     lockOwnerBranch,
     hasForeignLock: Boolean(lockOwnerBranch) && (!owningBranch || lockOwnerBranch !== owningBranch),
+    protectedBranch: isProtectedBranchName(owningBranch),
   };
+  decorated.riskBadges = changeRiskBadges(decorated);
+  return decorated;
 }
 
 function buildSessionTouchedChanges(session, lockRegistry) {
@@ -975,7 +2161,6 @@ function buildSessionTouchedChanges(session, lockRegistry) {
     ? session.worktreeChangedPaths
     : [];
   return [...new Set(changedPaths.map(normalizeRelativePath).filter(Boolean))]
-    .sort((left, right) => left.localeCompare(right))
     .map((relativePath) => {
       const lockEntry = lockRegistry.entriesByPath.get(relativePath);
       const lockOwnerBranch = lockEntry?.branch || '';
@@ -1018,7 +2203,7 @@ function localizeChangeForSession(session, change) {
 }
 
 async function findRepoSessionEntries() {
-  const [sessionFiles, worktreeLockFiles] = await Promise.all([
+  const [sessionFiles, worktreeLockFiles, managedWorktreeGitFiles] = await Promise.all([
     vscode.workspace.findFiles(
       ACTIVE_SESSION_FILES_GLOB,
       SESSION_SCAN_EXCLUDE_GLOB,
@@ -1029,22 +2214,49 @@ async function findRepoSessionEntries() {
       WORKTREE_LOCK_SCAN_EXCLUDE_GLOB,
       SESSION_SCAN_LIMIT,
     ),
+    vscode.workspace.findFiles(
+      MANAGED_WORKTREE_GIT_FILES_GLOB,
+      MANAGED_WORKTREE_GIT_SCAN_EXCLUDE_GLOB,
+      SESSION_SCAN_LIMIT,
+    ),
   ]);
 
   const repoRoots = new Set();
+  const addRepoRootCandidate = (repoRoot) => {
+    if (typeof repoRoot !== 'string' || !repoRoot.trim()) {
+      return;
+    }
+
+    const normalizedRepoRoot = path.resolve(repoRoot);
+    const isInsideWorkspaceManagedWorktree = (vscode.workspace.workspaceFolders || [])
+      .map((folder) => (typeof folder?.uri?.fsPath === 'string' ? path.resolve(folder.uri.fsPath) : ''))
+      .filter(Boolean)
+      .some((workspaceRoot) => MANAGED_WORKTREE_RELATIVE_ROOTS.some((relativeRoot) => (
+        isPathWithin(path.join(workspaceRoot, relativeRoot), normalizedRepoRoot)
+      )));
+    if (!isInsideWorkspaceManagedWorktree) {
+      repoRoots.add(normalizedRepoRoot);
+    }
+  };
+
   for (const uri of sessionFiles) {
-    repoRoots.add(repoRootFromSessionFile(uri.fsPath));
+    addRepoRootCandidate(repoRootFromSessionFile(uri.fsPath));
   }
   for (const uri of worktreeLockFiles) {
     if (path.basename(uri.fsPath) !== 'AGENT.lock') {
       continue;
     }
-    repoRoots.add(repoRootFromWorktreeLockFile(uri.fsPath));
+    addRepoRootCandidate(repoRootFromWorktreeLockFile(uri.fsPath));
   }
-
-  if (repoRoots.size === 0) {
-    for (const workspaceFolder of vscode.workspace.workspaceFolders || []) {
-      repoRoots.add(workspaceFolder.uri.fsPath);
+  for (const uri of managedWorktreeGitFiles) {
+    if (path.basename(uri.fsPath) !== '.git') {
+      continue;
+    }
+    addRepoRootCandidate(repoRootFromManagedWorktreeGitFile(uri.fsPath));
+  }
+  for (const workspaceFolder of vscode.workspace.workspaceFolders || []) {
+    if (workspaceFolder?.uri?.fsPath) {
+      addRepoRootCandidate(resolveWorkspaceFolderRepoRoot(workspaceFolder.uri.fsPath));
     }
   }
 
@@ -1164,10 +2376,6 @@ function buildChangeTreeNodes(changes) {
   return materialize(root);
 }
 
-function countWorkingSessions(sessions) {
-  return sessions.filter((session) => session.activityKind === 'working').length;
-}
-
 function countChangedPaths(repoRoot, sessions, changes) {
   const changedKeys = new Set();
 
@@ -1193,6 +2401,20 @@ function countChangedPaths(repoRoot, sessions, changes) {
   return changedKeys.size;
 }
 
+function buildRepoOverview(sessions, unassignedChanges, lockEntries) {
+  return {
+    sessionCount: sessions.length,
+    workingCount: countWorkingSessions(sessions),
+    idleCount: countIdleSessions(sessions),
+    unassignedChangeCount: (unassignedChanges || []).length,
+    lockedFileCount: Array.isArray(lockEntries) ? lockEntries.length : 0,
+    conflictCount: sessions.reduce(
+      (total, session) => total + (session.conflictCount || 0),
+      0,
+    ) + (unassignedChanges || []).filter((change) => change.hasForeignLock).length,
+  };
+}
+
 function groupSessionsByWorktree(sessions) {
   const sessionsByWorktree = new Map();
 
@@ -1223,7 +2445,7 @@ function groupSessionsByWorktree(sessions) {
     });
 }
 
-function buildGroupedChangeTreeNodes(sessions, changes) {
+function partitionChangesByOwnership(sessions, changes) {
   const changesBySession = new Map();
   const sessionByChangedPath = new Map();
   const repoRootChanges = [];
@@ -1255,22 +2477,40 @@ function buildGroupedChangeTreeNodes(sessions, changes) {
     changesBySession.get(session.branch).push(localizedChange);
   }
 
-  const items = groupSessionsByWorktree(
-    sessions.filter((session) => (changesBySession.get(session.branch) || []).length > 0),
-  ).map(({ worktreePath, sessions: worktreeSessions }) => {
-    const sessionItems = worktreeSessions.map((session) => (
-      new SessionItem(
-        session,
-        buildChangeTreeNodes(changesBySession.get(session.branch) || []),
-        { label: sessionTreeLabel(session) },
-      )
-    ));
-    const changedCount = worktreeSessions.reduce(
-      (total, session) => total + ((changesBySession.get(session.branch) || []).length),
-      0,
-    );
-    return new WorktreeItem(worktreePath, worktreeSessions, sessionItems, { changedCount });
-  });
+  return {
+    changesBySession,
+    repoRootChanges,
+  };
+}
+
+function buildGroupedChangeTreeNodes(sessions, changes) {
+  const { changesBySession, repoRootChanges } = partitionChangesByOwnership(sessions, changes);
+
+  const items = buildProjectScopedItems(
+    groupSessionsByWorktree(
+      sessions.filter((session) => (changesBySession.get(session.branch) || []).length > 0),
+    ).map(({ worktreePath, sessions: worktreeSessions }) => {
+      const sessionItems = worktreeSessions.map((session) => (
+        new SessionItem(
+          session,
+          buildChangeTreeNodes(changesBySession.get(session.branch) || []),
+          {
+            label: sessionTreeLabel(session),
+            variant: 'raw',
+          },
+        )
+      ));
+      const changedCount = worktreeSessions.reduce(
+        (total, session) => total + ((changesBySession.get(session.branch) || []).length),
+        0,
+      );
+      return {
+        projectRelativePath: worktreeProjectRelativePath(worktreeSessions),
+        sessions: worktreeSessions,
+        item: new WorktreeItem(worktreePath, worktreeSessions, sessionItems, { changedCount }),
+      };
+    }),
+  );
 
   if (repoRootChanges.length > 0) {
     items.push(new SectionItem('Repo root', buildChangeTreeNodes(repoRootChanges), {
@@ -1395,23 +2635,127 @@ function commitWorktree(worktreePath, message) {
   runGitCommand(worktreePath, ['commit', '-m', message]);
 }
 
-function buildActiveAgentGroupNodes(sessions) {
+function buildSessionDetailItems(session) {
+  const provider = resolveSessionProvider(session);
+  const snapshot = sessionSnapshotDisplayName(session);
+  const projectRelativePath = resolveSessionProjectRelativePath(session);
+  const badgeSummary = uniqueStringList([
+    ...(session.riskBadges || []),
+    session.deltaLabel || '',
+  ].filter(Boolean)).join(', ');
+  const sessionHealthSummary = buildSessionHealthSummary(session);
+  const items = [
+    new DetailItem('Recent change', session.recentChangeSummary || 'No recent change summary.', {
+      iconId: 'history',
+    }),
+    new DetailItem('Top files', session.topChangedFilesLabel || 'No tracked file edits.', {
+      iconId: 'list-flat',
+    }),
+  ];
+  if (badgeSummary) {
+    items.push(new DetailItem('Signals', badgeSummary, {
+      iconId: 'warning',
+    }));
+  }
+  if (sessionHealthSummary) {
+    items.push(new DetailItem('Session health', sessionHealthSummary, {
+      iconId: 'pulse',
+      tooltip: buildSessionHealthTooltip(session) || sessionHealthSummary,
+    }));
+  }
+  if (provider?.label) {
+    items.push(new DetailItem('Provider', provider.label, {
+      iconId: 'sparkle',
+    }));
+  }
+  if (snapshot) {
+    items.push(new DetailItem('Snapshot', snapshot, {
+      iconId: 'account',
+    }));
+  }
+  if (projectRelativePath) {
+    items.push(new DetailItem('Project', projectRelativePath, {
+      iconId: 'folder',
+      tooltip: projectRelativePath,
+    }));
+  }
+  items.push(new DetailItem('Branch', session.branch, {
+    iconId: 'git-branch',
+  }));
+  items.push(new DetailItem('Worktree', session.worktreePath, {
+    iconId: 'folder',
+    tooltip: session.worktreePath,
+  }));
+  return items;
+}
+
+function buildWorkingNowNodes(sessions) {
+  const sessionEntries = sortSessionsForWorkingNow(
+    sessions.filter((session) => (
+      session.activityKind === 'working' || session.activityKind === 'blocked'
+    )),
+  ).map((session) => ({
+    projectRelativePath: resolveSessionProjectRelativePath(session),
+    sessions: [session],
+    item: new SessionItem(session, buildSessionDetailItems(session)),
+  }));
+  return buildProjectScopedItems(sessionEntries, { rootLabel: 'Repo root' });
+}
+
+function buildIdleThinkingNodes(sessions) {
+  const sessionEntries = sortSessionsForIdleThinking(
+    sessions.filter((session) => !(
+      session.activityKind === 'working' || session.activityKind === 'blocked'
+    )),
+  ).map((session) => ({
+    projectRelativePath: resolveSessionProjectRelativePath(session),
+    sessions: [session],
+    item: new SessionItem(session, buildSessionDetailItems(session)),
+  }));
+  return buildProjectScopedItems(sessionEntries, { rootLabel: 'Repo root' });
+}
+
+function buildUnassignedChangeNodes(changes) {
+  return sortUnassignedChanges(changes).map((change) => new ChangeItem(change, {
+    label: compactRelativePath(change.relativePath),
+    description: buildUnassignedChangeDescription(change),
+    iconId: changeRiskBadges(change).length > 0 ? 'warning' : undefined,
+  }));
+}
+
+function buildRawActiveAgentGroupNodes(sessions) {
   const groups = [];
   for (const group of SESSION_ACTIVITY_GROUPS) {
     const groupSessions = sessions.filter((session) => session.activityKind === group.kind);
-    const worktreeItems = groupSessionsByWorktree(groupSessions).map(({ worktreePath, sessions: worktreeSessions }) => (
-      new WorktreeItem(
-        worktreePath,
-        worktreeSessions,
-        worktreeSessions.map((session) => new SessionItem(
-          session,
-          buildChangeTreeNodes(session.touchedChanges || []),
-          { label: sessionTreeLabel(session) },
-        )),
-      )
-    ));
+    const worktreeItems = buildProjectScopedItems(
+      groupSessionsByWorktree(groupSessions).map(({ worktreePath, sessions: worktreeSessions }) => ({
+        projectRelativePath: worktreeProjectRelativePath(worktreeSessions),
+        sessions: worktreeSessions,
+        item: new WorktreeItem(
+          worktreePath,
+          worktreeSessions,
+          worktreeSessions.map((session) => new SessionItem(
+            session,
+            buildChangeTreeNodes(session.touchedChanges || []),
+            {
+              label: sessionTreeLabel(session),
+              variant: 'raw',
+            },
+          )),
+          {
+            description: buildWorktreeBranchDescription(worktreeSessions),
+            iconId: 'git-branch',
+            resourceSession: worktreeSessions[0],
+            useSessionDecoration: true,
+          },
+        ),
+      })),
+      { rootLabel: 'Repo root' },
+    );
     if (worktreeItems.length > 0) {
-      groups.push(new SectionItem(group.label, worktreeItems));
+      groups.push(new SectionItem(group.label, worktreeItems, {
+        iconId: resolveSessionActivityIconId(group.kind),
+      }));
     }
   }
 
@@ -1431,9 +2775,13 @@ class ActiveAgentsProvider {
     this.viewSummary = {
       sessionCount: 0,
       workingCount: 0,
+      idleCount: 0,
+      unassignedChangeCount: 0,
+      lockedFileCount: 0,
       deadCount: 0,
       conflictCount: 0,
     };
+    this.previousSnapshot = null;
   }
 
   getTreeItem(element) {
@@ -1442,7 +2790,15 @@ class ActiveAgentsProvider {
 
   attachTreeView(treeView) {
     this.treeView = treeView;
-    this.updateViewState(0, 0, 0);
+    this.updateViewState({
+      sessionCount: 0,
+      workingCount: 0,
+      idleCount: 0,
+      unassignedChangeCount: 0,
+      lockedFileCount: 0,
+      deadCount: 0,
+      conflictCount: 0,
+    });
     treeView.onDidChangeSelection?.((event) => {
       const sessionItem = event.selection.find((item) => item instanceof SessionItem);
       this.setSelectedSession(sessionItem?.session || null);
@@ -1479,60 +2835,100 @@ class ActiveAgentsProvider {
     this.setSelectedSession(nextSession || null);
   }
 
-  updateViewState(sessionCount, workingCount, deadCount, conflictCount = 0) {
+  updateViewState(summary) {
     if (!this.treeView) {
       return;
     }
 
-    const activeCount = Math.max(0, sessionCount - deadCount);
-    this.viewSummary = {
-      sessionCount,
-      workingCount,
-      deadCount,
-      conflictCount,
-    };
+    const sessionCount = summary?.sessionCount || 0;
+    const conflictCount = summary?.conflictCount || 0;
+    this.viewSummary = { ...summary };
     void vscode.commands.executeCommand('setContext', 'guardex.hasAgents', sessionCount > 0);
     void vscode.commands.executeCommand('setContext', 'guardex.hasConflicts', conflictCount > 0);
-    const badgeTooltipParts = [];
-    if (activeCount > 0) {
-      badgeTooltipParts.push(`${activeCount} active agent${activeCount === 1 ? '' : 's'}`);
-    }
-    if (deadCount > 0) {
-      badgeTooltipParts.push(`${deadCount} dead`);
-    }
-    if (workingCount > 0) {
-      badgeTooltipParts.push(`${workingCount} working now`);
-    }
-    if (conflictCount > 0) {
-      badgeTooltipParts.push(`${conflictCount} conflict${conflictCount === 1 ? '' : 's'}`);
-    }
 
     this.treeView.badge = sessionCount > 0
       ? {
           value: sessionCount,
-          tooltip: badgeTooltipParts.join(' · '),
+          tooltip: buildOverviewDescription(summary),
         }
       : undefined;
     this.treeView.message = undefined;
   }
 
+  annotateRepoEntries(repoEntries) {
+    const hasPreviousSnapshot = Boolean(this.previousSnapshot);
+    const nextSnapshot = {
+      sessions: new Map(),
+      changes: new Map(),
+    };
+
+    const annotatedEntries = repoEntries.map((entry) => {
+      const sessions = entry.sessions.map((session) => {
+        const snapshotKey = sessionSnapshotKey(session);
+        nextSnapshot.sessions.set(snapshotKey, buildSessionSnapshot(session));
+        const deltaLabel = hasPreviousSnapshot
+          ? deriveSessionDelta(this.previousSnapshot.sessions.get(snapshotKey), session)
+          : '';
+        return {
+          ...session,
+          deltaLabel,
+          riskBadges: uniqueStringList([
+            ...(session.riskBadges || []),
+            deltaLabel,
+          ].filter(Boolean)),
+        };
+      });
+
+      const changes = entry.changes.map((change) => {
+        const snapshotKey = changeSnapshotKey(entry.repoRoot, change);
+        nextSnapshot.changes.set(snapshotKey, buildChangeSnapshot(change));
+        const deltaLabel = hasPreviousSnapshot
+          ? deriveChangeDelta(this.previousSnapshot.changes.get(snapshotKey), change)
+          : '';
+        return {
+          ...change,
+          deltaLabel,
+          riskBadges: changeRiskBadges({
+            ...change,
+            deltaLabel,
+          }),
+        };
+      });
+
+      const { repoRootChanges } = partitionChangesByOwnership(sessions, changes);
+      const unassignedChanges = sortUnassignedChanges(repoRootChanges);
+      return {
+        ...entry,
+        sessions,
+        changes,
+        unassignedChanges,
+        overview: buildRepoOverview(sessions, unassignedChanges, entry.lockEntries),
+      };
+    });
+
+    this.previousSnapshot = nextSnapshot;
+    return annotatedEntries;
+  }
+
   async syncRepoEntries() {
-    const repoEntries = await this.loadRepoEntries();
-    const sessionCount = repoEntries.reduce((total, entry) => total + entry.sessions.length, 0);
-    const workingCount = repoEntries.reduce(
-      (total, entry) => total + countWorkingSessions(entry.sessions),
-      0,
-    );
-    const deadCount = repoEntries.reduce(
-      (total, entry) => total + countSessionsByActivityKind(entry.sessions, 'dead'),
-      0,
-    );
-    const conflictCount = repoEntries.reduce(
-      (total, entry) => total + countEntryConflicts(entry),
-      0,
-    );
+    const repoEntries = this.annotateRepoEntries(await this.loadRepoEntries());
+    const summary = {
+      sessionCount: repoEntries.reduce((total, entry) => total + entry.sessions.length, 0),
+      workingCount: repoEntries.reduce((total, entry) => total + entry.overview.workingCount, 0),
+      idleCount: repoEntries.reduce((total, entry) => total + entry.overview.idleCount, 0),
+      unassignedChangeCount: repoEntries.reduce(
+        (total, entry) => total + entry.overview.unassignedChangeCount,
+        0,
+      ),
+      lockedFileCount: repoEntries.reduce((total, entry) => total + entry.overview.lockedFileCount, 0),
+      deadCount: repoEntries.reduce(
+        (total, entry) => total + countSessionsByActivityKind(entry.sessions, 'dead'),
+        0,
+      ),
+      conflictCount: repoEntries.reduce((total, entry) => total + entry.overview.conflictCount, 0),
+    };
 
-    this.updateViewState(sessionCount, workingCount, deadCount, conflictCount);
+    this.updateViewState(summary);
     this.decorationProvider?.updateSessions(repoEntries.flatMap((entry) => entry.sessions));
     this.decorationProvider?.updateLockEntries(repoEntries);
     return repoEntries;
@@ -1561,13 +2957,62 @@ class ActiveAgentsProvider {
   async getChildren(element) {
     if (element instanceof RepoItem) {
       const sectionItems = [
-        new SectionItem('ACTIVE AGENTS', buildActiveAgentGroupNodes(element.sessions), {
-          description: String(element.sessions.length),
+        new SectionItem('Overview', [
+          new DetailItem('Summary', buildOverviewDescription(element.overview), {
+            iconId: 'graph',
+            tooltip: buildRepoTooltip(element.repoRoot, element.overview),
+          }),
+        ], {
+          description: '1',
         }),
       ];
-      if (element.changes.length > 0) {
-        sectionItems.push(new SectionItem('CHANGES', buildGroupedChangeTreeNodes(element.sessions, element.changes), {
+
+      const workingNowItems = buildWorkingNowNodes(element.sessions);
+      if (workingNowItems.length > 0) {
+        sectionItems.push(new SectionItem('Working now', workingNowItems, {
+          description: String(workingNowItems.length),
+          iconId: 'loading~spin',
+        }));
+      }
+
+      const idleThinkingItems = buildIdleThinkingNodes(element.sessions);
+      if (idleThinkingItems.length > 0) {
+        sectionItems.push(new SectionItem('Idle / thinking', idleThinkingItems, {
+          description: String(idleThinkingItems.length),
+          collapsedState: vscode.TreeItemCollapsibleState.Collapsed,
+          iconId: 'comment-discussion',
+        }));
+      }
+
+      if (element.unassignedChanges.length > 0) {
+        sectionItems.push(new SectionItem('Unassigned changes', buildUnassignedChangeNodes(element.unassignedChanges), {
+          description: String(element.unassignedChanges.length),
+          iconId: 'warning',
+        }));
+      }
+
+      const advancedItems = [];
+      const rawActiveAgents = buildRawActiveAgentGroupNodes(element.sessions);
+      if (rawActiveAgents.length > 0) {
+        advancedItems.push(new SectionItem('Active agent tree', rawActiveAgents, {
+          description: String(element.sessions.length),
+          collapsedState: vscode.TreeItemCollapsibleState.Collapsed,
+          iconId: 'git-branch',
+        }));
+      }
+      const rawChangeTree = buildGroupedChangeTreeNodes(element.sessions, element.changes);
+      if (rawChangeTree.length > 0) {
+        advancedItems.push(new SectionItem('Raw path tree', rawChangeTree, {
           description: String(element.changes.length),
+          collapsedState: vscode.TreeItemCollapsibleState.Collapsed,
+          iconId: 'list-tree',
+        }));
+      }
+      if (advancedItems.length > 0) {
+        sectionItems.push(new SectionItem('Advanced details', advancedItems, {
+          description: String(advancedItems.length),
+          collapsedState: vscode.TreeItemCollapsibleState.Collapsed,
+          iconId: 'list-tree',
         }));
       }
       return sectionItems;
@@ -1584,7 +3029,12 @@ class ActiveAgentsProvider {
       return [new InfoItem('No active Guardex agents', 'Open or start a sandbox session.')];
     }
 
-    return repoEntries.map((entry) => new RepoItem(entry.repoRoot, entry.sessions, entry.changes));
+    return repoEntries.map((entry) => new RepoItem(entry.repoRoot, entry.sessions, entry.changes, {
+      label: repoEntryDisplayLabel(entry.repoRoot, entry.sessions),
+      overview: entry.overview,
+      unassignedChanges: entry.unassignedChanges,
+      lockEntries: entry.lockEntries,
+    }));
   }
 
   async loadRepoEntries() {
@@ -1777,10 +3227,15 @@ function activate(context) {
   activeAgentsStatusItem.command = 'gitguardex.activeAgents.focus';
   provider.attachTreeView(treeView);
   const scheduleRefresh = () => refreshController.scheduleRefresh();
+  const handleWorkspaceFoldersChanged = () => {
+    scheduleRefresh();
+    void ensureManagedRepoScanIgnores();
+  };
   const refresh = () => void refreshController.refreshNow();
   const activeSessionsWatcher = vscode.workspace.createFileSystemWatcher(ACTIVE_SESSION_FILES_GLOB);
   const lockWatcher = vscode.workspace.createFileSystemWatcher(AGENT_FILE_LOCKS_GLOB);
   const worktreeLockWatcher = vscode.workspace.createFileSystemWatcher(WORKTREE_AGENT_LOCKS_GLOB);
+  const managedWorktreeGitWatcher = vscode.workspace.createFileSystemWatcher(MANAGED_WORKTREE_GIT_FILES_GLOB);
   const logWatcher = vscode.workspace.createFileSystemWatcher(AGENT_LOG_FILES_GLOB);
   const updateCommitInput = (session) => {
     sourceControl.inputBox.enabled = true;
@@ -1868,8 +3323,9 @@ function activate(context) {
     vscode.window.registerFileDecorationProvider(decorationProvider),
     vscode.commands.registerCommand('gitguardex.activeAgents.startAgent', () => startAgentFromPrompt(refresh)),
     vscode.commands.registerCommand('gitguardex.activeAgents.refresh', refresh),
+    vscode.commands.registerCommand('gitguardex.activeAgents.restart', restartActiveAgents),
     vscode.commands.registerCommand('gitguardex.activeAgents.focus', async () => {
-      await vscode.commands.executeCommand('workbench.view.scm');
+      await vscode.commands.executeCommand('workbench.view.extension.gitguardex.activeAgentsContainer');
     }),
     vscode.commands.registerCommand('gitguardex.activeAgents.commitSelectedSession', commitSelectedSession),
     vscode.commands.registerCommand('gitguardex.activeAgents.openWorktree', async (session) => {
@@ -1898,14 +3354,15 @@ function activate(context) {
     vscode.commands.registerCommand('gitguardex.activeAgents.inspect', (session) => {
       inspectPanelManager.open(session || provider.getSelectedSession());
     }),
+    vscode.commands.registerCommand('gitguardex.activeAgents.showSessionTerminal', showSessionTerminal),
     vscode.commands.registerCommand('gitguardex.activeAgents.finishSession', finishSession),
     vscode.commands.registerCommand('gitguardex.activeAgents.syncSession', syncSession),
     vscode.commands.registerCommand('gitguardex.activeAgents.stopSession', (session) => stopSession(session, refresh)),
-    vscode.commands.registerCommand('gitguardex.activeAgents.openSessionDiff', openSessionDiff),
-    vscode.workspace.onDidChangeWorkspaceFolders(scheduleRefresh),
+    vscode.workspace.onDidChangeWorkspaceFolders(handleWorkspaceFoldersChanged),
     activeSessionsWatcher,
     lockWatcher,
     worktreeLockWatcher,
+    managedWorktreeGitWatcher,
     logWatcher,
     { dispose: () => clearInterval(interval) },
   );
@@ -1914,8 +3371,10 @@ function activate(context) {
     ...bindRefreshWatcher(activeSessionsWatcher, scheduleRefresh),
     ...bindRefreshWatcher(lockWatcher, refreshLockRegistry),
     ...bindRefreshWatcher(worktreeLockWatcher, scheduleRefresh),
+    ...bindRefreshWatcher(managedWorktreeGitWatcher, scheduleRefresh),
     ...bindRefreshWatcher(logWatcher, scheduleRefresh),
   );
+  void ensureManagedRepoScanIgnores();
   void refreshController.refreshNow();
   void maybeAutoUpdateActiveAgentsExtension(context);
 }