@imdeadpool/guardex 7.0.19 → 7.0.21

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

@@ -5,8 +5,30 @@ const cp = require('node:child_process');
 const ACTIVE_SESSIONS_RELATIVE_DIR = path.join('.omx', 'state', 'active-sessions');
 const SESSION_SCHEMA_VERSION = 1;
 const LOCK_FILE_RELATIVE = path.join('.omx', 'state', 'agent-file-locks.json');
+const AGENT_WORKTREE_LOCK_FILE = 'AGENT.lock';
+const MANAGED_WORKTREE_ROOTS = [
+  path.join('.omx', 'agent-worktrees'),
+  path.join('.omc', 'agent-worktrees'),
+];
 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 +40,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';
@@ -35,6 +67,10 @@ function sessionFilePathForBranch(repoRoot, branch) {
   return path.join(activeSessionsDirForRepo(repoRoot), sessionFileNameForBranch(branch));
 }
 
+function resolveManagedWorktreeRoots(repoRoot) {
+  return MANAGED_WORKTREE_ROOTS.map((relativeRoot) => path.join(path.resolve(repoRoot), relativeRoot));
+}
+
 function splitOutputLines(output) {
   if (typeof output !== 'string') {
     return null;
@@ -45,6 +81,28 @@ function splitOutputLines(output) {
     .filter((line) => line.trim().length > 0);
 }
 
+function normalizeRelativePath(value) {
+  return toNonEmptyString(value).replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function normalizeIsoString(value, fallback = '') {
+  const normalized = toNonEmptyString(value);
+  if (!normalized) {
+    return fallback;
+  }
+
+  const timestamp = Date.parse(normalized);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : fallback;
+}
+
 function runGitLines(worktreePath, args) {
   try {
     const output = cp.execFileSync('git', ['-C', worktreePath, ...args], {
@@ -150,7 +208,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;
@@ -167,8 +227,8 @@ function parseRepoChangeLine(repoRoot, line) {
 
 function collectWorktreeChangedPaths(worktreePath) {
   const changedGroups = [
-    runGitLines(worktreePath, ['diff', '--name-only', '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`]),
-    runGitLines(worktreePath, ['diff', '--cached', '--name-only', '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`]),
+    runGitLines(worktreePath, ['diff', '--name-only', '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`, `:(exclude)${AGENT_WORKTREE_LOCK_FILE}`]),
+    runGitLines(worktreePath, ['diff', '--cached', '--name-only', '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`, `:(exclude)${AGENT_WORKTREE_LOCK_FILE}`]),
     runGitLines(worktreePath, ['ls-files', '--others', '--exclude-standard']),
   ];
 
@@ -177,41 +237,196 @@ function collectWorktreeChangedPaths(worktreePath) {
   }
 
   return [...new Set(changedGroups.flat())]
-    .filter((relativePath) => relativePath && relativePath !== LOCK_FILE_RELATIVE)
+    .filter((relativePath) => (
+      relativePath
+      && relativePath !== LOCK_FILE_RELATIVE
+      && relativePath !== AGENT_WORKTREE_LOCK_FILE
+    ))
+    .sort((left, right) => left.localeCompare(right));
+}
+
+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 deriveSessionActivity(session) {
-  const changedPaths = collectWorktreeChangedPaths(session.worktreePath);
-  if (!changedPaths) {
+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 pid = toPositiveInteger(session?.pid);
+  const pidAlive = pid ? isPidAlive(pid) : null;
+  const blockingLabel = deriveBlockingGitLabel(session.worktreePath);
+  if (blockingLabel) {
     return {
-      activityKind: 'thinking',
-      activityLabel: 'thinking',
+      activityKind: 'blocked',
+      activityLabel: 'blocked',
+      activityCountLabel: '',
+      activitySummary: blockingLabel,
+      changeCount: 0,
+      changedPaths: [],
+      pidAlive,
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
+    };
+  }
+
+  if (pid && !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 (changedPaths.length === 0) {
+  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: 'thinking',
-      activityLabel: 'thinking',
+      activityKind: 'working',
+      activityLabel: 'working',
+      activityCountLabel: formatFileCount(worktreeChangedPaths.length),
+      activitySummary: previewChangedPaths(worktreeChangedPaths),
+      changeCount: worktreeChangedPaths.length,
+      changedPaths,
+      pidAlive,
+      lastFileActivityAt: '',
+      lastFileActivityLabel: '',
+    };
+  }
+
+  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: '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,
   };
 }
 
@@ -243,10 +458,14 @@ function buildSessionRecord(input) {
     repoRoot,
     branch,
     taskName: toNonEmptyString(input.taskName, 'task'),
+    latestTaskPreview: '',
     agentName: toNonEmptyString(input.agentName, 'agent'),
     worktreePath,
     pid,
     cliName: toNonEmptyString(input.cliName, 'codex'),
+    taskMode: normalizeTaskMode(input.taskMode),
+    openspecTier: normalizeOpenSpecTier(input.openspecTier),
+    taskRoutingReason: toNonEmptyString(input.taskRoutingReason),
     startedAt: startedAt.toISOString(),
   };
 }
@@ -279,13 +498,24 @@ function normalizeSessionRecord(input, options = {}) {
     repoRoot: path.resolve(repoRoot),
     branch,
     taskName: toNonEmptyString(input.taskName, 'task'),
+    latestTaskPreview: '',
     agentName: toNonEmptyString(input.agentName, 'agent'),
     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: [],
+    sourceKind: 'active-session',
+    telemetryUpdatedAt: '',
+    telemetrySource: '',
+    lockSnapshotCount: 0,
+    lockSessionCount: 0,
+    collaboration: false,
   };
 }
 
@@ -327,49 +557,212 @@ function isPidAlive(pid) {
   }
 }
 
-function readActiveSessions(repoRoot, options = {}) {
-  const activeSessionsDir = activeSessionsDirForRepo(repoRoot);
-  if (!fs.existsSync(activeSessionsDir)) {
-    return [];
+function readWorktreeBranch(worktreePath) {
+  const lines = runGitLines(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  return Array.isArray(lines) && typeof lines[0] === 'string' ? lines[0].trim() : '';
+}
+
+function deriveAgentNameFromBranch(branch) {
+  const parts = toNonEmptyString(branch).split('/').filter(Boolean);
+  if (parts.length >= 2 && parts[0] === 'agent') {
+    return parts[1];
   }
+  return 'agent';
+}
+
+function flattenTelemetrySnapshotSessions(lockPayload) {
+  const flattened = [];
+  const snapshots = Array.isArray(lockPayload?.snapshots) ? lockPayload.snapshots : [];
+  for (const snapshot of snapshots) {
+    const snapshotSessions = Array.isArray(snapshot?.sessions) ? snapshot.sessions : [];
+    for (const session of snapshotSessions) {
+      flattened.push({
+        taskPreview: toNonEmptyString(session?.taskPreview),
+        taskUpdatedAt: normalizeIsoString(session?.taskUpdatedAt),
+        projectName: toNonEmptyString(session?.projectName),
+        projectPath: toNonEmptyString(session?.projectPath),
+        snapshotName: toNonEmptyString(snapshot?.snapshotName),
+        email: toNonEmptyString(snapshot?.email),
+      });
+    }
+  }
+  return flattened;
+}
 
+function sortSessionsByTimestamp(sessions) {
+  sessions.sort((left, right) => {
+    const timeDelta = Date.parse(right.startedAt) - Date.parse(left.startedAt);
+    if (timeDelta !== 0) {
+      return timeDelta;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return sessions;
+}
+
+function deriveLockTaskAnchor(entries, fallbackTaskName, fallbackTimestamp) {
+  const sortedEntries = [...entries].sort((left, right) => {
+    const timeDelta = Date.parse(right.taskUpdatedAt || '') - Date.parse(left.taskUpdatedAt || '');
+    if (timeDelta !== 0) {
+      return timeDelta;
+    }
+    if (Boolean(right.taskPreview) !== Boolean(left.taskPreview)) {
+      return Number(Boolean(right.taskPreview)) - Number(Boolean(left.taskPreview));
+    }
+    return (right.projectPath || '').localeCompare(left.projectPath || '');
+  });
+
+  const latestEntry = sortedEntries[0] || null;
+  return {
+    taskName: latestEntry?.taskPreview || fallbackTaskName || 'task',
+    latestTaskPreview: latestEntry?.taskPreview || '',
+    timestamp: latestEntry?.taskUpdatedAt || fallbackTimestamp || '',
+  };
+}
+
+function buildWorktreeLockSession(repoRoot, worktreePath, lockPayload, options = {}) {
   const now = options.now || Date.now();
+  const telemetryEntries = flattenTelemetrySnapshotSessions(lockPayload);
+  const telemetryUpdatedAt = normalizeIsoString(lockPayload?.updatedAt);
+  const branch = readWorktreeBranch(worktreePath);
+  const effectiveBranch = branch && branch !== 'HEAD'
+    ? branch
+    : `agent/telemetry/${path.basename(worktreePath)}`;
+  const label = deriveSessionLabel(effectiveBranch, worktreePath);
+  const taskAnchor = deriveLockTaskAnchor(telemetryEntries, label, telemetryUpdatedAt);
+  const startedAt = taskAnchor.timestamp || telemetryUpdatedAt || new Date(now).toISOString();
+
+  const session = {
+    schemaVersion: toPositiveInteger(lockPayload?.schemaVersion) || SESSION_SCHEMA_VERSION,
+    repoRoot: path.resolve(repoRoot),
+    branch: effectiveBranch,
+    taskName: taskAnchor.taskName,
+    latestTaskPreview: taskAnchor.latestTaskPreview,
+    agentName: deriveAgentNameFromBranch(effectiveBranch),
+    worktreePath: path.resolve(worktreePath),
+    pid: null,
+    cliName: 'codex',
+    taskMode: '',
+    openspecTier: '',
+    taskRoutingReason: '',
+    startedAt,
+    filePath: path.join(worktreePath, AGENT_WORKTREE_LOCK_FILE),
+    label,
+    changedPaths: [],
+    sourceKind: 'worktree-lock',
+    telemetryUpdatedAt: telemetryUpdatedAt || startedAt,
+    telemetrySource: toNonEmptyString(lockPayload?.source, 'worktree-lock'),
+    lockSnapshotCount: toPositiveInteger(lockPayload?.snapshotCount) || 0,
+    lockSessionCount: toPositiveInteger(lockPayload?.sessionCount) || telemetryEntries.length,
+    collaboration: Boolean(lockPayload?.collaboration),
+  };
+
+  session.elapsedLabel = formatElapsedFrom(session.startedAt, now);
+  Object.assign(session, deriveSessionActivity(session, { now }));
+  return session;
+}
+
+function readWorktreeLockSessions(repoRoot, options = {}) {
   const sessions = [];
-  for (const entry of fs.readdirSync(activeSessionsDir, { withFileTypes: true })) {
-    if (!entry.isFile() || !entry.name.endsWith('.json')) {
+  for (const managedRoot of resolveManagedWorktreeRoots(repoRoot)) {
+    if (!fs.existsSync(managedRoot)) {
       continue;
     }
 
-    const filePath = path.join(activeSessionsDir, entry.name);
-    let parsed;
+    let entries;
     try {
-      parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      entries = fs.readdirSync(managedRoot, { withFileTypes: true });
     } catch (_error) {
       continue;
     }
 
-    const normalized = normalizeSessionRecord(parsed, { filePath });
-    if (!normalized) {
-      continue;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      const worktreePath = path.join(managedRoot, entry.name);
+      const lockPath = path.join(worktreePath, AGENT_WORKTREE_LOCK_FILE);
+      if (!fs.existsSync(lockPath)) {
+        continue;
+      }
+
+      const lockPayload = readJsonFile(lockPath);
+      if (!lockPayload || typeof lockPayload !== 'object' || Array.isArray(lockPayload)) {
+        continue;
+      }
+
+      const telemetryEntries = flattenTelemetrySnapshotSessions(lockPayload);
+      if (telemetryEntries.length === 0 && !toPositiveInteger(lockPayload.sessionCount)) {
+        continue;
+      }
+
+      sessions.push(buildWorktreeLockSession(repoRoot, worktreePath, lockPayload, options));
     }
-    if (!options.includeStale && !isPidAlive(normalized.pid)) {
+  }
+
+  return sortSessionsByTimestamp(sessions);
+}
+
+function mergeSessionSources(primarySessions, lockSessions) {
+  const lockSessionsByWorktree = new Map(
+    lockSessions.map((session) => [path.resolve(session.worktreePath), session]),
+  );
+  const consumedLockWorktrees = new Set();
+  const merged = [];
+
+  for (const session of primarySessions) {
+    const worktreeKey = path.resolve(session.worktreePath);
+    const lockSession = lockSessionsByWorktree.get(worktreeKey);
+    if (lockSession && session.activityKind === 'dead') {
       continue;
     }
+    if (lockSession) {
+      consumedLockWorktrees.add(worktreeKey);
+    }
+    merged.push(session);
+  }
 
-    normalized.elapsedLabel = formatElapsedFrom(normalized.startedAt, now);
-    Object.assign(normalized, deriveSessionActivity(normalized));
-    sessions.push(normalized);
+  for (const lockSession of lockSessions) {
+    const worktreeKey = path.resolve(lockSession.worktreePath);
+    if (!consumedLockWorktrees.has(worktreeKey)) {
+      merged.push(lockSession);
+    }
   }
 
-  sessions.sort((left, right) => {
-    const timeDelta = Date.parse(right.startedAt) - Date.parse(left.startedAt);
-    if (timeDelta !== 0) {
-      return timeDelta;
+  return sortSessionsByTimestamp(merged);
+}
+
+function readActiveSessions(repoRoot, options = {}) {
+  const activeSessionsDir = activeSessionsDirForRepo(repoRoot);
+  const now = options.now || Date.now();
+  const sessionFileSessions = [];
+  if (fs.existsSync(activeSessionsDir)) {
+    for (const entry of fs.readdirSync(activeSessionsDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) {
+        continue;
+      }
+
+      const filePath = path.join(activeSessionsDir, entry.name);
+      const parsed = readJsonFile(filePath);
+      const normalized = normalizeSessionRecord(parsed, { filePath });
+      if (!normalized) {
+        continue;
+      }
+      if (!options.includeStale && !isPidAlive(normalized.pid)) {
+        continue;
+      }
+
+      normalized.elapsedLabel = formatElapsedFrom(normalized.startedAt, now);
+      Object.assign(normalized, deriveSessionActivity(normalized, { now }));
+      sessionFileSessions.push(normalized);
     }
-    return left.label.localeCompare(right.label);
-  });
+  }
 
-  return sessions;
+  return mergeSessionSources(
+    sortSessionsByTimestamp(sessionFileSessions),
+    readWorktreeLockSessions(repoRoot, { now }),
+  );
 }
 
 function readRepoChanges(repoRoot) {
@@ -390,6 +783,9 @@ module.exports = {
   activeSessionsDirForRepo,
   buildSessionRecord,
   collectWorktreeChangedPaths,
+  collectWorktreeTrackedPaths,
+  deriveBlockingGitLabel,
+  deriveLatestWorktreeFileActivity,
   deriveSessionLabel,
   deriveSessionActivity,
   formatElapsedFrom,
@@ -399,8 +795,10 @@ module.exports = {
   parseRepoChangeLine,
   previewChangedPaths,
   readActiveSessions,
+  readWorktreeLockSessions,
   readRepoChanges,
   deriveRepoChangeStatus,
+  resolveWorktreeGitDir,
   sanitizeBranchForFile,
   sessionFileNameForBranch,
   sessionFilePathForBranch,