@yemi33/minions 0.1.1712 → 0.1.1714

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.1714 (2026-05-04)
+
+### Features
+- loosen work item create dedupe (#2053)
+- shorten Windows worktree paths (#2051)
+- fix ado project metadata discovery (#2048)
+
 ## 0.1.1712 (2026-05-04)
 
 ### Fixes

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

@@ -29,6 +29,7 @@ const routing = require('./engine/routing');
 const playbook = require('./engine/playbook');
 const dispatchMod = require('./engine/dispatch');
 const steering = require('./engine/steering');
+const projectDiscovery = require('./engine/project-discovery');
 const os = require('os');
 
 const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateControl, mutateCooldowns, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, WORK_TYPE, reopenWorkItem } = shared;
@@ -134,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) {
@@ -180,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;
 }
@@ -210,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;
 }
 
@@ -4854,17 +4875,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return jsonReply(res, 200, { confirmToken: token, ttlMs: PROJECT_CONFIRM_TOKEN_TTL_MS });
   }
 
-  function _execGitInRepo(repoPath, args, timeoutMs) {
-    const { execFileSync } = require('child_process');
-    return execFileSync('git', args, {
-      cwd: repoPath,
-      encoding: 'utf8',
-      timeout: timeoutMs || 5000,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: true,
-    }).trim();
-  }
-
   async function handleProjectsAdd(req, res) {
     try {
       const body = await readBody(req);
@@ -4897,43 +4907,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         return jsonReply(res, 400, { error: 'Project already linked at ' + target });
       }
 
-      // Auto-discover from git repo
-      const detected = { name: path.basename(target), _found: [] };
-      try {
-        let head = '';
-        try { head = _execGitInRepo(target, ['symbolic-ref', 'refs/remotes/origin/HEAD'], 5000); }
-        catch { head = _execGitInRepo(target, ['symbolic-ref', 'HEAD'], 5000); }
-        if (!head) throw new Error('empty git ref');
-        detected.mainBranch = head.replace('refs/remotes/origin/', '').replace('refs/heads/', '');
-      } catch { detected.mainBranch = 'main'; }
-      try {
-        const remoteUrl = _execGitInRepo(target, ['remote', 'get-url', 'origin'], 5000);
-        if (remoteUrl.includes('github.com')) {
-          detected.repoHost = 'github';
-          const m = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-          if (m) { detected.org = m[1]; detected.repoName = m[2]; }
-        } else if (remoteUrl.includes('visualstudio.com') || remoteUrl.includes('dev.azure.com')) {
-          detected.repoHost = 'ado';
-          const m = remoteUrl.match(/https:\/\/([^.]+)\.visualstudio\.com[^/]*\/([^/]+)\/_git\/([^/\s]+)/) ||
-                    remoteUrl.match(/https:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/\s]+)/);
-          if (m) { detected.org = m[1]; detected.project = m[2]; detected.repoName = m[3]; }
-        }
-      } catch (e) { console.error('git remote detection:', e.message); }
-      try {
-        const pkgPath = path.join(target, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-          const pkg = safeJson(pkgPath);
-          if (pkg.name) detected.name = pkg.name.replace(/^@[^/]+\//, '');
-        }
-      } catch { /* optional */ }
-      let description = '';
-      try {
-        const claudeMd = path.join(target, 'CLAUDE.md');
-        if (fs.existsSync(claudeMd)) {
-          const lines = (safeRead(claudeMd) || '').split('\n').filter(l => l.trim() && !l.startsWith('#'));
-          if (lines[0] && lines[0].length < 200) description = lines[0].trim();
-        }
-      } catch { /* optional */ }
+      // Auto-discover from git repo. Shared with minions.js so CLI and dashboard
+      // handle ADO URL variants and repository GUID enrichment consistently.
+      const detected = projectDiscovery.discoverProjectMetadata(target);
+      if (!detected.name) detected.name = path.basename(target);
+      const description = detected.description || '';
 
       const rawName = body.name || detected.name;
 
@@ -4949,17 +4927,18 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         return jsonReply(res, e.statusCode || 400, { error: e.message });
       }
 
-      const prUrlBase = detected.repoHost === 'github'
-        ? (detected.org && detected.repoName ? `https://github.com/${detected.org}/${detected.repoName}/pull/` : '')
-        : (detected.org && detected.project && detected.repoName
-          ? `https://${detected.org}.visualstudio.com/DefaultCollection/${detected.project}/_git/${detected.repoName}/pullrequest/` : '');
-
       const project = {
         name, description, localPath: target.replace(/\\/g, '/'),
-        repoHost: detected.repoHost || 'ado', repositoryId: '',
+        repoHost: detected.repoHost || 'ado', repositoryId: detected.repositoryId || '',
         adoOrg: detected.org || '', adoProject: detected.project || '',
         repoName: detected.repoName || name, mainBranch: detected.mainBranch || 'main',
-        prUrlBase,
+        prUrlBase: projectDiscovery.buildPrUrlBase({
+          repoHost: detected.repoHost,
+          org: detected.org,
+          project: detected.project,
+          repoName: detected.repoName,
+          prUrlBase: detected.prUrlBase,
+        }),
         workSources: { pullRequests: { enabled: true, cooldownMinutes: 30 }, workItems: { enabled: true, cooldownMinutes: 0 } }
       };
 
@@ -5028,20 +5007,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       // Enrich each repo with metadata
       const existingPaths = new Set(PROJECTS.map(p => path.resolve(p.localPath)));
       const results = repos.map(repoPath => {
-        const result = { path: repoPath.replace(/\\/g, '/'), name: path.basename(repoPath), host: 'git', linked: existingPaths.has(path.resolve(repoPath)) };
-        try {
-          const remoteUrl = _execGitInRepo(repoPath, ['remote', 'get-url', 'origin'], 3000);
-          const gh = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-          const ado = remoteUrl.match(/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/\s]+)/) || remoteUrl.match(/([^.]+)\.visualstudio\.com.*?\/([^/]+)\/_git\/([^/\s]+)/);
-          if (gh) { result.host = 'GitHub'; result.org = gh[1]; result.name = gh[2]; }
-          else if (ado) { result.host = 'ADO'; result.org = ado[1]; result.name = ado[3] || ado[2]; }
-        } catch { /* no remote */ }
-        try {
-          const pkg = JSON.parse(fs.readFileSync(path.join(repoPath, 'package.json'), 'utf8'));
-          if (pkg.name) result.name = pkg.name.replace(/@[^/]+\//, '');
-          if (pkg.description) result.description = pkg.description.slice(0, 100);
-        } catch { /* no package.json */ }
-        return result;
+        const detected = projectDiscovery.discoverProjectMetadata(repoPath, { adoLookupTimeoutMs: 5000 });
+        return projectDiscovery.buildScanResult(repoPath, detected, existingPaths.has(path.resolve(repoPath)));
       });
 
       return jsonReply(res, 200, { repos: results });

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-04T17:48:19.949Z"
+  "cachedAt": "2026-05-04T18:45:33.215Z"
 }

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/project-discovery.js

@@ -0,0 +1,377 @@
+/**
+ * Shared project metadata discovery for CLI and dashboard project linking.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync: defaultExecFileSync } = require('child_process');
+
+function decodeUrlSegment(segment) {
+  try { return decodeURIComponent(String(segment || '')); } catch { return String(segment || ''); }
+}
+
+function stripGitSuffix(value) {
+  return String(value || '').replace(/\.git$/i, '');
+}
+
+function encodePathSegment(segment) {
+  return encodeURIComponent(String(segment || '')).replace(/%2F/gi, '/');
+}
+
+function normalizeRemoteForUrl(remoteUrl) {
+  const raw = String(remoteUrl || '').trim();
+  if (/^git@ssh\.dev\.azure\.com:/i.test(raw)) {
+    return raw.replace(/^git@ssh\.dev\.azure\.com:/i, 'ssh://git@ssh.dev.azure.com/');
+  }
+  return raw;
+}
+
+function urlWithoutCredentials(url) {
+  url.username = '';
+  url.password = '';
+  return url;
+}
+
+function sanitizeUrlString(value) {
+  try {
+    const url = urlWithoutCredentials(new URL(normalizeRemoteForUrl(value)));
+    return url.toString().replace(/\/$/, '');
+  } catch {
+    return String(value || '').trim();
+  }
+}
+
+function isAdoRemoteUrl(remoteUrl) {
+  return /(dev\.azure\.com|visualstudio\.com|ssh\.dev\.azure\.com)/i.test(String(remoteUrl || ''));
+}
+
+function adoRemoteFromParts({ url, org, project, repoName, orgUrl, repoPathParts, collection = '' }) {
+  const safeRepo = stripGitSuffix(repoName);
+  const remoteUrl = sanitizeUrlString(`${url.origin}/${repoPathParts.join('/')}`).replace(/\.git$/i, '');
+  return {
+    repoHost: 'ado',
+    org: decodeUrlSegment(org),
+    project: decodeUrlSegment(project),
+    repoName: stripGitSuffix(decodeUrlSegment(safeRepo)),
+    orgUrl,
+    collection,
+    remoteUrl,
+    prUrlBase: deriveAdoPrUrlBase({ repoUrl: remoteUrl, orgUrl, project, repoName: safeRepo }),
+  };
+}
+
+function parseAdoRemoteUrl(remoteUrl) {
+  const raw = String(remoteUrl || '').trim();
+  if (!raw || !isAdoRemoteUrl(raw)) return null;
+
+  let url;
+  try {
+    url = urlWithoutCredentials(new URL(normalizeRemoteForUrl(raw)));
+  } catch {
+    return null;
+  }
+
+  const host = url.hostname.toLowerCase();
+  const encodedParts = url.pathname.split('/').filter(Boolean);
+  const decodedParts = encodedParts.map(decodeUrlSegment);
+
+  if (host === 'dev.azure.com') {
+    const gitIndex = decodedParts.findIndex(p => p.toLowerCase() === '_git');
+    if (gitIndex < 2 || !decodedParts[gitIndex + 1]) return null;
+    const org = decodedParts[0];
+    const project = decodedParts[1];
+    const repoName = decodedParts[gitIndex + 1];
+    return adoRemoteFromParts({
+      url,
+      org,
+      project,
+      repoName,
+      orgUrl: `https://dev.azure.com/${encodePathSegment(org)}`,
+      repoPathParts: encodedParts.slice(0, gitIndex + 2),
+    });
+  }
+
+  if (host.endsWith('.visualstudio.com')) {
+    const org = host.slice(0, -'.visualstudio.com'.length);
+    let offset = 0;
+    let collection = '';
+    if ((decodedParts[0] || '').toLowerCase() === 'defaultcollection') {
+      offset = 1;
+      collection = 'DefaultCollection';
+    }
+    const gitIndex = decodedParts.findIndex((p, i) => i >= offset && p.toLowerCase() === '_git');
+    if (gitIndex < offset + 1 || !decodedParts[gitIndex + 1]) return null;
+    const project = decodedParts[offset];
+    const repoName = decodedParts[gitIndex + 1];
+    const orgUrl = collection
+      ? `https://${org}.visualstudio.com/${collection}`
+      : `https://${org}.visualstudio.com`;
+    return adoRemoteFromParts({
+      url,
+      org,
+      project,
+      repoName,
+      orgUrl,
+      repoPathParts: encodedParts.slice(0, gitIndex + 2),
+      collection,
+    });
+  }
+
+  if (host === 'ssh.dev.azure.com') {
+    if ((decodedParts[0] || '').toLowerCase() !== 'v3' || decodedParts.length < 4) return null;
+    const [, org, project, repoName] = decodedParts;
+    const orgUrl = `https://dev.azure.com/${encodePathSegment(org)}`;
+    return {
+      repoHost: 'ado',
+      org,
+      project,
+      repoName: stripGitSuffix(repoName),
+      orgUrl,
+      collection: '',
+      remoteUrl: `https://dev.azure.com/${encodePathSegment(org)}/${encodePathSegment(project)}/_git/${encodePathSegment(stripGitSuffix(repoName))}`,
+      prUrlBase: deriveAdoPrUrlBase({ orgUrl, project, repoName }),
+    };
+  }
+
+  return null;
+}
+
+function parseGitHubRemoteUrl(remoteUrl) {
+  const raw = String(remoteUrl || '').trim();
+  const match = raw.match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?(?:[#?].*)?$/i);
+  if (!match) return null;
+  return {
+    repoHost: 'github',
+    org: decodeUrlSegment(match[1]),
+    repoName: stripGitSuffix(decodeUrlSegment(match[2])),
+  };
+}
+
+function deriveAdoPrUrlBase({ repoUrl, orgUrl, project, repoName }) {
+  const candidate = sanitizeUrlString(repoUrl || '');
+  if (candidate && /\/_git\//i.test(candidate)) {
+    return `${candidate.replace(/\.git$/i, '').replace(/\/$/, '')}/pullrequest/`;
+  }
+  if (orgUrl && project && repoName) {
+    return `${String(orgUrl).replace(/\/$/, '')}/${encodePathSegment(project)}/_git/${encodePathSegment(stripGitSuffix(repoName))}/pullrequest/`;
+  }
+  return '';
+}
+
+function parseJsonOutput(output) {
+  const text = String(output || '').trim();
+  if (!text) return null;
+  return JSON.parse(text);
+}
+
+function normalizeAzRepoResult(repo, fallback) {
+  if (!repo || typeof repo !== 'object') return null;
+  const repoUrl = repo.webUrl || repo.remoteUrl || fallback.remoteUrl || '';
+  const parsedUrl = parseAdoRemoteUrl(repoUrl);
+  const project = repo.project?.name || parsedUrl?.project || fallback.project || '';
+  const repoName = repo.name || parsedUrl?.repoName || fallback.repoName || '';
+  const org = parsedUrl?.org || fallback.org || '';
+  const orgUrl = parsedUrl?.orgUrl || fallback.orgUrl || '';
+  return {
+    ...fallback,
+    ...(parsedUrl || {}),
+    org,
+    orgUrl,
+    project,
+    repoName,
+    repositoryId: String(repo.id || fallback.repositoryId || '').trim(),
+    remoteUrl: repoUrl || parsedUrl?.remoteUrl || fallback.remoteUrl || '',
+    prUrlBase: deriveAdoPrUrlBase({ repoUrl, orgUrl, project, repoName }) || parsedUrl?.prUrlBase || fallback.prUrlBase || '',
+  };
+}
+
+function runAzJson(execFileSync, args, timeoutMs) {
+  return parseJsonOutput(execFileSync('az', args, {
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    stdio: ['ignore', 'pipe', 'ignore'],
+    windowsHide: true,
+  }));
+}
+
+function resolveAdoRemoteMetadata(remote, options = {}) {
+  if (!remote) return null;
+  const execFileSync = options.execFileSync || defaultExecFileSync;
+  const timeoutMs = options.adoLookupTimeoutMs || 10000;
+  if (options.resolveAdo !== false && remote.orgUrl && remote.project && remote.repoName) {
+    const baseArgs = [
+      'repos', 'show',
+      '--repository', remote.repoName,
+      '--organization', remote.orgUrl,
+      '--project', remote.project,
+      '--output', 'json',
+    ];
+    try {
+      const repo = runAzJson(execFileSync, baseArgs, timeoutMs);
+      const normalized = normalizeAzRepoResult(repo, remote);
+      if (normalized) return normalized;
+    } catch { /* fall back to parsed remote metadata */ }
+
+    try {
+      const repos = runAzJson(execFileSync, [
+        'repos', 'list',
+        '--organization', remote.orgUrl,
+        '--project', remote.project,
+        '--output', 'json',
+      ], timeoutMs);
+      const match = Array.isArray(repos)
+        ? repos.find(repo => {
+          const name = String(repo?.name || '').toLowerCase();
+          const parsed = parseAdoRemoteUrl(repo?.remoteUrl || repo?.webUrl || '');
+          return name === String(remote.repoName || '').toLowerCase()
+            || parsed?.remoteUrl === remote.remoteUrl
+            || parsed?.repoName?.toLowerCase() === String(remote.repoName || '').toLowerCase();
+        })
+        : null;
+      const normalized = normalizeAzRepoResult(match, remote);
+      if (normalized) return normalized;
+    } catch { /* fall back to parsed remote metadata */ }
+  }
+  return { ...remote, repositoryId: remote.repositoryId || '', prUrlBase: remote.prUrlBase || deriveAdoPrUrlBase(remote) };
+}
+
+function execGit(execFileSync, targetDir, args, timeout = 5000) {
+  return String(execFileSync('git', args, {
+    cwd: targetDir,
+    encoding: 'utf8',
+    timeout,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  })).trim();
+}
+
+function discoverProjectMetadata(targetDir, options = {}) {
+  const execFileSync = options.execFileSync || defaultExecFileSync;
+  const result = { _found: [] };
+
+  try {
+    let head = '';
+    try {
+      head = execGit(execFileSync, targetDir, ['symbolic-ref', 'refs/remotes/origin/HEAD']);
+    } catch {
+      head = execGit(execFileSync, targetDir, ['symbolic-ref', 'HEAD']);
+    }
+    const branch = head.replace('refs/remotes/origin/', '').replace('refs/heads/', '');
+    if (branch) {
+      result.mainBranch = branch;
+      result._found.push('main branch');
+    }
+  } catch {}
+
+  try {
+    const remoteUrl = execGit(execFileSync, targetDir, ['remote', 'get-url', 'origin']);
+    const github = parseGitHubRemoteUrl(remoteUrl);
+    if (github) {
+      Object.assign(result, github);
+      result._found.push('GitHub remote');
+    } else {
+      const adoRemote = parseAdoRemoteUrl(remoteUrl);
+      if (adoRemote) {
+        const ado = resolveAdoRemoteMetadata(adoRemote, options);
+        Object.assign(result, ado);
+        result._found.push(ado.repositoryId ? 'Azure DevOps remote + repository metadata' : 'Azure DevOps remote');
+      }
+    }
+  } catch {}
+
+  try {
+    const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+    if (fs.existsSync(claudeMdPath)) {
+      const content = fs.readFileSync(claudeMdPath, 'utf8');
+      const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+      if (lines[0] && lines[0].length < 200) {
+        result.description = lines[0].trim();
+        result._found.push('description from CLAUDE.md');
+      }
+    }
+  } catch {}
+  if (!result.description) {
+    try {
+      const readmePath = path.join(targetDir, 'README.md');
+      if (fs.existsSync(readmePath)) {
+        const content = fs.readFileSync(readmePath, 'utf8').slice(0, 2000);
+        const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('!'));
+        if (lines[0] && lines[0].length < 200) {
+          result.description = lines[0].trim();
+          result._found.push('description from README.md');
+        }
+      }
+    } catch {}
+  }
+
+  try {
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if (pkg.name) {
+        result.name = pkg.name.replace(/^@[^/]+\//, '');
+        result._found.push('name from package.json');
+      }
+      if (!result.description && pkg.description) result.description = String(pkg.description).slice(0, 200);
+    }
+  } catch {}
+
+  return result;
+}
+
+function buildPrUrlBase({ repoHost, org, project, repoName, prUrlBase }) {
+  if (prUrlBase) return prUrlBase;
+  if (repoHost === 'github') {
+    return org && repoName ? `https://github.com/${org}/${repoName}/pull/` : '';
+  }
+  if (repoHost === 'ado' && org && project && repoName) {
+    return `https://dev.azure.com/${org}/${encodePathSegment(project)}/_git/${encodePathSegment(repoName)}/pullrequest/`;
+  }
+  return '';
+}
+
+function buildProjectEntry({ name, description, localPath, repoHost, repositoryId, org, project, repoName, mainBranch, prUrlBase }) {
+  const safeName = (name || 'project').replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 60) || 'project';
+  return {
+    name: safeName,
+    description: description || '',
+    localPath: (localPath || '').replace(/\\/g, '/'),
+    repoHost: repoHost || 'github',
+    repositoryId: repositoryId || '',
+    adoOrg: org || '',
+    adoProject: project || '',
+    repoName: repoName || name,
+    mainBranch: mainBranch || 'main',
+    prUrlBase: buildPrUrlBase({ repoHost, org, project, repoName, prUrlBase }),
+    workSources: {
+      pullRequests: { enabled: true, cooldownMinutes: 30 },
+      workItems: { enabled: true, cooldownMinutes: 0 },
+    },
+  };
+}
+
+function buildScanResult(repoPath, detected = {}, linked = false) {
+  return {
+    path: repoPath.replace(/\\/g, '/'),
+    name: detected.name || detected.repoName || path.basename(repoPath),
+    host: detected.repoHost || 'git',
+    org: detected.org || '',
+    project: detected.project || '',
+    repoName: detected.repoName || path.basename(repoPath),
+    repositoryId: detected.repositoryId || '',
+    mainBranch: detected.mainBranch || 'main',
+    description: detected.description || '',
+    prUrlBase: detected.prUrlBase || '',
+    linked,
+  };
+}
+
+module.exports = {
+  parseAdoRemoteUrl,
+  parseGitHubRemoteUrl,
+  resolveAdoRemoteMetadata,
+  discoverProjectMetadata,
+  buildPrUrlBase,
+  buildProjectEntry,
+  buildScanResult,
+};

package/engine/shared.js

@@ -1479,6 +1479,8 @@ function nextWorkItemId(items, prefix) {
 
 function getAdoOrgBase(project) {
   if (project.prUrlBase) {
+    const devAzure = project.prUrlBase.match(/^(https?:\/\/dev\.azure\.com\/[^/]+)/i);
+    if (devAzure) return devAzure[1];
     const m = project.prUrlBase.match(/^(https?:\/\/[^/]+(?:\/DefaultCollection)?)/);
     if (m) return m[1];
   }
@@ -1700,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
@@ -2659,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/minions.js

@@ -17,6 +17,7 @@ const path = require('path');
 const readline = require('readline');
 const { execSync } = require('child_process');
 const { ENGINE_DEFAULTS, DEFAULT_AGENTS, DEFAULT_CLAUDE } = require('./engine/shared');
+const projectDiscovery = require('./engine/project-discovery');
 
 const MINIONS_HOME = __dirname;
 const CONFIG_PATH = path.join(MINIONS_HOME, 'config.json');
@@ -50,77 +51,7 @@ function ask(q, def) {
 }
 
 function autoDiscover(targetDir) {
-  const result = { _found: [] };
-
-  // 1. Detect main branch from git
-  try {
-    let head = '';
-    try {
-      head = execSync('git symbolic-ref refs/remotes/origin/HEAD', { cwd: targetDir, encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    } catch {
-      head = execSync('git symbolic-ref HEAD', { cwd: targetDir, encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    }
-    const branch = head.replace('refs/remotes/origin/', '').replace('refs/heads/', '');
-    if (branch) { result.mainBranch = branch; result._found.push('main branch'); }
-  } catch {}
-
-  // 2. Detect repo host, org, project, repo name from git remote URL
-  try {
-    const remoteUrl = execSync('git remote get-url origin', { cwd: targetDir, encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    if (remoteUrl.includes('github.com')) {
-      result.repoHost = 'github';
-      // https://github.com/org/repo.git or git@github.com:org/repo.git
-      const m = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-      if (m) { result.org = m[1]; result.repoName = m[2]; }
-      result._found.push('GitHub remote');
-    } else if (remoteUrl.includes('visualstudio.com') || remoteUrl.includes('dev.azure.com')) {
-      result.repoHost = 'ado';
-      // https://org.visualstudio.com/project/_git/repo or https://dev.azure.com/org/project/_git/repo
-      const m1 = remoteUrl.match(/https:\/\/([^.]+)\.visualstudio\.com[^/]*\/([^/]+)\/_git\/([^/\s]+)/);
-      const m2 = remoteUrl.match(/https:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/\s]+)/);
-      const m = m1 || m2;
-      if (m) { result.org = m[1]; result.project = m[2]; result.repoName = m[3]; }
-      result._found.push('Azure DevOps remote');
-    }
-  } catch {}
-
-  // 3. Read description from CLAUDE.md first line or README.md first paragraph
-  try {
-    const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
-    if (fs.existsSync(claudeMdPath)) {
-      const content = fs.readFileSync(claudeMdPath, 'utf8');
-      // Look for a description-like first line or paragraph (skip headings)
-      const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#'));
-      if (lines[0] && lines[0].length < 200) {
-        result.description = lines[0].trim();
-        result._found.push('description from CLAUDE.md');
-      }
-    }
-  } catch {}
-  if (!result.description) {
-    try {
-      const readmePath = path.join(targetDir, 'README.md');
-      if (fs.existsSync(readmePath)) {
-        const content = fs.readFileSync(readmePath, 'utf8').slice(0, 2000);
-        const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('!'));
-        if (lines[0] && lines[0].length < 200) {
-          result.description = lines[0].trim();
-          result._found.push('description from README.md');
-        }
-      }
-    } catch {}
-  }
-
-  // 4. Detect project name
-  try {
-    const pkgPath = path.join(targetDir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.name) { result.name = pkg.name.replace(/^@[^/]+\//, ''); result._found.push('name from package.json'); }
-    }
-  } catch {}
-
-  return result;
+  return projectDiscovery.discoverProjectMetadata(targetDir);
 }
 
 // ─── Shared Helpers (used by both addProject and scanAndAdd) ─────────────────
@@ -149,38 +80,11 @@ function _detectAvailableRuntimes() {
   return found;
 }
 
-function buildPrUrlBase({ repoHost, org, project, repoName }) {
-  if (repoHost === 'github') {
-    return org && repoName ? `https://github.com/${org}/${repoName}/pull/` : '';
-  }
-  if (repoHost === 'ado' && org && project && repoName) {
-    return `https://dev.azure.com/${org}/${project}/_git/${repoName}/pullrequest/`;
-  }
-  return '';
-}
-
-function buildProjectEntry({ name, description, localPath, repoHost, repositoryId, org, project, repoName, mainBranch }) {
-  // Sanitize name for use as directory name in projects/<name>/
-  const safeName = (name || 'project').replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 60) || 'project';
-  return {
-    name: safeName,
-    description: description || '',
-    localPath: (localPath || '').replace(/\\/g, '/'),
-    repoHost: repoHost || 'github',
-    repositoryId: repositoryId || '',
-    adoOrg: org || '',
-    adoProject: project || '',
-    repoName: repoName || name,
-    mainBranch: mainBranch || 'main',
-    prUrlBase: buildPrUrlBase({ repoHost, org, project, repoName }),
-    // Discovery defaults must mirror dashboard.js POST /api/projects — without
-    // these, discoverFromWorkItems / discoverFromPrs silently no-op (the engine
-    // looks healthy but never dispatches anything).
-    workSources: {
-      pullRequests: { enabled: true, cooldownMinutes: 30 },
-      workItems: { enabled: true, cooldownMinutes: 0 },
-    },
-  };
+function buildProjectEntry(opts) {
+  // Discovery defaults must mirror dashboard.js POST /api/projects — without
+  // these, discoverFromWorkItems / discoverFromPrs silently no-op (the engine
+  // looks healthy but never dispatches anything).
+  return projectDiscovery.buildProjectEntry(opts);
 }
 
 
@@ -221,12 +125,15 @@ async function addProject(targetDir) {
   const org = await ask('Organization', detected.org || '');
   const project = await ask('Project', detected.project || '');
   const repoName = await ask('Repo name', detected.repoName || name);
-  const repositoryId = await ask('Repository ID (GUID, optional)', '');
+  const repositoryId = await ask('Repository ID (GUID, optional)', detected.repositoryId || '');
   const mainBranch = await ask('Main branch', detected.mainBranch || 'main');
 
   rl.close();
 
-  config.projects.push(buildProjectEntry({ name, description, localPath: target, repoHost, repositoryId, org, project, repoName, mainBranch }));
+  config.projects.push(buildProjectEntry({
+    name, description, localPath: target, repoHost, repositoryId, org, project, repoName, mainBranch,
+    prUrlBase: detected.prUrlBase,
+  }));
   saveConfig(config);
 
   console.log(`\n  Linked "${name}" (${target})`);
@@ -373,17 +280,7 @@ async function scanAndAdd({ root, depth } = {}) {
   const enriched = repos.map(repoPath => {
     const detected = autoDiscover(repoPath);
     const alreadyLinked = linkedPaths.has(path.resolve(repoPath));
-    return {
-      path: repoPath,
-      name: detected.name || detected.repoName || path.basename(repoPath),
-      host: detected.repoHost || '?',
-      org: detected.org || '',
-      project: detected.project || '',
-      repoName: detected.repoName || path.basename(repoPath),
-      mainBranch: detected.mainBranch || 'main',
-      description: detected.description || '',
-      linked: alreadyLinked,
-    };
+    return projectDiscovery.buildScanResult(repoPath, detected, alreadyLinked);
   });
 
   console.log(`  Found ${enriched.length} git repo(s):\n`);
@@ -449,8 +346,8 @@ async function scanAndAdd({ root, depth } = {}) {
     existingNames.add(name);
     config.projects.push(buildProjectEntry({
       name, description: repo.description, localPath: repo.path,
-      repoHost: repo.host, org: repo.org, project: repo.project,
-      repoName: repo.repoName, mainBranch: repo.mainBranch,
+      repoHost: repo.host, repositoryId: repo.repositoryId, org: repo.org, project: repo.project,
+      repoName: repo.repoName, mainBranch: repo.mainBranch, prUrlBase: repo.prUrlBase,
     }));
     console.log(`  + ${name} (${repo.path})`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1712",
+  "version": "0.1.1714",
   "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"