@yemi33/minions 0.1.2264 → 0.1.2266

package/dashboard.js

@@ -590,6 +590,126 @@ let _prRefVerifierOverride = null;   // test seam
 // (prRef, project) and returns true | false | null.
 function _setPrRefVerifierForTest(fn) { _prRefVerifierOverride = (typeof fn === 'function') ? fn : null; }
 
+// ── Live PR fetch helpers (W-mqtrnp7y00056bc8) ───────────────────────────────
+//
+// When GET /api/prs/:id is called for a PR that is not in the local tracker
+// (e.g. merged before the engine started tracking, or from an unpolled repo),
+// attempt a live fetch from the platform API and return a shaped record with
+// _liveOnly: true. Falls back to the existing 404 when both lookups fail.
+
+const LIVE_PR_FETCH_TIMEOUT_MS = 8000;
+
+// Test seam: when set, replaces the real _fetchLivePrRecord call so unit tests
+// can inject a mock without standing up a real gh CLI or ADO endpoint.
+let _livePrFetchForTest = null;
+function _setLivePrFetchForTest(fn) {
+  _livePrFetchForTest = typeof fn === 'function' ? fn : null;
+}
+
+function _mapGhPrToRecord(ghPr, canonicalId) {
+  const isMerged = !!ghPr.merged_at;
+  const status = isMerged ? 'merged' : ghPr.state === 'closed' ? 'closed' : 'active';
+  return {
+    id: canonicalId,
+    prNumber: ghPr.number,
+    title: (ghPr.title || `PR #${ghPr.number}`).slice(0, 120),
+    agent: (ghPr.user && ghPr.user.login) ? String(ghPr.user.login).toLowerCase() : 'unknown',
+    branch: (ghPr.head && ghPr.head.ref) || '',
+    status,
+    url: ghPr.html_url || '',
+    description: typeof ghPr.body === 'string' ? ghPr.body.slice(0, 500) : '',
+    _liveOnly: true,
+  };
+}
+
+function _mapAdoPrToRecord(adoPr, canonicalId, ref) {
+  const status = adoPr.status === 'completed' ? 'merged'
+    : adoPr.status === 'abandoned' ? 'abandoned'
+    : 'active';
+  const branch = typeof adoPr.sourceRefName === 'string'
+    ? adoPr.sourceRefName.replace(/^refs\/heads\//, '')
+    : '';
+  const author = (adoPr.createdBy && (adoPr.createdBy.uniqueName || adoPr.createdBy.displayName)) || 'unknown';
+  const prUrl = `https://dev.azure.com/${encodeURIComponent(ref.org)}/${encodeURIComponent(ref.project)}/_git/${encodeURIComponent(ref.repo)}/pullrequest/${ref.number}`;
+  return {
+    id: canonicalId,
+    prNumber: adoPr.pullRequestId || ref.number,
+    title: (adoPr.title || `PR #${ref.number}`).slice(0, 120),
+    agent: String(author).toLowerCase(),
+    branch,
+    status,
+    url: prUrl,
+    description: typeof adoPr.description === 'string' ? adoPr.description.slice(0, 500) : '',
+    _liveOnly: true,
+  };
+}
+
+// Exported for unit testing — fetch a PR live from the platform API and return
+// a tracker-shaped record. Returns null when the canonical id is not parseable
+// or the host is unrecognized. Throws on fetch errors so callers can decide
+// whether to log-and-degrade or propagate.
+//
+// opts: test seams only — production callers pass no opts.
+//   _resolveTokenForSlug(slug) → token string or null
+//   _shellSafeGh(args, opts)   → stdout string (argv-form gh CLI)
+//   _adoFetch(url, token)      → parsed JSON object
+//   _adoToken                  → ADO bearer token string (skips ado.getAdoToken())
+async function _fetchLivePrRecord(canonicalId, opts) {
+  const o = opts || {};
+  const parsed = shared.parseCanonicalPrId(canonicalId);
+  if (!parsed) return null; // bare number or unknown format
+  const { scope, prNumber } = parsed;
+  const colonIdx = scope.indexOf(':');
+  const host = scope.slice(0, colonIdx).toLowerCase();
+  const scopeSlug = scope.slice(colonIdx + 1);
+
+  if (host === 'github') {
+    const [owner, repo] = scopeSlug.split('/');
+    if (!owner || !repo) return null;
+    const ghSlug = shared.validateGhSlug(`${owner}/${repo}`);
+    const num = String(prNumber);
+    const resolveToken = o._resolveTokenForSlug || ghToken.resolveTokenForSlug;
+    const token = resolveToken(`${owner}/${repo}`);
+    const ghOpts = { timeout: LIVE_PR_FETCH_TIMEOUT_MS };
+    if (token) ghOpts.env = { ...process.env, GH_TOKEN: token };
+    const shellGh = o._shellSafeGh || shared.shellSafeGh;
+    const raw = await shellGh(['api', `repos/${ghSlug}/pulls/${num}`], ghOpts);
+    const ghPr = JSON.parse(raw);
+    return _mapGhPrToRecord(ghPr, canonicalId);
+  }
+
+  if (host === 'ado') {
+    const segs = scopeSlug.split('/');
+    if (segs.length < 3) return null;
+    const [org, project, repo] = segs;
+    const ref = { host: 'ado', slug: scopeSlug, org, project, repo, number: prNumber, id: canonicalId };
+    const doFetch = o._adoFetch || (async (url, adoToken) => {
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${adoToken}`, 'Content-Type': 'application/json' },
+        signal: AbortSignal.timeout(LIVE_PR_FETCH_TIMEOUT_MS),
+      });
+      if (!res.ok) throw new Error(`ADO API ${res.status}: ${res.statusText}`);
+      const text = await res.text();
+      if (!text || text.trimStart().startsWith('<')) {
+        throw new Error(`ADO returned HTML instead of JSON for ${url.split('?')[0]}`);
+      }
+      return JSON.parse(text);
+    });
+    const adoTok = o._adoToken != null ? o._adoToken : await ado.getAdoToken();
+    if (!adoTok) throw new Error(`Could not acquire ADO token for ${canonicalId}`);
+    const orgBase = `https://dev.azure.com/${encodeURIComponent(org)}`;
+    const projEnc = encodeURIComponent(project);
+    const repoEnc = encodeURIComponent(repo);
+    const adoPr = await doFetch(
+      `${orgBase}/${projEnc}/_apis/git/repositories/${repoEnc}/pullRequests/${prNumber}?api-version=7.1`,
+      adoTok,
+    );
+    return _mapAdoPrToRecord(adoPr, canonicalId, ref);
+  }
+
+  return null; // unknown host
+}
+
 function _findTrackedPrRecord(prRef, project) {
   if (!project) return null;
   try {
@@ -6398,16 +6518,35 @@ const server = http.createServer(async (req, res) => {
 
   // GET /api/prs/<id> — return a single fully-enriched PR record by canonical
   // id (`<host>:<slug>#<number>`) or by bare number (P-79b47b0c). The in-stack
-  // PR modal (renderPrs.openPrDetail) calls this on demand. Always returns the
-  // record exactly as queries.getPullRequests() produces it (no slimming).
+  // PR modal (renderPrs.openPrDetail) calls this on demand. Returns the local
+  // tracker record when found; falls back to a live platform fetch (GitHub REST
+  // or ADO) for PRs that were never added to the tracker. The live record
+  // carries _liveOnly: true so the UI can optionally surface a "start tracking"
+  // offer. Returns {"error":"pr not found"} when both lookups fail.
   async function handlePrsById(req, res, match) {
     try {
       const id = decodeURIComponent(match[1] || '').trim();
       if (!id) return jsonReply(res, 400, { error: 'id required' });
       const prs = queries.getPullRequests();
       const found = prs.find(p => p && (p.id === id || String(p.number) === id));
-      if (!found) return jsonReply(res, 404, { error: 'pr not found' });
-      return jsonReply(res, 200, { pr: found });
+      if (found) return jsonReply(res, 200, { pr: found });
+
+      // Not in local tracker — attempt live fetch from platform API.
+      const liveFetch = _livePrFetchForTest || _fetchLivePrRecord;
+      let liveRecord = null;
+      try {
+        liveRecord = await Promise.race([
+          liveFetch(id),
+          new Promise((_, rej) => {
+            const t = setTimeout(() => rej(new Error(`live PR fetch timed out for ${id}`)), LIVE_PR_FETCH_TIMEOUT_MS + 1000);
+            if (t.unref) t.unref();
+          }),
+        ]);
+      } catch (e) {
+        shared.log('warn', `handlePrsById: live fetch failed for ${id}: ${e.message}`);
+      }
+      if (liveRecord) return jsonReply(res, 200, { pr: liveRecord });
+      return jsonReply(res, 404, { error: 'pr not found' });
     } catch (e) { return jsonReply(res, 500, { error: e.message }); }
   }
 
@@ -14166,6 +14305,8 @@ function _installCrashHandlers() {
 module.exports = {
   getMcpServers,
   _setPrRefVerifierForTest, // issue #246 — inject a fake loose-PR-ref verifier in handler tests
+  _setLivePrFetchForTest,   // W-mqtrnp7y00056bc8 — inject a mock live fetch for unit tests
+  _fetchLivePrRecord,       // W-mqtrnp7y00056bc8 — exported for direct unit testing
   _parseClaudeMcpListLine,
   _parseCopilotMcpListJson,
   _readWorkspaceMcpServers,

package/engine/lifecycle.js

@@ -371,9 +371,19 @@ function checkPlanCompletion(meta, config) {
         return `### ${w.id}: ${(w.title || 'Untitled').replace('Implement: ', '')}\n${criteria ? '**Acceptance Criteria:**\n' + criteria : ''}`;
       }).join('\n\n');
 
-      const prSummary = prs.map(pr =>
-        `- ${pr.id}: ${pr.title || ''} (branch: \`${pr.branch || '?'}\`) ${pr.url || ''}`
-      ).join('\n') || '_No PRs surfaced for this project — verify the worktree directly._';
+      // Supplement the active-PR scan with WI-level _prUrl entries
+      // (e.g. PRs that were merged and left the active filter but had
+      // _prUrl stamped via stampWiPrRef at completion time).
+      const prUrlsAlreadyListed = new Set(prs.map(pr => pr.url).filter(Boolean));
+      const wiPrLines = itemsForProject
+        .filter(w => w._prUrl && !prUrlsAlreadyListed.has(w._prUrl))
+        .map(w => `- ${w._pr || w._prUrl}: (branch: \`${w.branch || '?'}\`) ${w._prUrl}`);
+      const prSummary = [
+        ...prs.map(pr =>
+          `- ${pr.id}: ${pr.title || ''} (branch: \`${pr.branch || '?'}\`) ${pr.url || ''}`
+        ),
+        ...wiPrLines,
+      ].join('\n') || '_No PRs surfaced for this project — verify the worktree directly._';
 
       const sharedBranchNote = isSharedBranch
         ? `\n**Shared-branch plan** — all changes are already on branch \`${plan.feature_branch}\`. Use this branch directly for the E2E PR instead of creating a new \`e2e/\` branch. Check if a PR already exists for this branch before creating one.\n`
@@ -767,6 +777,26 @@ function syncPrdItemStatus(itemId, status, sourcePlan) {
   } catch (err) { log('warn', `PRD status sync: ${err.message}`); }
 }
 
+// W-mqtplpk6001oe6d5 — stamp workItemId back onto the PRD item when its
+// materialised WI completes. dashboard/render-prd.js reads
+// i.workItemId || i._workItemId || i.work_item_id || i.id — writing this
+// field makes the back-reference explicit and avoids relying on id equality.
+function stampPrdItemWorkItemId(itemId, sourcePlan) {
+  if (!itemId || !sourcePlan) return;
+  try {
+    const fpath = path.join(PRD_DIR, sourcePlan);
+    if (!fs.existsSync(fpath)) return;
+    const plan = safeJsonNoRestore(fpath);
+    const feature = plan?.missing_features?.find(f => f.id === itemId);
+    if (!feature || feature.workItemId === itemId) return;
+    mutateJsonFileLocked(fpath, (fresh) => {
+      const f = fresh?.missing_features?.find(x => x.id === itemId);
+      if (f && f.workItemId !== itemId) f.workItemId = itemId;
+      return fresh;
+    }, { skipWriteIfUnchanged: true });
+  } catch (err) { log('warn', `stampPrdItemWorkItemId: ${err.message}`); }
+}
+
 // ─── PRD Backward-Scan Reconciliation (#929, #984) ─────────────────────────
 // Proactive counterpart to syncPrdItemStatus. Scans all active PRDs and:
 // 1. Promotes "missing" items to "updated" when a done work item already exists (#929)
@@ -1363,6 +1393,80 @@ async function _ensurePrEnrollmentForCompletedItem(meta, config) {
   }
 }
 
+// W-mqtplpk6001oe6d5 — stamp _pr/_prUrl/_prNumber onto the WI record at
+// completion time so the PRD-progress view shows the linked PR and
+// enforceVerifyPrContract's fast-path (item._pr || item._prUrl) succeeds
+// without waiting for the next reconcileItemsWithPrs tick.
+function stampWiPrRef(meta, config) {
+  if (!meta || !meta.item || !meta.item.id) return;
+  // No-op when already stamped — preserve any value set by earlier paths.
+  if (meta.item._pr && meta.item._prUrl) return;
+  const itemId = meta.item.id;
+  const projects = (config && Array.isArray(config.projects))
+    ? config.projects : shared.getProjects(config || {});
+
+  // 1. Search each project's pull-requests.json.
+  let found = null;
+  for (const p of projects) {
+    const pr = safeJsonArr(projectPrPath(p)).find(
+      r => Array.isArray(r.prdItems) && r.prdItems.includes(itemId)
+    );
+    if (pr) { found = pr; break; }
+  }
+
+  // 2. Fall back to central pull-requests.json.
+  if (!found) {
+    found = safeJsonArr(path.join(MINIONS_DIR, 'pull-requests.json')).find(
+      r => Array.isArray(r.prdItems) && r.prdItems.includes(itemId)
+    );
+  }
+
+  // 3. Fall back to pr-links index (catches cases where prdItems wasn't
+  //    populated but a pr-links entry links the PR to this WI).
+  if (!found) {
+    const prLinks = getPrLinks();
+    const linkedPrId = Object.keys(prLinks).find(id => (prLinks[id] || []).includes(itemId));
+    if (linkedPrId) {
+      for (const p of projects) {
+        const pr = safeJsonArr(projectPrPath(p)).find(r => r.id === linkedPrId);
+        if (pr) { found = pr; break; }
+      }
+      if (!found) {
+        found = safeJsonArr(path.join(MINIONS_DIR, 'pull-requests.json')).find(r => r.id === linkedPrId);
+      }
+      // Worst case: only the canonical ID is known — at least stamp _pr.
+      if (!found) found = { id: linkedPrId };
+    }
+  }
+
+  if (!found) return;
+
+  const prId = found.id;
+  const prUrl = found.url;
+  const prNumber = found.prNumber ?? found.number ?? null;
+
+  // Stamp the on-disk WI record.
+  const wiPath = resolveWorkItemPath(meta);
+  if (wiPath) {
+    try {
+      mutateWorkItems(wiPath, items => {
+        const wi = items.find(i => i.id === itemId);
+        if (wi && !wi._pr) {
+          if (prId) wi._pr = prId;
+          if (prUrl) wi._prUrl = prUrl;
+          if (prNumber != null) wi._prNumber = prNumber;
+        }
+        return items;
+      });
+    } catch (err) { log('warn', `stampWiPrRef on-disk: ${err.message}`); }
+  }
+
+  // Also update meta.item in-memory so enforceVerifyPrContract fast-path passes.
+  if (!meta.item._pr && prId) meta.item._pr = prId;
+  if (!meta.item._prUrl && prUrl) meta.item._prUrl = prUrl;
+  if (!meta.item._prNumber && prNumber != null) meta.item._prNumber = prNumber;
+}
+
 function isPrAttachmentRequired(type, item, meta = {}) {
   if (!item?.id || item.skipPr) return false;
   // SETUP (W-mpbi6f2q00104957) is implicitly PR-exempt — the type itself
@@ -4933,6 +5037,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     await _ensurePrEnrollmentForCompletedItem(meta, config);
   } catch (err) { log('warn', `PR enrollment back-fill: ${err.message}`); }
 
+  // W-mqtplpk6001oe6d5 — stamp _pr/_prUrl/_prNumber onto WI at completion time.
+  try { stampWiPrRef(meta, config); } catch (err) { log('warn', `stampWiPrRef: ${err.message}`); }
+
   // Structured completion may report PR even when regex didn't find it
   const scHasPr = structuredCompletion && structuredCompletion.pr && structuredCompletion.pr !== 'N/A';
   if (scHasPr && prsCreatedCount === 0) {
@@ -5241,6 +5348,10 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       meta._noopReason = noopRationale.slice(0, 500);
     }
     updateWorkItemStatus(meta, WI_STATUS.DONE, '');
+    // W-mqtplpk6001oe6d5 — back-stamp workItemId onto the PRD item now that WI is done.
+    if (meta.item.sourcePlan) {
+      try { stampPrdItemWorkItemId(meta.item.id, meta.item.sourcePlan); } catch (err) { log('warn', `stampPrdItemWorkItemId: ${err.message}`); }
+    }
     promoteCompletionArtifacts(meta, agentId, dispatchItem.id, structuredCompletion, { resultSummary });
   }
   // Failure retry is handled by completeDispatch in dispatch.js — not duplicated here.
@@ -6084,4 +6195,7 @@ module.exports = {
   // W-mq5uzmc6001d708f — post-hoc PR enrollment for orphan `_pr` pointers.
   enrollPrFromCanonicalId,
   _setEnrollmentGhRunnerForTest,
+  // W-mqtplpk6001oe6d5 — stamp PR ref + workItemId onto WI and PRD item at completion time.
+  stampWiPrRef,
+  stampPrdItemWorkItemId,
 };

package/package.json

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