@yemi33/minions 0.1.1713 → 0.1.1715

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1715 (2026-05-04)
+
+### Features
+- auto-repair ADO project metadata (#2052)
+
 ## 0.1.1713 (2026-05-04)
 
 ### Features

package/README.md

@@ -541,7 +541,7 @@ Engine behavior is controlled via `config.json`. Key settings:
 | `inboxConsolidateThreshold` | 5 | Inbox files needed before consolidation |
 | `worktreeCreateTimeout` | 300000 (5min) | Timeout for each `git worktree add` attempt |
 | `worktreeCreateRetries` | 1 | Retry count for transient `git worktree add` failures (0-3) |
-| `worktreeRoot` | `../worktrees` | Where git worktrees are created |
+| `worktreeRoot` | `../worktrees` | Where git worktrees are created; may be absolute, and Windows users should prefer a short root such as `C:\wt` |
 | `idleAlertMinutes` | 15 | Alert after no dispatch for this many minutes |
 | `restartGracePeriod` | 1200000 (20min) | Grace period for agent re-attachment after engine restart |
 | `shutdownTimeout` | 300000 (5min) | Max wait for active agents during graceful shutdown (SIGTERM/SIGINT) |

package/dashboard/js/settings.js

@@ -75,7 +75,7 @@ async function openSettings() {
       settingsField('Heartbeat Timeout', 'set-heartbeatTimeout', e.heartbeatTimeout || 300000, 'ms', 'No output = dead after this') +
       settingsField('Worktree Create Timeout', 'set-worktreeCreateTimeout', e.worktreeCreateTimeout || 300000, 'ms', 'Timeout for git worktree add (increase for large repos/Windows)') +
       settingsField('Worktree Create Retries', 'set-worktreeCreateRetries', e.worktreeCreateRetries || 1, '', 'Retry count for transient worktree add failures (0-3)') +
-      settingsField('Worktree Root', 'set-worktreeRoot', e.worktreeRoot || '../worktrees', '', 'Relative path for git worktrees') +
+      settingsField('Worktree Root', 'set-worktreeRoot', e.worktreeRoot || '../worktrees', '', 'Relative or absolute path for git worktrees; on Windows prefer a short path like C:\\wt') +
       settingsField('Idle Alert', 'set-idleAlertMinutes', e.idleAlertMinutes || 15, 'min', 'Alert after agent idle this long') +
       settingsField('Shutdown Timeout', 'set-shutdownTimeout', e.shutdownTimeout || 300000, 'ms', 'Max wait for agents during graceful shutdown') +
       settingsField('Restart Grace Period', 'set-restartGracePeriod', e.restartGracePeriod || 1200000, 'ms', 'Grace period before orphan detection on restart') +

package/dashboard.js

@@ -135,6 +135,12 @@ function normalizeWorkItemDedupText(value) {
     .trim();
 }
 
+function normalizeWorkItemDedupTitle(value) {
+  return normalizeWorkItemDedupText(value)
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+}
+
 function resolveWorkItemDedupProject(item, wiPath = '') {
   const projectName = normalizeWorkItemDedupText(item?.project || item?._project || item?._source);
   if (projectName) {
@@ -181,15 +187,30 @@ function normalizeWorkItemDedupPrIdentity(item, project = null) {
 function workItemCreateFingerprint(item, options = {}) {
   const project = resolveWorkItemDedupProject(item, options.wiPath);
   return {
-    title: normalizeWorkItemDedupText(item?.title),
+    title: normalizeWorkItemDedupTitle(item?.title),
     type: routing.normalizeWorkType(item?.type || item?.workType, WORK_TYPE.IMPLEMENT),
-    priority: normalizeWorkItemDedupText(item?.priority || 'medium').toLowerCase(),
-    description: normalizeWorkItemDedupText(item?.description),
+    source: normalizeWorkItemDedupText(project?.name || item?.project || item?._project || item?._source).toLowerCase(),
     scope: normalizeWorkItemDedupText(item?.scope).toLowerCase(),
     prIdentity: normalizeWorkItemDedupPrIdentity(item, project),
   };
 }
 
+function isCompatibleWorkItemCreateScope(existingFingerprint, candidateFingerprint) {
+  const existingFanOut = existingFingerprint.scope === 'fan-out';
+  const candidateFanOut = candidateFingerprint.scope === 'fan-out';
+  if (existingFanOut || candidateFanOut) {
+    return existingFingerprint.scope === candidateFingerprint.scope;
+  }
+  return true;
+}
+
+function isCompatibleWorkItemCreatePrIdentity(existingFingerprint, candidateFingerprint) {
+  if (existingFingerprint.prIdentity || candidateFingerprint.prIdentity) {
+    return existingFingerprint.prIdentity === candidateFingerprint.prIdentity;
+  }
+  return true;
+}
+
 function isActiveWorkItemCreateStatus(status) {
   return status === WI_STATUS.PENDING || status === WI_STATUS.DISPATCHED || status === WI_STATUS.QUEUED;
 }
@@ -211,10 +232,9 @@ function findDuplicateWorkItemCreate(items, candidate, options = {}) {
     const existingFingerprint = workItemCreateFingerprint(item, options);
     return existingFingerprint.title === candidateFingerprint.title &&
       existingFingerprint.type === candidateFingerprint.type &&
-      existingFingerprint.priority === candidateFingerprint.priority &&
-      existingFingerprint.description === candidateFingerprint.description &&
-      existingFingerprint.scope === candidateFingerprint.scope &&
-      existingFingerprint.prIdentity === candidateFingerprint.prIdentity;
+      existingFingerprint.source === candidateFingerprint.source &&
+      isCompatibleWorkItemCreateScope(existingFingerprint, candidateFingerprint) &&
+      isCompatibleWorkItemCreatePrIdentity(existingFingerprint, candidateFingerprint);
   }) || null;
 }
 

package/engine/ado.js

@@ -4,6 +4,7 @@
  */
 
 const path = require('path');
+const childProcess = require('child_process');
 const shared = require('./shared');
 const { exec, execAsync, getAdoOrgBase, log, ts, dateStamp, PR_STATUS, createThrottleTracker } = shared;
 const { getPrs } = require('./queries');
@@ -74,6 +75,207 @@ function sameAdoProject(a, b) {
     && String(a.repoHost || 'ado').toLowerCase() === String(b.repoHost || 'ado').toLowerCase();
 }
 
+function decodeUrlSegment(segment) {
+  try { return decodeURIComponent(segment); } catch { return segment; }
+}
+
+function stripGitSuffix(value) {
+  return String(value || '').trim().replace(/\.git$/i, '');
+}
+
+function encodeAdoPathSegment(value) {
+  return encodeURIComponent(String(value || '').trim());
+}
+
+function buildAdoPrUrlBase(meta) {
+  const repo = meta.repoName || meta.repositoryId || '';
+  if (!meta.adoOrg || !meta.adoProject || !repo) return '';
+  if (meta.host === 'visualstudio') {
+    const collection = meta.defaultCollection ? 'DefaultCollection/' : '';
+    return `https://${meta.adoOrg}.visualstudio.com/${collection}${encodeAdoPathSegment(meta.adoProject)}/_git/${encodeAdoPathSegment(repo)}/pullrequest/`;
+  }
+  return `https://dev.azure.com/${encodeAdoPathSegment(meta.adoOrg)}/${encodeAdoPathSegment(meta.adoProject)}/_git/${encodeAdoPathSegment(repo)}/pullrequest/`;
+}
+
+function adoRepoCandidateFromParts(parts, source) {
+  const repo = stripGitSuffix(decodeUrlSegment(parts.repo || ''));
+  const repositoryId = isAdoGuid(repo) ? repo : '';
+  const repoName = repositoryId ? '' : repo;
+  const candidate = {
+    adoOrg: decodeUrlSegment(parts.org || '').trim(),
+    adoProject: decodeUrlSegment(parts.project || '').trim(),
+    repoName,
+    repositoryId,
+    host: parts.host || 'dev.azure',
+    defaultCollection: parts.defaultCollection === true,
+    source,
+  };
+  candidate.prUrlBase = buildAdoPrUrlBase(candidate);
+  return candidate;
+}
+
+function parseAdoRepoMetadata(value, source) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+
+  const devAzure = raw.match(/https?:\/\/(?:[^/@]+@)?dev\.azure\.com\/([^/?#]+)\/([^/?#]+)\/_git\/([^/?#\s]+)/i);
+  if (devAzure) {
+    return adoRepoCandidateFromParts({
+      host: 'dev.azure',
+      org: devAzure[1],
+      project: devAzure[2],
+      repo: devAzure[3],
+    }, source);
+  }
+
+  const visualStudio = raw.match(/https?:\/\/(?:[^/@]+@)?([^/.@]+)\.visualstudio\.com\/(?:(DefaultCollection)\/)?([^/?#]+)\/_git\/([^/?#\s]+)/i);
+  if (visualStudio) {
+    return adoRepoCandidateFromParts({
+      host: 'visualstudio',
+      defaultCollection: !!visualStudio[2],
+      org: visualStudio[1],
+      project: visualStudio[3],
+      repo: visualStudio[4],
+    }, source);
+  }
+
+  const ssh = raw.match(/^(?:ssh:\/\/)?git@ssh\.dev\.azure\.com(?::|\/)v3\/([^/]+)\/([^/]+)\/([^/\s]+)$/i);
+  if (ssh) {
+    return adoRepoCandidateFromParts({
+      host: 'dev.azure',
+      org: ssh[1],
+      project: ssh[2],
+      repo: ssh[3],
+    }, source);
+  }
+
+  return null;
+}
+
+function parseCanonicalAdoPrId(value, source) {
+  const match = String(value || '').trim().match(/^ado:([^/#]+)\/([^/#]+)\/([^/#]+)#\d+$/i);
+  if (!match) return null;
+  return adoRepoCandidateFromParts({
+    host: 'dev.azure',
+    org: match[1],
+    project: match[2],
+    repo: match[3],
+  }, source);
+}
+
+function normalizeAdoOrgForCompare(value) {
+  return String(value || '').trim().toLowerCase().replace(/\.visualstudio\.com$/i, '');
+}
+
+function normalizeAdoFieldForCompare(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function isAdoRepairCandidateCompatible(project, candidate) {
+  if (!project || !candidate) return false;
+  if (project.adoOrg && candidate.adoOrg
+    && normalizeAdoOrgForCompare(project.adoOrg) !== normalizeAdoOrgForCompare(candidate.adoOrg)) return false;
+  if (project.adoProject && candidate.adoProject
+    && normalizeAdoFieldForCompare(project.adoProject) !== normalizeAdoFieldForCompare(candidate.adoProject)) return false;
+  if (project.repoName && candidate.repoName
+    && normalizeAdoFieldForCompare(project.repoName) !== normalizeAdoFieldForCompare(candidate.repoName)) return false;
+  if (project.repositoryId && candidate.repositoryId
+    && normalizeAdoFieldForCompare(project.repositoryId) !== normalizeAdoFieldForCompare(candidate.repositoryId)) return false;
+  return true;
+}
+
+function getMissingAdoProjectConfigFields(project) {
+  return ['adoOrg', 'adoProject', 'repoName', 'prUrlBase', 'repositoryId']
+    .filter(field => !String(project?.[field] || '').trim());
+}
+
+function getOriginRemoteUrl(project) {
+  const localPath = String(project?.localPath || '').trim();
+  if (!localPath) return '';
+  try {
+    const result = childProcess.spawnSync('git', ['-C', localPath, 'config', '--get', 'remote.origin.url'], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 3000,
+    });
+    if (result.status !== 0) return '';
+    return String(result.stdout || '').trim().split(/\r?\n/)[0] || '';
+  } catch {
+    return '';
+  }
+}
+
+function collectAdoRepairCandidates(project, prs = []) {
+  const candidates = [];
+  const add = (candidate) => {
+    if (candidate && isAdoRepairCandidateCompatible(project, candidate)) candidates.push(candidate);
+  };
+
+  if (project?.prUrlBase) add(parseAdoRepoMetadata(project.prUrlBase, 'configured prUrlBase'));
+  add(parseAdoRepoMetadata(getOriginRemoteUrl(project), 'origin remote'));
+
+  for (const pr of Array.isArray(prs) ? prs : []) {
+    add(parseAdoRepoMetadata(pr?.url, 'tracked PR URL'));
+    add(parseCanonicalAdoPrId(pr?.id, 'tracked canonical PR ID'));
+  }
+
+  return candidates;
+}
+
+function persistAdoProjectRepair(project, repairs, source) {
+  Object.assign(project, repairs);
+
+  try {
+    let persisted = false;
+    mutateJsonFileLocked(adoConfigPath(), (config) => {
+      if (!config || typeof config !== 'object' || Array.isArray(config)) return config;
+      if (!Array.isArray(config.projects)) return config;
+      const target = config.projects.find(p => sameAdoProject(p, project));
+      if (!target) return config;
+      for (const [field, value] of Object.entries(repairs)) {
+        if (!String(target[field] || '').trim()) target[field] = value;
+      }
+      persisted = true;
+      return config;
+    }, { defaultValue: { projects: [] }, skipWriteIfUnchanged: true });
+    const repairedFields = Object.keys(repairs).join(', ');
+    if (persisted) {
+      log('info', `Auto-repaired ADO project config for ${getAdoProjectLabel(project)} from ${source}: ${repairedFields}`);
+    } else {
+      log('warn', `Auto-repaired ADO project config for ${getAdoProjectLabel(project)} from ${source} in memory but could not find the project in config.json to persist it`);
+    }
+  } catch (e) {
+    log('warn', `Auto-repaired ADO project config for ${getAdoProjectLabel(project)} but failed to persist it: ${e.message}`);
+  }
+}
+
+function repairAdoProjectConfig(project, purpose, prs = null) {
+  if (!project || isGitHubProject(project)) return false;
+  const missingBefore = getMissingAdoProjectConfigFields(project);
+  if (missingBefore.length === 0) return false;
+
+  const trackedPrs = prs || shared.safeJson(shared.projectPrPath(project)) || [];
+  for (const candidate of collectAdoRepairCandidates(project, trackedPrs)) {
+    const repairs = {};
+    if (!project.adoOrg && candidate.adoOrg) repairs.adoOrg = candidate.adoOrg;
+    if (!project.adoProject && candidate.adoProject) repairs.adoProject = candidate.adoProject;
+    if (!project.repoName && candidate.repoName) repairs.repoName = candidate.repoName;
+    if (!project.repositoryId && candidate.repositoryId) repairs.repositoryId = candidate.repositoryId;
+    if (!project.prUrlBase && candidate.prUrlBase) repairs.prUrlBase = candidate.prUrlBase;
+    if (Object.keys(repairs).length > 0) {
+      persistAdoProjectRepair(project, repairs, candidate.source);
+      return true;
+    }
+  }
+
+  const missingAfter = getMissingAdoProjectConfigFields(project)
+    .filter(field => field !== 'repositoryId' || !project.repoName);
+  if (missingAfter.some(field => field === 'adoOrg' || field === 'adoProject' || field === 'repoName')) {
+    log('warn', `${purpose} cannot auto-repair ADO project config for ${getAdoProjectLabel(project)}: missing ${missingAfter.map(f => `project.${f}`).join(', ')} and no trusted origin remote, tracked PR URL, or canonical ADO PR ID supplied enough metadata`);
+  }
+  return false;
+}
+
 function persistAdoRepositoryGuid(project, guid, repoName) {
   if (!isAdoGuid(guid)) return;
   const previous = String(project?.repositoryId || '').trim();
@@ -387,6 +589,7 @@ async function forEachActivePr(config, token, callback) {
 
   for (const project of projects) {
     if (isGitHubProject(project)) continue;
+    repairAdoProjectConfig(project, 'ADO PR polling');
     if (!project.adoOrg || !project.adoProject) continue;
 
     const prs = getPrs(project);
@@ -870,6 +1073,7 @@ async function reconcilePrs(config) {
 
   for (const project of projects) {
     if (isGitHubProject(project)) continue;
+    repairAdoProjectConfig(project, 'ADO PR reconciliation');
     if (!project.adoOrg || !project.adoProject) continue;
     const adoRepositoryId = getAdoRepositoryId(project);
     if (!adoRepositoryId) {
@@ -1020,6 +1224,8 @@ async function reconcilePrs(config) {
  */
 async function checkLiveReviewStatus(pr, project) {
   try {
+    repairAdoProjectConfig(project, 'ADO live review check', pr ? [pr] : null);
+    if (!project.adoOrg || !project.adoProject) return null;
     const token = await getAdoToken();
     if (!token) return null;
     const orgBase = shared.getAdoOrgBase(project);
@@ -1066,6 +1272,8 @@ async function checkLiveReviewStatus(pr, project) {
  */
 async function checkLiveBuildAndConflict(pr, project) {
   try {
+    repairAdoProjectConfig(project, 'ADO live build/conflict check', pr ? [pr] : null);
+    if (!project.adoOrg || !project.adoProject) return null;
     const token = await getAdoToken();
     if (!token) return null;
     const orgBase = shared.getAdoOrgBase(project);
@@ -1163,6 +1371,9 @@ async function fetchAdoPrMetadata(prNum, adoOrg, adoProj, adoRepo) {
  *           mergeConflict, url, project } or null on auth failure.
  */
 async function fetchSinglePrBuildStatus(project, prNumber) {
+  repairAdoProjectConfig(project, 'ADO single PR status fetch');
+  if (!project.adoOrg || !project.adoProject) return null;
+
   const token = await getAdoToken();
   if (!token) return null;
 
@@ -1261,6 +1472,7 @@ const getAdoThrottleState = () => _adoThrottle.getState();
  * @returns {{ prNumber: number, url: string }|null}
  */
 async function findOpenPrOnBranch(project, branch) {
+  repairAdoProjectConfig(project, 'ADO branch PR lookup');
   if (!project.adoOrg || !project.adoProject || !branch) return null;
   const adoRepositoryId = getAdoRepositoryId(project);
   if (!adoRepositoryId) {

package/engine/cleanup.js

@@ -39,6 +39,23 @@ function worktreeDirMatchesBranch(dirLower, branch) {
   return dirLower === branchSlug || dirLower.includes(branchSlug + '-') || dirLower.endsWith('-' + branchSlug);
 }
 
+function worktreeBranchMatches(actualBranch, branch) {
+  if (!actualBranch || !branch) return false;
+  return sanitizeBranch(actualBranch).toLowerCase() === sanitizeBranch(branch).toLowerCase();
+}
+
+function worktreeMatchesBranch(dirLower, branch, actualBranch = '') {
+  return worktreeBranchMatches(actualBranch, branch) || worktreeDirMatchesBranch(dirLower, branch);
+}
+
+function getWorktreeBranch(wtPath) {
+  try {
+    return exec(`git -C "${wtPath}" branch --show-current`, { encoding: 'utf8', stdio: 'pipe', timeout: 5000, windowsHide: true }).trim();
+  } catch {
+    return '';
+  }
+}
+
 let _orphanPidProcessNamesCache = null;
 function _orphanPidProcessNames() {
   if (_orphanPidProcessNamesCache) return _orphanPidProcessNamesCache;
@@ -235,12 +252,13 @@ function runCleanup(config, verbose = false) {
 
         let shouldClean = false;
         let isProtected = false;
+        const actualBranch = getWorktreeBranch(wtPath);
 
         // Check if this worktree's branch is merged/abandoned
-        // Use sanitized exact match on the branch portion of the dir name (format: {slug}-{branch}-{suffix})
+        // Prefer actual git branch metadata; compact Windows dirs intentionally omit branch names.
         const dirLower = dir.toLowerCase();
         for (const branch of mergedBranches) {
-          if (worktreeDirMatchesBranch(dirLower, branch)) {
+          if (worktreeMatchesBranch(dirLower, branch, actualBranch)) {
             shouldClean = true;
             break;
           }
@@ -249,8 +267,7 @@ function runCleanup(config, verbose = false) {
         // Check if referenced by active/pending dispatch (use sanitized branch comparison)
         const isReferenced = [...dispatch.pending, ...(dispatch.active || [])].some(d => {
           if (!d.meta?.branch) return false;
-          const dispBranch = sanitizeBranch(d.meta.branch).toLowerCase();
-          return dirLower.includes(dispBranch);
+          return worktreeMatchesBranch(dirLower, d.meta.branch, actualBranch);
         });
         if (isReferenced) isProtected = true;
 
@@ -275,8 +292,7 @@ function runCleanup(config, verbose = false) {
               for (const pf of fs.readdirSync(checkDir).filter(f => f.endsWith('.json'))) {
                 const plan = safeJson(path.join(checkDir, pf));
                 if (plan?.branch_strategy === 'shared-branch' && plan?.feature_branch && plan?.status !== 'completed') {
-                  const planBranch = sanitizeBranch(plan.feature_branch).toLowerCase();
-                  if (dirLower.includes(planBranch)) {
+                  if (worktreeMatchesBranch(dirLower, plan.feature_branch, actualBranch)) {
                     isProtected = true;
                     if (shouldClean) {
                       shouldClean = false;
@@ -291,7 +307,7 @@ function runCleanup(config, verbose = false) {
           } catch (e) { log('warn', 'check shared-branch protection: ' + e.message); }
         }
 
-        wtEntries.push({ dir, wtPath, mtime, shouldClean, isProtected });
+        wtEntries.push({ dir, wtPath, mtime, shouldClean, isProtected, actualBranch });
       }
 
       // Enforce max worktree cap — if over limit, mark oldest unprotected for cleanup
@@ -323,7 +339,7 @@ function runCleanup(config, verbose = false) {
           const entryDirLower = entry.dir.toLowerCase();
           let stillMerged = false;
           for (const branch of freshMergedBranches) {
-            if (worktreeDirMatchesBranch(entryDirLower, branch)) {
+            if (worktreeMatchesBranch(entryDirLower, branch, entry.actualBranch)) {
               stillMerged = true;
               break;
             }
@@ -331,7 +347,7 @@ function runCleanup(config, verbose = false) {
           // If originally marked due to merged branch but PR was reopened, skip deletion
           if (!stillMerged) {
             // Check if it was marked for age/cap cleanup (not branch-based) — those are still valid
-            const wasMarkedByBranch = [...mergedBranches].some(branch => worktreeDirMatchesBranch(entryDirLower, branch));
+            const wasMarkedByBranch = [...mergedBranches].some(branch => worktreeMatchesBranch(entryDirLower, branch, entry.actualBranch));
             if (wasMarkedByBranch) {
               if (verbose) console.log(`  Skipping worktree ${entry.dir}: PR was reopened since initial check`);
               log('info', `Worktree deletion skipped — PR reopened: ${entry.dir}`);
@@ -832,4 +848,6 @@ module.exports = {
   runCleanup,
   scrubStaleMetrics,
   worktreeDirMatchesBranch,  // exported for testing
+  worktreeMatchesBranch,     // exported for testing
+  getWorktreeBranch,         // exported for lifecycle cleanup
 };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T18:44:26.581Z"
+  "cachedAt": "2026-05-04T18:47:12.870Z"
 }

package/engine/lifecycle.js

@@ -14,7 +14,7 @@ const { trackEngineUsage } = require('./llm');
 const { resolveRuntime } = require('./runtimes');
 const queries = require('./queries');
 const { isBranchActive } = require('./cooldown');
-const { worktreeDirMatchesBranch } = require('./cleanup');
+const { worktreeMatchesBranch, getWorktreeBranch } = require('./cleanup');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
   MINIONS_DIR, ENGINE_DIR, PLANS_DIR, PRD_DIR, INBOX_DIR, AGENTS_DIR } = queries;
 
@@ -446,10 +446,12 @@ function cleanupPlanWorktrees(planFile, plan, projects, config) {
       if (!fs.existsSync(wtRoot)) continue;
       const dirs = fs.readdirSync(wtRoot);
       for (const dir of dirs) {
+        const wtPath = path.join(wtRoot, dir);
         const dirLower = dir.toLowerCase();
-        const matches = [...branchSlugs].some(slug => dirLower.includes(slug));
+        const actualBranch = getWorktreeBranch(wtPath);
+        const actualBranchSlug = actualBranch ? shared.sanitizeBranch(actualBranch).toLowerCase() : '';
+        const matches = [...branchSlugs].some(slug => dirLower.includes(slug) || actualBranchSlug === slug);
         if (matches) {
-          const wtPath = path.join(wtRoot, dir);
           if (shared.removeWorktree(wtPath, root, wtRoot)) cleanedWt++;
         }
       }
@@ -1587,13 +1589,13 @@ async function handlePostMerge(pr, project, config, newStatus) {
   if (pr.branch && project) {
     const root = path.resolve(project.localPath);
     const wtRoot = path.resolve(root, config.engine?.worktreeRoot || '../worktrees');
-    // Find worktrees matching this branch — dir format is {slug}-{branch}-{suffix}
+    // Find worktrees matching this branch; compact Windows dirs require branch metadata.
     try {
       const dirs = require('fs').readdirSync(wtRoot);
       for (const dir of dirs) {
+        const wtPath = path.join(wtRoot, dir);
         const dirLower = dir.toLowerCase();
-        if (worktreeDirMatchesBranch(dirLower, pr.branch) || dir === pr.branch || dir === `bt-${prNum}`) {
-          const wtPath = path.join(wtRoot, dir);
+        if (worktreeMatchesBranch(dirLower, pr.branch, getWorktreeBranch(wtPath)) || dir === pr.branch || dir === `bt-${prNum}`) {
           try {
             if (!require('fs').statSync(wtPath).isDirectory()) continue;
             execSilent(`git worktree remove "${wtPath}" --force`, { cwd: root, stdio: 'pipe', timeout: 15000 });
@@ -2724,7 +2726,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         // Find the worktree directory for this dispatch's branch
         const branchSlug = shared.sanitizeBranch ? shared.sanitizeBranch(meta.branch) : meta.branch.replace(/[^a-zA-Z0-9._\-\/]/g, '-');
         const dirs = fs.readdirSync(worktreeRoot).filter(d => {
-          return worktreeDirMatchesBranch(d.toLowerCase(), meta.branch) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
+          const wtPath = path.join(worktreeRoot, d);
+          return fs.statSync(wtPath).isDirectory()
+            && worktreeMatchesBranch(d.toLowerCase(), meta.branch, getWorktreeBranch(wtPath));
         });
         // Only remove if no other active dispatch uses this branch
         const dispatch = getDispatch();

package/engine/shared.js

@@ -1702,6 +1702,28 @@ function sanitizeBranch(name) {
   return String(name).replace(/[^a-zA-Z0-9._\-\/]/g, '-').slice(0, 200);
 }
 
+function _worktreeNameSuffix(dispatchId, projectName, branchName) {
+  const id = String(dispatchId || '').split('-').filter(Boolean).pop();
+  if (id) return safeSlugComponent(id, 32);
+  const hash = crypto.createHash('sha1')
+    .update(`${projectName || 'default'}\n${branchName || 'worktree'}`)
+    .digest('hex')
+    .slice(0, 12);
+  return hash;
+}
+
+function buildWorktreeDirName({
+  dispatchId = '',
+  projectName = 'default',
+  branchName = 'worktree',
+  platform = process.platform,
+} = {}) {
+  const suffix = _worktreeNameSuffix(dispatchId, projectName, branchName);
+  if (platform === 'win32') return `W-${suffix}`;
+  const projectSlug = String(projectName || 'default').replace(/[^a-zA-Z0-9_-]/g, '-');
+  return `${projectSlug}-${sanitizeBranch(branchName || 'worktree')}-${suffix}`;
+}
+
 // ── HTTP Origin Allowlist & Security Headers ─────────────────────────────────
 // Pure helpers used by dashboard.js to gate mutating requests against an
 // explicit allowlist of local origins and to attach uniform security response
@@ -2661,6 +2683,7 @@ module.exports = {
   getAdoOrgBase,
   sanitizePath,
   sanitizeBranch,
+  buildWorktreeDirName, // exported for testing
   isLiveCommandCenterPath,
   describeCcProtectedPaths,
   renderCcSystemPrompt,

package/engine.js

@@ -513,9 +513,11 @@ async function spawnAgent(dispatchItem, config) {
 
   if (branchName) {
     updateAgentStatus(id, AGENT_STATUS.WORKTREE_SETUP, `Setting up worktree for branch ${branchName}`);
-    const wtSuffix = id ? id.split('-').pop() : shared.uid();
-    const projectSlug = (project.name || 'default').replace(/[^a-zA-Z0-9_-]/g, '-');
-    const wtDirName = `${projectSlug}-${branchName}-${wtSuffix}`;
+    const wtDirName = shared.buildWorktreeDirName({
+      dispatchId: id,
+      projectName: project.name || 'default',
+      branchName,
+    });
     worktreePath = path.resolve(rootDir, engineConfig.worktreeRoot || '../worktrees', wtDirName);
 
     // If branch is already checked out in an existing worktree, reuse it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1713",
+  "version": "0.1.1715",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"