@imdeadpool/guardex 7.0.20 → 7.0.22

package/templates/scripts/agent-branch-finish.sh

@@ -218,18 +218,48 @@ fi
 
 get_worktree_for_branch() {
   local branch="$1"
-  git -C "$repo_root" worktree list --porcelain | awk -v target="refs/heads/${branch}" '
+  git -C "$repo_root" worktree list --porcelain | awk -v target="refs/heads/${branch}" -v probe_prefix="${agent_worktree_root}/__source-probe-" '
     $1 == "worktree" { wt = $2 }
-    $1 == "branch" && $2 == target { print wt; exit }
+    $1 == "branch" && $2 == target {
+      if (index(wt, probe_prefix) != 1) {
+        print wt
+        exit
+      }
+    }
   '
 }
 
+remove_stale_source_probe_worktrees() {
+  local branch="$1"
+  local stale_probe=""
+
+  while IFS= read -r stale_probe; do
+    [[ -z "$stale_probe" ]] && continue
+    [[ "$stale_probe" == "$current_worktree" ]] && continue
+
+    echo "[agent-branch-finish] Removing stale source-probe worktree for '${branch}': ${stale_probe}" >&2
+    git -C "$stale_probe" rebase --abort >/dev/null 2>&1 || true
+    git -C "$stale_probe" merge --abort >/dev/null 2>&1 || true
+    git -C "$repo_root" worktree remove "$stale_probe" --force >/dev/null 2>&1 || true
+  done < <(
+    git -C "$repo_root" worktree list --porcelain | awk -v target="refs/heads/${branch}" -v probe_prefix="${agent_worktree_root}/__source-probe-" '
+      $1 == "worktree" { wt = $2 }
+      $1 == "branch" && $2 == target {
+        if (index(wt, probe_prefix) == 1) {
+          print wt
+        }
+      }
+    '
+  )
+}
+
 is_clean_worktree() {
   local wt="$1"
   git -C "$wt" diff --quiet -- . ":(exclude).omx/state/agent-file-locks.json" \
     && git -C "$wt" diff --cached --quiet -- . ":(exclude).omx/state/agent-file-locks.json"
 }
 
+remove_stale_source_probe_worktrees "$SOURCE_BRANCH"
 source_worktree="$(get_worktree_for_branch "$SOURCE_BRANCH")"
 created_source_probe=0
 source_probe_path=""
@@ -295,8 +325,13 @@ if [[ "$should_require_sync" -eq 1 ]] && git -C "$repo_root" show-ref --verify -
 
       echo "[agent-sync-guard] Auto-sync failed while rebasing '${SOURCE_BRANCH}' onto origin/${BASE_BRANCH}." >&2
       if [[ "$rebase_active" -eq 1 ]]; then
-        echo "[agent-sync-guard] Resolve conflicts, then run: git -C \"$source_worktree\" rebase --continue" >&2
-        echo "[agent-sync-guard] Or abort: git -C \"$source_worktree\" rebase --abort" >&2
+        if [[ "$created_source_probe" -eq 1 ]]; then
+          echo "[agent-sync-guard] Temporary source-probe worktree will be cleaned up on exit." >&2
+          echo "[agent-sync-guard] Reattach '${SOURCE_BRANCH}' in a regular worktree, then rebase it onto origin/${BASE_BRANCH} manually." >&2
+        else
+          echo "[agent-sync-guard] Resolve conflicts, then run: git -C \"$source_worktree\" rebase --continue" >&2
+          echo "[agent-sync-guard] Or abort: git -C \"$source_worktree\" rebase --abort" >&2
+        fi
       fi
       exit 1
     fi
@@ -366,6 +401,14 @@ is_local_branch_delete_error() {
   return 1
 }
 
+is_remote_branch_missing_error() {
+  local output="$1"
+  if [[ "$output" == *"remote ref does not exist"* ]] || [[ "$output" == *"failed to push some refs"* ]]; then
+    return 0
+  fi
+  return 1
+}
+
 read_pr_state() {
   local state_line
   state_line="$("$GH_BIN" pr view "$SOURCE_BRANCH" --json state,mergedAt,url --jq '[.state, (.mergedAt // ""), (.url // "")] | join("\u001f")' 2>/dev/null || true)"
@@ -568,7 +611,15 @@ if [[ "$CLEANUP_AFTER_MERGE" -eq 1 ]]; then
 
   if [[ "$PUSH_ENABLED" -eq 1 && "$DELETE_REMOTE_BRANCH" -eq 1 ]]; then
     if git -C "$repo_root" ls-remote --exit-code --heads origin "$SOURCE_BRANCH" >/dev/null 2>&1; then
-      git -C "$repo_root" push origin --delete "$SOURCE_BRANCH"
+      remote_delete_output=""
+      if ! remote_delete_output="$(git -C "$repo_root" push origin --delete "$SOURCE_BRANCH" 2>&1)"; then
+        if is_remote_branch_missing_error "$remote_delete_output"; then
+          echo "[agent-branch-finish] Remote branch '${SOURCE_BRANCH}' was already deleted; continuing cleanup." >&2
+        else
+          echo "$remote_delete_output" >&2
+          exit 1
+        fi
+      fi
     fi
   fi
 

package/templates/scripts/agent-worktree-prune.sh

@@ -111,6 +111,13 @@ is_managed_worktree_path() {
   return 1
 }
 
+is_temporary_worktree_path() {
+  local entry="$1"
+  local name
+  name="$(basename "$entry")"
+  [[ "$name" == __agent_integrate-* || "$name" == __source-probe-* ]]
+}
+
 resolve_base_branch() {
   local configured=""
   local current=""
@@ -425,7 +432,9 @@ process_entry() {
   local remove_reason=""
   local branch_delete_mode="safe"
 
-  if [[ -z "$branch_ref" ]]; then
+  if is_temporary_worktree_path "$wt"; then
+    remove_reason="temporary-worktree"
+  elif [[ -z "$branch_ref" ]]; then
     remove_reason="detached-worktree"
   elif ! git -C "$repo_root" show-ref --verify --quiet "refs/heads/${branch}"; then
     remove_reason="missing-branch"
@@ -452,6 +461,11 @@ process_entry() {
     return
   fi
 
+  if [[ "$remove_reason" == "temporary-worktree" ]]; then
+    git -C "$wt" rebase --abort >/dev/null 2>&1 || true
+    git -C "$wt" merge --abort >/dev/null 2>&1 || true
+  fi
+
   if [[ "$FORCE_DIRTY" -ne 1 ]] && ! is_clean_worktree "$wt"; then
     skipped_dirty=$((skipped_dirty + 1))
     echo "[agent-worktree-prune] Skipping dirty worktree (${remove_reason}): ${wt}"

package/templates/scripts/codex-agent.sh

@@ -90,6 +90,13 @@ string_has_lightweight_prefix() {
   return 1
 }
 
+task_requires_full_change_workspace() {
+  local text="$1"
+  string_contains_any "$text" \
+    "cleanup evidence" "merged cleanup" "merged state" "pr url" \
+    "cleanup pipeline" "finish pipeline" "sandbox cleanup" "tasks.md"
+}
+
 derive_task_mode_from_tier() {
   case "$1" in
     T0|T1) printf 'caveman' ;;
@@ -128,8 +135,13 @@ decide_task_routing() {
     fi
     TASK_ROUTING_REASON="explicit tier override"
   elif string_has_lightweight_prefix "$task_lower"; then
-    OPENSPEC_TIER="T1"
-    TASK_ROUTING_REASON="explicit lightweight prefix"
+    if task_requires_full_change_workspace "$task_lower"; then
+      OPENSPEC_TIER="T2"
+      TASK_ROUTING_REASON="cleanup-evidence artifact wording overrides lightweight prefix"
+    else
+      OPENSPEC_TIER="T1"
+      TASK_ROUTING_REASON="explicit lightweight prefix"
+    fi
   elif string_contains_any "$task_lower" \
     "ralph" "autopilot" "ultrawork" "ultraqa" "ralplan" "deep interview" "ouroboros" \
     "migration" "refactor" "architecture" "re-architect" "cross-cutting" "multi-agent" \

package/templates/vscode/guardex-active-agents/README.md

@@ -17,11 +17,13 @@ node scripts/install-vscode-active-agents-extension.js
 
 What it does:
 
+- Bundles a local GitGuardex icon so repo installs show branded extension metadata inside VS Code.
 - Adds an `Active Agents` view to the Source Control container.
 - Renders one repo node per live Guardex workspace with grouped `ACTIVE AGENTS` and `CHANGES` sections.
 - Splits live sessions inside `ACTIVE AGENTS` into `BLOCKED`, `WORKING NOW`, `IDLE`, `STALLED`, and `DEAD` groups so stuck, active, and inactive lanes stand out immediately.
+- Mirrors the same live state in the VS Code status bar so the selected session or active-agent count stays visible outside the tree.
 - Shows one row per live Guardex sandbox session inside those activity groups.
 - Shows repo-root git changes in a sibling `CHANGES` section when the guarded repo itself is dirty.
 - Derives session state from dirty worktree status, git conflict markers, PID liveness, and recent file mtimes, surfaces working/dead counts in the repo/header summary, and shows changed-file counts for active edits.
 - Uses distinct VS Code codicons for each session state: `warning`, `edit`, `loading~spin`, `clock`, and `error`.
-- Reads repo-local presence files from `.omx/state/active-sessions/`.
+- Reads repo-local presence files from `.omx/state/active-sessions/` and falls back to managed worktree-root `AGENT.lock` telemetry when the launcher session file is absent.

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

@@ -15,9 +15,15 @@ const IDLE_ERROR_MS = 30 * 60 * 1000;
 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 SESSION_SCAN_EXCLUDE_GLOB = '**/{node_modules,.git,.omx/agent-worktrees,.omc/agent-worktrees}/**';
+const WORKTREE_LOCK_SCAN_EXCLUDE_GLOB = '**/{node_modules,.git}/**';
 const SESSION_SCAN_LIMIT = 200;
 const REFRESH_DEBOUNCE_MS = 250;
+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 SESSION_ACTIVITY_GROUPS = [
   { kind: 'blocked', label: 'BLOCKED' },
   { kind: 'working', label: 'WORKING NOW' },
@@ -91,10 +97,83 @@ function sessionIdleDecoration(session, now = Date.now()) {
   return undefined;
 }
 
+function formatCountLabel(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function sessionIdentityLabel(session) {
+  const agentName = typeof session?.agentName === 'string' ? session.agentName.trim() : '';
+  const taskName = typeof session?.taskName === 'string' ? session.taskName.trim() : '';
+  const label = typeof session?.label === 'string' ? session.label.trim() : '';
+
+  if (agentName && taskName) {
+    return `${agentName} · ${taskName}`;
+  }
+  if (agentName && label) {
+    return `${agentName} · ${label}`;
+  }
+
+  return agentName || taskName || label || 'session';
+}
+
+function sessionCommitPlaceholder(session) {
+  if (!session?.branch) {
+    return 'Pick an Active Agents session to commit its worktree.';
+  }
+
+  return `Commit ${sessionIdentityLabel(session)} on ${session.branch} · ${formatCountLabel(session.lockCount || 0, 'lock')} (Ctrl+Enter)`;
+}
+
+function agentNameFromBranch(branch) {
+  const segments = String(branch || '')
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+  if (segments[0] === 'agent' && segments[1]) {
+    return segments[1];
+  }
+  return segments[0] || 'lock';
+}
+
+function agentBadgeFromBranch(branch) {
+  const normalized = agentNameFromBranch(branch).toUpperCase().replace(/[^A-Z0-9]/g, '');
+  return normalized.slice(0, 2) || 'LK';
+}
+
+function buildActiveAgentsStatusSummary(summary) {
+  const activeCount = Math.max(0, (summary?.sessionCount || 0) - (summary?.deadCount || 0));
+  if (activeCount > 0) {
+    return `$(git-branch) ${formatCountLabel(activeCount, 'active agent')}`;
+  }
+  return `$(git-branch) ${formatCountLabel(summary?.sessionCount || 0, 'tracked session')}`;
+}
+
+function buildActiveAgentsStatusTooltip(selectedSession, summary) {
+  if (selectedSession?.branch) {
+    return [
+      selectedSession.branch,
+      sessionIdentityLabel(selectedSession),
+      formatCountLabel(selectedSession.lockCount || 0, 'lock'),
+      selectedSession.worktreePath,
+      'Click to open Source Control.',
+    ].filter(Boolean).join('\n');
+  }
+
+  const activeCount = Math.max(0, (summary?.sessionCount || 0) - (summary?.deadCount || 0));
+  return [
+    formatCountLabel(activeCount, 'active agent'),
+    formatCountLabel(summary?.workingCount || 0, 'working now session', 'working now sessions'),
+    summary?.deadCount ? formatCountLabel(summary.deadCount, 'dead session') : '',
+    'Click to open Source Control.',
+  ].filter(Boolean).join('\n');
+}
+
 class SessionDecorationProvider {
   constructor(nowProvider = () => Date.now()) {
     this.nowProvider = nowProvider;
     this.sessionsByUri = new Map();
+    this.lockEntriesByFileUri = new Map();
+    this.selectedBranch = '';
     this.onDidChangeFileDecorationsEmitter = new vscode.EventEmitter();
     this.onDidChangeFileDecorations = this.onDidChangeFileDecorationsEmitter.event;
   }
@@ -105,13 +184,54 @@ class SessionDecorationProvider {
     );
   }
 
+  updateLockEntries(repoEntries) {
+    const nextEntriesByUri = new Map();
+    for (const entry of repoEntries || []) {
+      for (const [relativePath, lockEntry] of entry.lockEntries || []) {
+        nextEntriesByUri.set(
+          vscode.Uri.file(path.join(entry.repoRoot, relativePath)).toString(),
+          { branch: lockEntry.branch },
+        );
+      }
+    }
+    this.lockEntriesByFileUri = nextEntriesByUri;
+  }
+
+  setSelectedBranch(branch) {
+    this.selectedBranch = typeof branch === 'string' ? branch.trim() : '';
+  }
+
   refresh() {
     this.onDidChangeFileDecorationsEmitter.fire();
   }
 
   provideFileDecoration(uri) {
     if (!uri || uri.scheme !== SESSION_DECORATION_SCHEME) {
-      return undefined;
+      if (!uri || uri.scheme !== 'file') {
+        return undefined;
+      }
+
+      const lockEntry = this.lockEntriesByFileUri.get(uri.toString());
+      if (!lockEntry?.branch) {
+        return undefined;
+      }
+
+      const ownsSelectedSession = Boolean(this.selectedBranch) && lockEntry.branch === this.selectedBranch;
+      return {
+        badge: agentBadgeFromBranch(lockEntry.branch),
+        tooltip: ownsSelectedSession
+          ? `Locked by selected session ${lockEntry.branch}`
+          : this.selectedBranch
+            ? `Locked by ${lockEntry.branch} (selected session: ${this.selectedBranch})`
+            : `Locked by ${lockEntry.branch}`,
+        color: new vscode.ThemeColor(
+          ownsSelectedSession
+            ? 'gitDecoration.modifiedResourceForeground'
+            : this.selectedBranch
+              ? 'list.errorForeground'
+              : 'list.warningForeground',
+        ),
+      };
     }
 
     return sessionIdleDecoration(this.sessionsByUri.get(uri.toString()), this.nowProvider());
@@ -187,14 +307,23 @@ class SessionItem extends vscode.TreeItem {
     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.pidAlive === false ? `PID ${session.pid} not alive` : `PID ${session.pid} alive`,
+      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}` : '',
-      `Started ${session.startedAt}`,
+      session.sourceKind === 'worktree-lock'
+        ? `Telemetry updated ${session.telemetryUpdatedAt || session.startedAt}`
+        : `Started ${session.startedAt}`,
       session.worktreePath,
     ];
     this.tooltip = tooltipLines.filter(Boolean).join('\n');
@@ -365,6 +494,10 @@ function repoRootFromSessionFile(filePath) {
   return path.resolve(path.dirname(filePath), '..', '..', '..');
 }
 
+function repoRootFromWorktreeLockFile(filePath) {
+  return path.resolve(path.dirname(filePath), '..', '..', '..');
+}
+
 function repoRootFromLockFile(filePath) {
   return path.resolve(path.dirname(filePath), '..', '..');
 }
@@ -436,6 +569,120 @@ function readCurrentBranch(repoRoot) {
   }
 }
 
+function parseSimpleSemver(version) {
+  const parts = String(version || '')
+    .split('.')
+    .map((part) => Number.parseInt(part, 10));
+  if (parts.length !== 3 || parts.some((part) => Number.isNaN(part))) {
+    return null;
+  }
+  return parts;
+}
+
+function compareSimpleSemver(left, right) {
+  const leftParts = parseSimpleSemver(left);
+  const rightParts = parseSimpleSemver(right);
+  if (!leftParts || !rightParts) {
+    return 0;
+  }
+
+  for (let index = 0; index < leftParts.length; index += 1) {
+    if (leftParts[index] !== rightParts[index]) {
+      return leftParts[index] - rightParts[index];
+    }
+  }
+
+  return 0;
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function resolveActiveAgentsAutoUpdateCandidate(installedVersion) {
+  const candidates = [];
+
+  for (const workspaceFolder of vscode.workspace.workspaceFolders || []) {
+    const repoRoot = workspaceFolder?.uri?.fsPath;
+    if (!repoRoot) {
+      continue;
+    }
+
+    const manifestPath = path.join(repoRoot, ACTIVE_AGENTS_MANIFEST_RELATIVE);
+    const installScriptPath = path.join(repoRoot, ACTIVE_AGENTS_INSTALL_SCRIPT_RELATIVE);
+    if (!fs.existsSync(manifestPath) || !fs.existsSync(installScriptPath)) {
+      continue;
+    }
+
+    const manifest = readJsonFile(manifestPath);
+    const nextVersion = typeof manifest?.version === 'string' ? manifest.version.trim() : '';
+    if (!nextVersion || compareSimpleSemver(nextVersion, installedVersion) <= 0) {
+      continue;
+    }
+
+    candidates.push({ repoRoot, installScriptPath, version: nextVersion });
+  }
+
+  candidates.sort((left, right) => compareSimpleSemver(right.version, left.version));
+  return candidates[0] || null;
+}
+
+function runActiveAgentsInstallScript(repoRoot, installScriptPath) {
+  return new Promise((resolve, reject) => {
+    cp.execFile(
+      process.execPath,
+      [installScriptPath],
+      { cwd: repoRoot, encoding: 'utf8' },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(String(stderr || stdout || error.message || '').trim() || 'install failed'));
+          return;
+        }
+        resolve({ stdout, stderr });
+      },
+    );
+  });
+}
+
+async function maybeAutoUpdateActiveAgentsExtension(context) {
+  const installedVersion = typeof context?.extension?.packageJSON?.version === 'string'
+    ? context.extension.packageJSON.version.trim()
+    : '';
+  if (!installedVersion) {
+    return;
+  }
+
+  const candidate = resolveActiveAgentsAutoUpdateCandidate(installedVersion);
+  if (!candidate) {
+    return;
+  }
+
+  try {
+    await runActiveAgentsInstallScript(candidate.repoRoot, candidate.installScriptPath);
+  } catch (error) {
+    const failure = typeof error?.message === 'string' && error.message.trim()
+      ? error.message.trim()
+      : 'install failed';
+    vscode.window.showWarningMessage?.(
+      `GitGuardex Active Agents could not auto-update to ${candidate.version}: ${failure}`,
+    );
+    return;
+  }
+
+  const selection = await vscode.window.showInformationMessage?.(
+    `GitGuardex Active Agents updated to ${candidate.version}. Reload Window to use the newest companion.`,
+    RELOAD_WINDOW_ACTION,
+    UPDATE_LATER_ACTION,
+  );
+  if (selection === RELOAD_WINDOW_ACTION) {
+    await vscode.commands.executeCommand('workbench.action.reloadWindow');
+  }
+}
+
 function decorateSession(session, lockRegistry) {
   return {
     ...session,
@@ -479,16 +726,29 @@ function localizeChangeForSession(session, change) {
 }
 
 async function findRepoSessionEntries() {
-  const sessionFiles = await vscode.workspace.findFiles(
-    ACTIVE_SESSION_FILES_GLOB,
-    SESSION_SCAN_EXCLUDE_GLOB,
-    SESSION_SCAN_LIMIT,
-  );
+  const [sessionFiles, worktreeLockFiles] = await Promise.all([
+    vscode.workspace.findFiles(
+      ACTIVE_SESSION_FILES_GLOB,
+      SESSION_SCAN_EXCLUDE_GLOB,
+      SESSION_SCAN_LIMIT,
+    ),
+    vscode.workspace.findFiles(
+      WORKTREE_AGENT_LOCKS_GLOB,
+      WORKTREE_LOCK_SCAN_EXCLUDE_GLOB,
+      SESSION_SCAN_LIMIT,
+    ),
+  ]);
 
   const repoRoots = new Set();
   for (const uri of sessionFiles) {
     repoRoots.add(repoRootFromSessionFile(uri.fsPath));
   }
+  for (const uri of worktreeLockFiles) {
+    if (path.basename(uri.fsPath) !== 'AGENT.lock') {
+      continue;
+    }
+    repoRoots.add(repoRootFromWorktreeLockFile(uri.fsPath));
+  }
 
   if (repoRoots.size === 0) {
     for (const workspaceFolder of vscode.workspace.workspaceFolders || []) {
@@ -808,6 +1068,11 @@ class ActiveAgentsProvider {
     this.treeView = null;
     this.lockRegistryByRepoRoot = new Map();
     this.selectedSession = null;
+    this.viewSummary = {
+      sessionCount: 0,
+      workingCount: 0,
+      deadCount: 0,
+    };
   }
 
   getTreeItem(element) {
@@ -828,6 +1093,7 @@ class ActiveAgentsProvider {
     const currentKey = sessionSelectionKey(this.selectedSession);
     const nextKey = sessionSelectionKey(nextSession);
     this.selectedSession = nextSession;
+    this.decorationProvider?.setSelectedBranch(nextSession?.branch || '');
     if (currentKey !== nextKey) {
       this.onDidChangeSelectedSessionEmitter.fire(this.selectedSession);
     }
@@ -837,6 +1103,10 @@ class ActiveAgentsProvider {
     return this.selectedSession ? { ...this.selectedSession } : null;
   }
 
+  getViewSummary() {
+    return { ...this.viewSummary };
+  }
+
   syncSelectedSession(repoEntries) {
     if (!this.selectedSession) {
       return;
@@ -854,6 +1124,11 @@ class ActiveAgentsProvider {
     }
 
     const activeCount = Math.max(0, sessionCount - deadCount);
+    this.viewSummary = {
+      sessionCount,
+      workingCount,
+      deadCount,
+    };
     const badgeTooltipParts = [];
     if (activeCount > 0) {
       badgeTooltipParts.push(`${activeCount} active agent${activeCount === 1 ? '' : 's'}`);
@@ -890,6 +1165,7 @@ class ActiveAgentsProvider {
 
     this.updateViewState(sessionCount, workingCount, deadCount);
     this.decorationProvider?.updateSessions(repoEntries.flatMap((entry) => entry.sessions));
+    this.decorationProvider?.updateLockEntries(repoEntries);
     return repoEntries;
   }
 
@@ -968,6 +1244,7 @@ class ActiveAgentsProvider {
         changes: readRepoChanges(repoRoot).map((change) => (
           decorateChange(change, lockRegistry, currentBranch)
         )),
+        lockEntries: Array.from(lockRegistry.entriesByPath.entries()),
       };
     });
   }
@@ -1052,19 +1329,36 @@ function activate(context) {
     'gitguardex.activeAgents.commitInput',
     'Active Agents Commit',
   );
+  const activeAgentsStatusItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 10);
+  activeAgentsStatusItem.name = 'GitGuardex Active Agents';
+  activeAgentsStatusItem.command = 'gitguardex.activeAgents.focus';
   provider.attachTreeView(treeView);
   const scheduleRefresh = () => refreshController.scheduleRefresh();
   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 updateCommitInput = (session) => {
     sourceControl.inputBox.enabled = true;
     sourceControl.inputBox.visible = true;
-    sourceControl.inputBox.placeholder = session?.label
-      ? `Commit ${session.label} (Ctrl+Enter)`
-      : 'Pick an Active Agents session to commit its worktree.';
+    sourceControl.inputBox.placeholder = sessionCommitPlaceholder(session);
+  };
+  const updateStatusBar = () => {
+    const selectedSession = provider.getSelectedSession();
+    const summary = provider.getViewSummary();
+    if ((summary.sessionCount || 0) <= 0) {
+      activeAgentsStatusItem.hide();
+      return;
+    }
+
+    activeAgentsStatusItem.text = selectedSession?.branch
+      ? `$(git-branch) ${sessionIdentityLabel(selectedSession)} · ${formatCountLabel(selectedSession.lockCount || 0, 'lock')}`
+      : buildActiveAgentsStatusSummary(summary);
+    activeAgentsStatusItem.tooltip = buildActiveAgentsStatusTooltip(selectedSession, summary);
+    activeAgentsStatusItem.show();
   };
   updateCommitInput(null);
+  updateStatusBar();
   const commitSelectedSession = async () => {
     const selectedSession = provider.getSelectedSession();
     if (!selectedSession?.worktreePath) {
@@ -1111,15 +1405,27 @@ function activate(context) {
     scheduleRefresh();
   };
 
-  provider.onDidChangeSelectedSession(updateCommitInput);
+  provider.onDidChangeSelectedSession((session) => {
+    updateCommitInput(session);
+    updateStatusBar();
+    decorationProvider.refresh();
+  });
+  provider.onDidChangeTreeData(() => {
+    updateCommitInput(provider.getSelectedSession());
+    updateStatusBar();
+  });
 
   context.subscriptions.push(
     treeView,
     sourceControl,
+    activeAgentsStatusItem,
     refreshController,
     vscode.window.registerFileDecorationProvider(decorationProvider),
     vscode.commands.registerCommand('gitguardex.activeAgents.startAgent', () => startAgentFromPrompt(refresh)),
     vscode.commands.registerCommand('gitguardex.activeAgents.refresh', refresh),
+    vscode.commands.registerCommand('gitguardex.activeAgents.focus', async () => {
+      await vscode.commands.executeCommand('workbench.view.scm');
+    }),
     vscode.commands.registerCommand('gitguardex.activeAgents.commitSelectedSession', commitSelectedSession),
     vscode.commands.registerCommand('gitguardex.activeAgents.openWorktree', async (session) => {
       if (!session?.worktreePath) {
@@ -1151,14 +1457,17 @@ function activate(context) {
     vscode.workspace.onDidChangeWorkspaceFolders(scheduleRefresh),
     activeSessionsWatcher,
     lockWatcher,
+    worktreeLockWatcher,
     { dispose: () => clearInterval(interval) },
   );
 
   context.subscriptions.push(
     ...bindRefreshWatcher(activeSessionsWatcher, scheduleRefresh),
     ...bindRefreshWatcher(lockWatcher, refreshLockRegistry),
+    ...bindRefreshWatcher(worktreeLockWatcher, scheduleRefresh),
   );
   void refreshController.refreshNow();
+  void maybeAutoUpdateActiveAgentsExtension(context);
 }
 
 function deactivate() {}