@imdeadpool/guardex 7.0.20 → 7.0.21

package/src/context.js

@@ -71,7 +71,7 @@ const REQUIRED_SYSTEM_TOOLS = [
   },
 ];
 const MAINTAINER_RELEASE_REPO = path.resolve(
-  process.env.GUARDEX_RELEASE_REPO || path.resolve(PACKAGE_ROOT),
+  process.env.GUARDEX_RELEASE_REPO || PACKAGE_ROOT,
 );
 const NPM_BIN = process.env.GUARDEX_NPM_BIN || 'npm';
 const OPENSPEC_BIN = process.env.GUARDEX_OPENSPEC_BIN || 'openspec';
@@ -242,13 +242,24 @@ const GITIGNORE_MARKER_START = '# multiagent-safety:START';
 const GITIGNORE_MARKER_END = '# multiagent-safety:END';
 const CODEX_WORKTREE_RELATIVE_DIR = path.join('.omx', 'agent-worktrees');
 const CLAUDE_WORKTREE_RELATIVE_DIR = path.join('.omc', 'agent-worktrees');
+const SHARED_VSCODE_SETTINGS_RELATIVE = path.posix.join('.vscode', 'settings.json');
+const REPO_SCAN_IGNORED_FOLDERS_SETTING = 'git.repositoryScanIgnoredFolders';
 const AGENT_WORKTREE_RELATIVE_DIRS = [
   CODEX_WORKTREE_RELATIVE_DIR,
   CLAUDE_WORKTREE_RELATIVE_DIR,
 ];
+const MANAGED_REPO_SCAN_IGNORED_FOLDERS = [
+  '.omx/agent-worktrees',
+  '**/.omx/agent-worktrees',
+  '.omc/agent-worktrees',
+  '**/.omc/agent-worktrees',
+];
 const MANAGED_GITIGNORE_PATHS = [
   '.omx/',
   '.omc/',
+  '!.vscode/',
+  '.vscode/*',
+  '!.vscode/settings.json',
   'scripts/agent-session-state.js',
   'scripts/guardex-docker-loader.sh',
   'scripts/guardex-env.sh',
@@ -322,8 +333,8 @@ const SUGGESTIBLE_COMMANDS = [
 ];
 const CLI_COMMAND_DESCRIPTIONS = [
   ['status', 'Show GitGuardex CLI + service health without modifying files'],
-  ['setup', 'Install, repair, and verify guardrails (flags: --repair, --install-only, --target)'],
-  ['doctor', 'Repair drift + verify (auto-sandboxes on protected main)'],
+  ['setup', 'Install, repair, and verify guardrails (flags: --repair, --install-only, --target, --current)'],
+  ['doctor', 'Repair drift + verify (flags: --target, --current; auto-sandboxes on protected main)'],
   ['branch', 'CLI-owned branch workflow surface (start/finish/merge)'],
   ['locks', 'CLI-owned file lock surface (claim/allow-delete/release/status/validate)'],
   ['worktree', 'CLI-owned worktree cleanup surface (prune)'],
@@ -480,7 +491,10 @@ module.exports = {
   GITIGNORE_MARKER_END,
   CODEX_WORKTREE_RELATIVE_DIR,
   CLAUDE_WORKTREE_RELATIVE_DIR,
+  SHARED_VSCODE_SETTINGS_RELATIVE,
+  REPO_SCAN_IGNORED_FOLDERS_SETTING,
   AGENT_WORKTREE_RELATIVE_DIRS,
+  MANAGED_REPO_SCAN_IGNORED_FOLDERS,
   MANAGED_GITIGNORE_PATHS,
   REPO_SCAFFOLD_DIRECTORIES,
   OMX_SCAFFOLD_DIRECTORIES,

package/src/git/index.js

@@ -1,3 +1,4 @@
+const fs = require('node:fs');
 const { path } = require('../context');
 const { run } = require('../core/runtime');
 
@@ -41,66 +42,75 @@ const NESTED_REPO_DEFAULT_SKIP_DIRS = new Set([
   '.pnpm-store',
 ]);
 
+function resolveGitCommonDir(repoPath) {
+  const result = run('git', ['-C', repoPath, 'rev-parse', '--git-common-dir'], { cwd: repoPath });
+  if (result.status !== 0) return null;
+  const raw = result.stdout.trim();
+  if (!raw) return null;
+  return path.resolve(repoPath, raw);
+}
+
 function discoverNestedGitRepos(rootPath, opts = {}) {
   const maxDepth = Number.isFinite(opts.maxDepth)
     ? Math.max(1, opts.maxDepth)
     : NESTED_REPO_DEFAULT_MAX_DEPTH;
   const extraSkip = new Set(Array.isArray(opts.extraSkip) ? opts.extraSkip : []);
   const includeSubmodules = Boolean(opts.includeSubmodules);
+  const skipRelativeDirs = Array.isArray(opts.skipRelativeDirs) ? opts.skipRelativeDirs.filter(Boolean) : [];
   const resolvedRoot = path.resolve(rootPath);
 
   if (!isGitRepo(resolvedRoot)) {
     throw new Error(`Target is not inside a git repository: ${resolvedRoot}`);
   }
 
-  const results = [];
-  const seen = new Set();
-
-  function visit(directoryPath, depth) {
-    const repoRoot = resolveRepoRoot(directoryPath);
-    if (!seen.has(repoRoot)) {
-      seen.add(repoRoot);
-      results.push(repoRoot);
-    }
+  const rootCommonDir = resolveGitCommonDir(resolvedRoot);
+  const skipAbsolutes = skipRelativeDirs.map((relativeDir) => path.join(resolvedRoot, relativeDir));
+  const found = new Set([resolvedRoot]);
 
-    if (depth >= maxDepth) {
-      return;
-    }
+  function shouldSkipDir(dirName) {
+    return NESTED_REPO_DEFAULT_SKIP_DIRS.has(dirName) || extraSkip.has(dirName);
+  }
 
-    let entries = [];
+  function walk(currentPath, depth) {
+    if (depth > maxDepth) return;
+    let entries;
     try {
-      entries = require('node:fs').readdirSync(directoryPath, { withFileTypes: true });
+      entries = fs.readdirSync(currentPath, { withFileTypes: true });
     } catch {
       return;
     }
 
     for (const entry of entries) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      if (NESTED_REPO_DEFAULT_SKIP_DIRS.has(entry.name) || extraSkip.has(entry.name)) {
-        continue;
-      }
+      const entryPath = path.join(currentPath, entry.name);
 
-      const childPath = path.join(directoryPath, entry.name);
-      const gitDir = path.join(childPath, '.git');
-      if (require('node:fs').existsSync(gitDir)) {
-        if (!includeSubmodules) {
-          const gitInfo = require('node:fs').lstatSync(gitDir);
-          if (gitInfo.isFile()) {
-            continue;
-          }
+      if (entry.name === '.git') {
+        if (entry.isDirectory()) {
+          if (entryPath === path.join(resolvedRoot, '.git')) continue;
+          found.add(path.dirname(entryPath));
+        } else if (includeSubmodules && entry.isFile()) {
+          found.add(path.dirname(entryPath));
         }
-        visit(childPath, depth + 1);
         continue;
       }
 
-      visit(childPath, depth + 1);
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      if (shouldSkipDir(entry.name)) continue;
+      if (skipAbsolutes.includes(entryPath)) continue;
+      walk(entryPath, depth + 1);
     }
   }
 
-  visit(resolvedRoot, 0);
-  return results;
+  walk(resolvedRoot, 0);
+
+  const filtered = Array.from(found).filter((repoPath) => {
+    if (repoPath === resolvedRoot || !rootCommonDir) return true;
+    const childCommonDir = resolveGitCommonDir(repoPath);
+    return !childCommonDir || childCommonDir !== rootCommonDir;
+  });
+
+  const [root, ...rest] = filtered;
+  rest.sort((a, b) => a.localeCompare(b));
+  return root ? [root, ...rest] : [];
 }
 
 module.exports = {

package/src/scaffold/index.js

@@ -3,32 +3,11 @@ const {
   path,
   TOOL_NAME,
   SHORT_TOOL_NAME,
+  toDestinationPath,
   EXECUTABLE_RELATIVE_PATHS,
   CRITICAL_GUARDRAIL_PATHS,
 } = require('../context');
 
-function toDestinationPath(relativeTemplatePath) {
-  if (relativeTemplatePath.startsWith('scripts/')) {
-    return relativeTemplatePath;
-  }
-  if (relativeTemplatePath.startsWith('githooks/')) {
-    return `.${relativeTemplatePath}`;
-  }
-  if (relativeTemplatePath.startsWith('codex/')) {
-    return `.${relativeTemplatePath}`;
-  }
-  if (relativeTemplatePath.startsWith('claude/')) {
-    return `.${relativeTemplatePath}`;
-  }
-  if (relativeTemplatePath.startsWith('github/')) {
-    return `.${relativeTemplatePath}`;
-  }
-  if (relativeTemplatePath.startsWith('vscode/')) {
-    return relativeTemplatePath;
-  }
-  throw new Error(`Unsupported template path: ${relativeTemplatePath}`);
-}
-
 function ensureParentDir(repoRoot, filePath, dryRun) {
   if (dryRun) return;
 

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

@@ -24,4 +24,4 @@ What it does:
 - 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,7 +15,9 @@ 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 SESSION_ACTIVITY_GROUPS = [
@@ -187,14 +189,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 +376,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), '..', '..');
 }
@@ -479,16 +494,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 || []) {
@@ -1057,6 +1085,7 @@ function activate(context) {
   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;
@@ -1151,12 +1180,14 @@ 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();
 }

package/templates/vscode/guardex-active-agents/package.json

@@ -14,6 +14,8 @@
   ],
   "activationEvents": [
     "workspaceContains:.omx/state/active-sessions",
+    "workspaceContains:.omx/agent-worktrees",
+    "workspaceContains:.omc/agent-worktrees",
     "onView:gitguardex.activeAgents"
   ],
   "main": "./extension.js",