@imdeadpool/guardex 7.0.19 → 7.0.20

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

@@ -19,13 +19,42 @@
   "main": "./extension.js",
   "contributes": {
     "commands": [
+      {
+        "command": "gitguardex.activeAgents.startAgent",
+        "title": "Start Guardex Agent"
+      },
       {
         "command": "gitguardex.activeAgents.refresh",
         "title": "Refresh Active Agents"
       },
+      {
+        "command": "gitguardex.activeAgents.commitSelectedSession",
+        "title": "Commit Selected Session",
+        "icon": "$(check)"
+      },
       {
         "command": "gitguardex.activeAgents.openWorktree",
         "title": "Open Agent Worktree"
+      },
+      {
+        "command": "gitguardex.activeAgents.finishSession",
+        "title": "Finish",
+        "icon": "$(check)"
+      },
+      {
+        "command": "gitguardex.activeAgents.syncSession",
+        "title": "Sync",
+        "icon": "$(sync)"
+      },
+      {
+        "command": "gitguardex.activeAgents.stopSession",
+        "title": "Stop",
+        "icon": "$(debug-stop)"
+      },
+      {
+        "command": "gitguardex.activeAgents.openSessionDiff",
+        "title": "Open Diff",
+        "icon": "$(diff)"
       }
     ],
     "views": {
@@ -37,12 +66,23 @@
         }
       ]
     },
+    "viewsWelcome": [
+      {
+        "view": "gitguardex.activeAgents",
+        "contents": "No active Guardex agents are visible in this workspace yet.\n\n[Start agent](command:gitguardex.activeAgents.startAgent)\n[Open guide](https://github.com/recodeee/gitguardex/blob/main/vscode/guardex-active-agents/README.md#quick-start)\n[Refresh](command:gitguardex.activeAgents.refresh)"
+      }
+    ],
     "menus": {
       "view/title": [
+        {
+          "command": "gitguardex.activeAgents.commitSelectedSession",
+          "when": "view == gitguardex.activeAgents",
+          "group": "navigation@1"
+        },
         {
           "command": "gitguardex.activeAgents.refresh",
           "when": "view == gitguardex.activeAgents",
-          "group": "navigation"
+          "group": "navigation@9"
         }
       ],
       "view/item/context": [
@@ -50,6 +90,26 @@
           "command": "gitguardex.activeAgents.openWorktree",
           "when": "view == gitguardex.activeAgents && viewItem == gitguardex.session",
           "group": "inline"
+        },
+        {
+          "command": "gitguardex.activeAgents.finishSession",
+          "when": "view == gitguardex.activeAgents && viewItem == gitguardex.session",
+          "group": "inline"
+        },
+        {
+          "command": "gitguardex.activeAgents.syncSession",
+          "when": "view == gitguardex.activeAgents && viewItem == gitguardex.session",
+          "group": "inline"
+        },
+        {
+          "command": "gitguardex.activeAgents.stopSession",
+          "when": "view == gitguardex.activeAgents && viewItem == gitguardex.session",
+          "group": "inline"
+        },
+        {
+          "command": "gitguardex.activeAgents.openSessionDiff",
+          "when": "view == gitguardex.activeAgents && viewItem == gitguardex.session",
+          "group": "inline"
         }
       ]
     }

package/templates/vscode/guardex-active-agents/session-schema.js

@@ -7,6 +7,23 @@ const SESSION_SCHEMA_VERSION = 1;
 const LOCK_FILE_RELATIVE = path.join('.omx', 'state', 'agent-file-locks.json');
 const MAX_CHANGED_PATH_PREVIEW = 3;
 const ACTIVE_SESSIONS_FILTER_PREFIX = ACTIVE_SESSIONS_RELATIVE_DIR.split(path.sep).join('/');
+const LOCK_FILE_FILTER_PATH = LOCK_FILE_RELATIVE.split(path.sep).join('/');
+const IDLE_ACTIVITY_WINDOW_MS = 2 * 60 * 1000;
+const STALLED_ACTIVITY_WINDOW_MS = 15 * 60 * 1000;
+const BLOCKING_GIT_STATES = [
+  {
+    label: 'Rebase in progress.',
+    markers: ['REBASE_HEAD', 'rebase-apply', 'rebase-merge'],
+  },
+  {
+    label: 'Merge in progress.',
+    markers: ['MERGE_HEAD'],
+  },
+  {
+    label: 'Cherry-pick in progress.',
+    markers: ['CHERRY_PICK_HEAD'],
+  },
+];
 
 function toNonEmptyString(value, fallback = '') {
   const normalized = typeof value === 'string' ? value.trim() : String(value || '').trim();
@@ -18,6 +35,16 @@ function toPositiveInteger(value) {
   return Number.isInteger(normalized) && normalized > 0 ? normalized : null;
 }
 
+function normalizeTaskMode(value) {
+  const normalized = toNonEmptyString(value).toLowerCase();
+  return normalized === 'caveman' || normalized === 'omx' ? normalized : '';
+}
+
+function normalizeOpenSpecTier(value) {
+  const normalized = toNonEmptyString(value).toUpperCase();
+  return ['T0', 'T1', 'T2', 'T3'].includes(normalized) ? normalized : '';
+}
+
 function sanitizeBranchForFile(branch) {
   const normalized = toNonEmptyString(branch, 'session');
   return normalized.replace(/[^a-zA-Z0-9._-]+/g, '__').replace(/^_+|_+$/g, '') || 'session';
@@ -45,6 +72,10 @@ function splitOutputLines(output) {
     .filter((line) => line.trim().length > 0);
 }
 
+function normalizeRelativePath(value) {
+  return toNonEmptyString(value).replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
 function runGitLines(worktreePath, args) {
   try {
     const output = cp.execFileSync('git', ['-C', worktreePath, ...args], {
@@ -150,7 +181,9 @@ function parseRepoChangeLine(repoRoot, line) {
 
   const normalizedRelativePath = relativePath.split(path.sep).join('/');
   if (
-    normalizedRelativePath === ACTIVE_SESSIONS_FILTER_PREFIX
+    normalizedRelativePath === LOCK_FILE_FILTER_PATH
+    || normalizedRelativePath.startsWith(`${LOCK_FILE_FILTER_PATH}/`)
+    || normalizedRelativePath === ACTIVE_SESSIONS_FILTER_PREFIX
     || normalizedRelativePath.startsWith(`${ACTIVE_SESSIONS_FILTER_PREFIX}/`)
   ) {
     return null;
@@ -181,37 +214,187 @@ function collectWorktreeChangedPaths(worktreePath) {
     .sort((left, right) => left.localeCompare(right));
 }
 
-function deriveSessionActivity(session) {
-  const changedPaths = collectWorktreeChangedPaths(session.worktreePath);
-  if (!changedPaths) {
+function resolveWorktreeGitDir(worktreePath) {
+  const gitPath = path.join(path.resolve(worktreePath), '.git');
+  try {
+    if (fs.statSync(gitPath).isDirectory()) {
+      return gitPath;
+    }
+  } catch (_error) {
+    return null;
+  }
+
+  try {
+    const gitPointer = fs.readFileSync(gitPath, 'utf8');
+    const match = gitPointer.match(/^gitdir:\s*(.+)$/m);
+    if (match?.[1]) {
+      return path.resolve(worktreePath, match[1].trim());
+    }
+  } catch (_error) {
+    return null;
+  }
+
+  return null;
+}
+
+function deriveBlockingGitLabel(worktreePath) {
+  const gitDir = resolveWorktreeGitDir(worktreePath);
+  if (!gitDir) {
+    return '';
+  }
+
+  for (const blockingState of BLOCKING_GIT_STATES) {
+    if (blockingState.markers.some((marker) => fs.existsSync(path.join(gitDir, marker)))) {
+      return blockingState.label;
+    }
+  }
+
+  return '';
+}
+
+function collectWorktreeTrackedPaths(worktreePath) {
+  const trackedPaths = runGitLines(worktreePath, ['ls-files', '--cached', '--others', '--exclude-standard']);
+  if (!trackedPaths) {
+    return null;
+  }
+
+  return [...new Set(trackedPaths)]
+    .filter(Boolean)
+    .sort((left, right) => left.localeCompare(right));
+}
+
+function deriveLatestWorktreeFileActivity(worktreePath) {
+  const trackedPaths = collectWorktreeTrackedPaths(worktreePath);
+  if (!trackedPaths) {
+    return null;
+  }
+
+  let latestMtimeMs = null;
+  for (const relativePath of trackedPaths) {
+    const absolutePath = path.join(worktreePath, relativePath);
+    try {
+      const stats = fs.statSync(absolutePath);
+      if (!stats.isFile() || !Number.isFinite(stats.mtimeMs)) {
+        continue;
+      }
+      latestMtimeMs = latestMtimeMs === null
+        ? stats.mtimeMs
+        : Math.max(latestMtimeMs, stats.mtimeMs);
+    } catch (_error) {
+      continue;
+    }
+  }
+
+  return latestMtimeMs;
+}
+
+function deriveSessionActivity(session, options = {}) {
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const blockingLabel = deriveBlockingGitLabel(session.worktreePath);
+  if (blockingLabel) {
     return {
-      activityKind: 'thinking',
-      activityLabel: 'thinking',
+      activityKind: 'blocked',
+      activityLabel: 'blocked',
+      activityCountLabel: '',
+      activitySummary: blockingLabel,
+      changeCount: 0,
+      changedPaths: [],
+      pidAlive: isPidAlive(session.pid),
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
+    };
+  }
+
+  const pidAlive = isPidAlive(session.pid);
+  if (!pidAlive) {
+    return {
+      activityKind: 'dead',
+      activityLabel: 'dead',
+      activityCountLabel: '',
+      activitySummary: 'Recorded PID is not alive.',
+      changeCount: 0,
+      changedPaths: [],
+      pidAlive,
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
+    };
+  }
+
+  const worktreeChangedPaths = collectWorktreeChangedPaths(session.worktreePath);
+  if (!worktreeChangedPaths) {
+    return {
+      activityKind: 'idle',
+      activityLabel: 'idle',
       activityCountLabel: '',
       activitySummary: 'Worktree activity unavailable.',
       changeCount: 0,
       changedPaths: [],
+      pidAlive,
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
+    };
+  }
+
+  if (worktreeChangedPaths.length > 0) {
+    const changedPaths = [...new Set(worktreeChangedPaths
+      .map((relativePath) => normalizeRelativePath(
+        path.relative(session.repoRoot, path.resolve(session.worktreePath, relativePath)),
+      ))
+      .filter(Boolean))]
+      .sort((left, right) => left.localeCompare(right));
+
+    return {
+      activityKind: 'working',
+      activityLabel: 'working',
+      activityCountLabel: formatFileCount(worktreeChangedPaths.length),
+      activitySummary: previewChangedPaths(worktreeChangedPaths),
+      changeCount: worktreeChangedPaths.length,
+      changedPaths,
+      pidAlive,
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
     };
   }
 
-  if (changedPaths.length === 0) {
+  const latestFileActivityMs = deriveLatestWorktreeFileActivity(session.worktreePath);
+  const lastFileActivityAt = Number.isFinite(latestFileActivityMs)
+    ? new Date(latestFileActivityMs).toISOString()
+    : '';
+  const lastFileActivityLabel = lastFileActivityAt
+    ? formatElapsedFrom(lastFileActivityAt, now)
+    : '';
+  const lastFileActivityAgeMs = Number.isFinite(latestFileActivityMs)
+    ? Math.max(0, now - latestFileActivityMs)
+    : null;
+
+  if (lastFileActivityAgeMs !== null && lastFileActivityAgeMs > STALLED_ACTIVITY_WINDOW_MS) {
     return {
-      activityKind: 'thinking',
-      activityLabel: 'thinking',
+      activityKind: 'stalled',
+      activityLabel: 'stalled',
       activityCountLabel: '',
-      activitySummary: 'Worktree clean.',
+      activitySummary: `Worktree clean. No file activity for ${lastFileActivityLabel}.`,
       changeCount: 0,
       changedPaths: [],
+      pidAlive,
+      lastFileActivityAt,
+      lastFileActivityLabel,
     };
   }
 
   return {
-    activityKind: 'working',
-    activityLabel: 'working',
-    activityCountLabel: formatFileCount(changedPaths.length),
-    activitySummary: previewChangedPaths(changedPaths),
-    changeCount: changedPaths.length,
-    changedPaths,
+    activityKind: 'idle',
+    activityLabel: 'idle',
+    activityCountLabel: '',
+    activitySummary: lastFileActivityAgeMs !== null && lastFileActivityAgeMs <= IDLE_ACTIVITY_WINDOW_MS
+      ? `Worktree clean. Recent file activity ${lastFileActivityLabel} ago.`
+      : lastFileActivityLabel
+        ? `Worktree clean. Last file activity ${lastFileActivityLabel} ago.`
+        : 'Worktree clean.',
+    changeCount: 0,
+    changedPaths: [],
+    pidAlive,
+    lastFileActivityAt,
+    lastFileActivityLabel,
   };
 }
 
@@ -247,6 +430,9 @@ function buildSessionRecord(input) {
     worktreePath,
     pid,
     cliName: toNonEmptyString(input.cliName, 'codex'),
+    taskMode: normalizeTaskMode(input.taskMode),
+    openspecTier: normalizeOpenSpecTier(input.openspecTier),
+    taskRoutingReason: toNonEmptyString(input.taskRoutingReason),
     startedAt: startedAt.toISOString(),
   };
 }
@@ -283,9 +469,13 @@ function normalizeSessionRecord(input, options = {}) {
     worktreePath: path.resolve(worktreePath),
     pid,
     cliName: toNonEmptyString(input.cliName, 'codex'),
+    taskMode: normalizeTaskMode(input.taskMode),
+    openspecTier: normalizeOpenSpecTier(input.openspecTier),
+    taskRoutingReason: toNonEmptyString(input.taskRoutingReason),
     startedAt: startedAt.toISOString(),
     filePath: toNonEmptyString(options.filePath),
     label: deriveSessionLabel(branch, worktreePath),
+    changedPaths: [],
   };
 }
 
@@ -357,7 +547,7 @@ function readActiveSessions(repoRoot, options = {}) {
     }
 
     normalized.elapsedLabel = formatElapsedFrom(normalized.startedAt, now);
-    Object.assign(normalized, deriveSessionActivity(normalized));
+    Object.assign(normalized, deriveSessionActivity(normalized, { now }));
     sessions.push(normalized);
   }
 
@@ -390,6 +580,9 @@ module.exports = {
   activeSessionsDirForRepo,
   buildSessionRecord,
   collectWorktreeChangedPaths,
+  collectWorktreeTrackedPaths,
+  deriveBlockingGitLabel,
+  deriveLatestWorktreeFileActivity,
   deriveSessionLabel,
   deriveSessionActivity,
   formatElapsedFrom,
@@ -401,6 +594,7 @@ module.exports = {
   readActiveSessions,
   readRepoChanges,
   deriveRepoChangeStatus,
+  resolveWorktreeGitDir,
   sanitizeBranchForFile,
   sessionFileNameForBranch,
   sessionFilePathForBranch,