@harness-engineering/core 0.16.0 → 0.17.1

package/dist/index.mjs

@@ -10058,6 +10058,7 @@ var VALID_STATUSES = /* @__PURE__ */ new Set([
   "blocked"
 ]);
 var EM_DASH = "\u2014";
+var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
 function parseRoadmap(markdown) {
   const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) {
@@ -10068,9 +10069,12 @@ function parseRoadmap(markdown) {
   const body = markdown.slice(fmMatch[0].length);
   const milestonesResult = parseMilestones(body);
   if (!milestonesResult.ok) return milestonesResult;
+  const historyResult = parseAssignmentHistory(body);
+  if (!historyResult.ok) return historyResult;
   return Ok2({
     frontmatter: fmResult.value,
-    milestones: milestonesResult.value
+    milestones: milestonesResult.value,
+    assignmentHistory: historyResult.value
   });
 }
 function parseFrontmatter2(raw) {
@@ -10110,12 +10114,17 @@ function parseMilestones(body) {
   const h2Pattern = /^## (.+)$/gm;
   const h2Matches = [];
   let match;
+  let bodyEnd = body.length;
   while ((match = h2Pattern.exec(body)) !== null) {
+    if (match[1] === "Assignment History") {
+      bodyEnd = match.index;
+      break;
+    }
     h2Matches.push({ heading: match[1], startIndex: match.index, fullMatch: match[0] });
   }
   for (let i = 0; i < h2Matches.length; i++) {
     const h2 = h2Matches[i];
-    const nextStart = i + 1 < h2Matches.length ? h2Matches[i + 1].startIndex : body.length;
+    const nextStart = i + 1 < h2Matches.length ? h2Matches[i + 1].startIndex : bodyEnd;
     const sectionBody = body.slice(h2.startIndex + h2.fullMatch.length, nextStart);
     const isBacklog = h2.heading === "Backlog";
     const milestoneName = isBacklog ? "Backlog" : h2.heading.replace(/^Milestone:\s*/, "");
@@ -10181,15 +10190,60 @@ function parseFeatureFields(name, body) {
   const specRaw = fieldMap.get("Spec") ?? EM_DASH;
   const plans = parseListField(fieldMap, "Plans", "Plan");
   const blockedBy = parseListField(fieldMap, "Blocked by", "Blockers");
+  const assigneeRaw = fieldMap.get("Assignee") ?? EM_DASH;
+  const priorityRaw = fieldMap.get("Priority") ?? EM_DASH;
+  const externalIdRaw = fieldMap.get("External-ID") ?? EM_DASH;
+  if (priorityRaw !== EM_DASH && !VALID_PRIORITIES.has(priorityRaw)) {
+    return Err2(
+      new Error(
+        `Feature "${name}" has invalid priority: "${priorityRaw}". Valid priorities: ${[...VALID_PRIORITIES].join(", ")}`
+      )
+    );
+  }
   return Ok2({
     name,
     status: statusRaw,
     spec: specRaw === EM_DASH ? null : specRaw,
     plans,
     blockedBy,
-    summary: fieldMap.get("Summary") ?? ""
+    summary: fieldMap.get("Summary") ?? "",
+    assignee: assigneeRaw === EM_DASH ? null : assigneeRaw,
+    priority: priorityRaw === EM_DASH ? null : priorityRaw,
+    externalId: externalIdRaw === EM_DASH ? null : externalIdRaw
   });
 }
+function parseAssignmentHistory(body) {
+  const historyMatch = body.match(/^## Assignment History\s*\n/m);
+  if (!historyMatch || historyMatch.index === void 0) return Ok2([]);
+  const historyStart = historyMatch.index + historyMatch[0].length;
+  const rawHistoryBody = body.slice(historyStart);
+  const nextH2 = rawHistoryBody.search(/^## /m);
+  const historyBody = nextH2 === -1 ? rawHistoryBody : rawHistoryBody.slice(0, nextH2);
+  const records = [];
+  const lines = historyBody.split("\n");
+  let pastHeader = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) continue;
+    if (!pastHeader) {
+      if (trimmed.match(/^\|[-\s|]+\|$/)) {
+        pastHeader = true;
+      }
+      continue;
+    }
+    const cells = trimmed.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < 4) continue;
+    const action = cells[2];
+    if (!["assigned", "completed", "unassigned"].includes(action)) continue;
+    records.push({
+      feature: cells[0],
+      assignee: cells[1],
+      action,
+      date: cells[3]
+    });
+  }
+  return Ok2(records);
+}
 
 // src/roadmap/serialize.ts
 var EM_DASH2 = "\u2014";
@@ -10217,6 +10271,10 @@ function serializeRoadmap(roadmap) {
       lines.push(...serializeFeature(feature));
     }
   }
+  if (roadmap.assignmentHistory && roadmap.assignmentHistory.length > 0) {
+    lines.push("");
+    lines.push(...serializeAssignmentHistory(roadmap.assignmentHistory));
+  }
   lines.push("");
   return lines.join("\n");
 }
@@ -10227,7 +10285,7 @@ function serializeFeature(feature) {
   const spec = feature.spec ?? EM_DASH2;
   const plans = feature.plans.length > 0 ? feature.plans.join(", ") : EM_DASH2;
   const blockedBy = feature.blockedBy.length > 0 ? feature.blockedBy.join(", ") : EM_DASH2;
-  return [
+  const lines = [
     `### ${feature.name}`,
     "",
     `- **Status:** ${feature.status}`,
@@ -10236,12 +10294,45 @@ function serializeFeature(feature) {
     `- **Blockers:** ${blockedBy}`,
     `- **Plan:** ${plans}`
   ];
+  const hasExtended = feature.assignee !== null || feature.priority !== null || feature.externalId !== null;
+  if (hasExtended) {
+    lines.push(`- **Assignee:** ${feature.assignee ?? EM_DASH2}`);
+    lines.push(`- **Priority:** ${feature.priority ?? EM_DASH2}`);
+    lines.push(`- **External-ID:** ${feature.externalId ?? EM_DASH2}`);
+  }
+  return lines;
+}
+function serializeAssignmentHistory(records) {
+  const lines = [
+    "## Assignment History",
+    "| Feature | Assignee | Action | Date |",
+    "|---------|----------|--------|------|"
+  ];
+  for (const record of records) {
+    lines.push(`| ${record.feature} | ${record.assignee} | ${record.action} | ${record.date} |`);
+  }
+  return lines;
 }
 
 // src/roadmap/sync.ts
 import * as fs19 from "fs";
 import * as path19 from "path";
 import { Ok as Ok3 } from "@harness-engineering/types";
+
+// src/roadmap/status-rank.ts
+var STATUS_RANK = {
+  backlog: 0,
+  planned: 1,
+  blocked: 1,
+  // lateral to planned — sync can move to/from blocked freely
+  "in-progress": 2,
+  done: 3
+};
+function isRegression(from, to) {
+  return STATUS_RANK[to] < STATUS_RANK[from];
+}
+
+// src/roadmap/sync.ts
 function inferStatus(feature, projectPath, allFeatures) {
   if (feature.blockedBy.length > 0) {
     const blockerNotDone = feature.blockedBy.some((blockerName) => {
@@ -10308,17 +10399,6 @@ function inferStatus(feature, projectPath, allFeatures) {
   if (anyStarted) return "in-progress";
   return null;
 }
-var STATUS_RANK = {
-  backlog: 0,
-  planned: 1,
-  blocked: 1,
-  // lateral to planned — sync can move to/from blocked freely
-  "in-progress": 2,
-  done: 3
-};
-function isRegression(from, to) {
-  return STATUS_RANK[to] < STATUS_RANK[from];
-}
 function syncRoadmap(options) {
   const { projectPath, roadmap, forceSync } = options;
   const allFeatures = roadmap.milestones.flatMap((m) => m.features);
@@ -10349,6 +10429,487 @@ function applySyncChanges(roadmap, changes) {
   roadmap.frontmatter.lastSynced = (/* @__PURE__ */ new Date()).toISOString();
 }
 
+// src/roadmap/tracker-sync.ts
+function resolveReverseStatus(externalStatus, labels, config) {
+  const reverseMap = config.reverseStatusMap;
+  if (!reverseMap) return null;
+  if (reverseMap[externalStatus]) {
+    return reverseMap[externalStatus];
+  }
+  const statusLabels = ["in-progress", "blocked", "planned"];
+  const matchingLabels = labels.filter((l) => statusLabels.includes(l));
+  if (matchingLabels.length === 1) {
+    const compoundKey = `${externalStatus}:${matchingLabels[0]}`;
+    if (reverseMap[compoundKey]) {
+      return reverseMap[compoundKey];
+    }
+  }
+  return null;
+}
+
+// src/roadmap/adapters/github-issues.ts
+import { Ok as Ok4, Err as Err3 } from "@harness-engineering/types";
+function parseExternalId(externalId) {
+  const match = externalId.match(/^github:([^/]+)\/([^#]+)#(\d+)$/);
+  if (!match) return null;
+  return { owner: match[1], repo: match[2], number: parseInt(match[3], 10) };
+}
+function buildExternalId(owner, repo, number) {
+  return `github:${owner}/${repo}#${number}`;
+}
+function labelsForStatus(status, config) {
+  const base = config.labels ?? [];
+  const externalStatus = config.statusMap[status];
+  if (externalStatus === "open" && status !== "backlog") {
+    return [...base, status];
+  }
+  return [...base];
+}
+var RETRY_DEFAULTS = { maxRetries: 5, baseDelayMs: 1e3 };
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function fetchWithRetry(fetchFn, input, init, opts = RETRY_DEFAULTS) {
+  let lastResponse;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    const response = await fetchFn(input, init);
+    if (response.status !== 403 && response.status !== 429) return response;
+    lastResponse = response;
+    if (attempt === opts.maxRetries) break;
+    const retryAfter = response.headers.get("Retry-After");
+    let delayMs;
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      delayMs = isNaN(seconds) ? opts.baseDelayMs : seconds * 1e3;
+    } else {
+      delayMs = opts.baseDelayMs * Math.pow(2, attempt) + Math.random() * 500;
+    }
+    await sleep(delayMs);
+  }
+  return lastResponse;
+}
+var GitHubIssuesSyncAdapter = class {
+  token;
+  config;
+  fetchFn;
+  apiBase;
+  owner;
+  repo;
+  retryOpts;
+  constructor(options) {
+    this.token = options.token;
+    this.config = options.config;
+    this.fetchFn = options.fetchFn ?? globalThis.fetch;
+    this.apiBase = options.apiBase ?? "https://api.github.com";
+    this.retryOpts = {
+      maxRetries: options.maxRetries ?? RETRY_DEFAULTS.maxRetries,
+      baseDelayMs: options.baseDelayMs ?? RETRY_DEFAULTS.baseDelayMs
+    };
+    const repoParts = (options.config.repo ?? "").split("/");
+    if (repoParts.length !== 2 || !repoParts[0] || !repoParts[1]) {
+      throw new Error(`Invalid repo format: "${options.config.repo}". Expected "owner/repo".`);
+    }
+    this.owner = repoParts[0];
+    this.repo = repoParts[1];
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "Content-Type": "application/json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+  }
+  /**
+   * Close an issue if the feature status maps to 'closed'.
+   * GitHub Issues API doesn't accept state on POST — requires a follow-up PATCH.
+   */
+  async closeIfDone(issueNumber, featureStatus) {
+    const externalStatus = this.config.statusMap[featureStatus];
+    if (externalStatus !== "closed") return;
+    await fetchWithRetry(
+      this.fetchFn,
+      `${this.apiBase}/repos/${this.owner}/${this.repo}/issues/${issueNumber}`,
+      { method: "PATCH", headers: this.headers(), body: JSON.stringify({ state: "closed" }) },
+      this.retryOpts
+    );
+  }
+  async createTicket(feature, milestone) {
+    try {
+      const labels = labelsForStatus(feature.status, this.config);
+      const body = [
+        feature.summary,
+        "",
+        `**Milestone:** ${milestone}`,
+        feature.spec ? `**Spec:** ${feature.spec}` : ""
+      ].filter(Boolean).join("\n");
+      const response = await fetchWithRetry(
+        this.fetchFn,
+        `${this.apiBase}/repos/${this.owner}/${this.repo}/issues`,
+        {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({ title: feature.name, body, labels })
+        },
+        this.retryOpts
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        return Err3(new Error(`GitHub API error ${response.status}: ${text}`));
+      }
+      const data = await response.json();
+      const externalId = buildExternalId(this.owner, this.repo, data.number);
+      await this.closeIfDone(data.number, feature.status);
+      return Ok4({ externalId, url: data.html_url });
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async updateTicket(externalId, changes) {
+    try {
+      const parsed = parseExternalId(externalId);
+      if (!parsed) return Err3(new Error(`Invalid externalId format: "${externalId}"`));
+      const patch = {};
+      if (changes.name !== void 0) patch.title = changes.name;
+      if (changes.summary !== void 0) {
+        const body = [changes.summary, "", changes.spec ? `**Spec:** ${changes.spec}` : ""].filter(Boolean).join("\n");
+        patch.body = body;
+      }
+      if (changes.status !== void 0) {
+        const externalStatus = this.config.statusMap[changes.status];
+        patch.state = externalStatus;
+        patch.labels = labelsForStatus(changes.status, this.config);
+      }
+      const response = await fetchWithRetry(
+        this.fetchFn,
+        `${this.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
+        {
+          method: "PATCH",
+          headers: this.headers(),
+          body: JSON.stringify(patch)
+        },
+        this.retryOpts
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        return Err3(new Error(`GitHub API error ${response.status}: ${text}`));
+      }
+      const data = await response.json();
+      return Ok4({ externalId, url: data.html_url });
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async fetchTicketState(externalId) {
+    try {
+      const parsed = parseExternalId(externalId);
+      if (!parsed) return Err3(new Error(`Invalid externalId format: "${externalId}"`));
+      const response = await fetchWithRetry(
+        this.fetchFn,
+        `${this.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
+        {
+          method: "GET",
+          headers: this.headers()
+        },
+        this.retryOpts
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        return Err3(new Error(`GitHub API error ${response.status}: ${text}`));
+      }
+      const data = await response.json();
+      return Ok4({
+        externalId,
+        status: data.state,
+        labels: data.labels.map((l) => l.name),
+        assignee: data.assignee ? `@${data.assignee.login}` : null
+      });
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async fetchAllTickets() {
+    try {
+      const filterLabels = this.config.labels ?? [];
+      const labelsParam = filterLabels.length > 0 ? `&labels=${filterLabels.join(",")}` : "";
+      const tickets = [];
+      let page = 1;
+      const perPage = 100;
+      while (true) {
+        const response = await fetchWithRetry(
+          this.fetchFn,
+          `${this.apiBase}/repos/${this.owner}/${this.repo}/issues?state=all&per_page=${perPage}&page=${page}${labelsParam}`,
+          {
+            method: "GET",
+            headers: this.headers()
+          },
+          this.retryOpts
+        );
+        if (!response.ok) {
+          const text = await response.text();
+          return Err3(new Error(`GitHub API error ${response.status}: ${text}`));
+        }
+        const data = await response.json();
+        const issues = data.filter((d) => !d.pull_request);
+        for (const issue of issues) {
+          tickets.push({
+            externalId: buildExternalId(this.owner, this.repo, issue.number),
+            status: issue.state,
+            labels: issue.labels.map((l) => l.name),
+            assignee: issue.assignee ? `@${issue.assignee.login}` : null
+          });
+        }
+        if (data.length < perPage) break;
+        page++;
+      }
+      return Ok4(tickets);
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async assignTicket(externalId, assignee) {
+    try {
+      const parsed = parseExternalId(externalId);
+      if (!parsed) return Err3(new Error(`Invalid externalId format: "${externalId}"`));
+      const login = assignee.startsWith("@") ? assignee.slice(1) : assignee;
+      const response = await fetchWithRetry(
+        this.fetchFn,
+        `${this.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}/assignees`,
+        {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({ assignees: [login] })
+        },
+        this.retryOpts
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        return Err3(new Error(`GitHub API error ${response.status}: ${text}`));
+      }
+      return Ok4(void 0);
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+};
+
+// src/roadmap/sync-engine.ts
+import * as fs20 from "fs";
+function emptySyncResult() {
+  return { created: [], updated: [], assignmentChanges: [], errors: [] };
+}
+async function syncToExternal(roadmap, adapter, _config) {
+  const result = emptySyncResult();
+  for (const milestone of roadmap.milestones) {
+    for (const feature of milestone.features) {
+      if (!feature.externalId) {
+        const createResult = await adapter.createTicket(feature, milestone.name);
+        if (createResult.ok) {
+          feature.externalId = createResult.value.externalId;
+          result.created.push(createResult.value);
+        } else {
+          result.errors.push({ featureOrId: feature.name, error: createResult.error });
+        }
+      } else {
+        const updateResult = await adapter.updateTicket(feature.externalId, feature);
+        if (updateResult.ok) {
+          result.updated.push(feature.externalId);
+        } else {
+          result.errors.push({ featureOrId: feature.externalId, error: updateResult.error });
+        }
+      }
+    }
+  }
+  return result;
+}
+async function syncFromExternal(roadmap, adapter, config, options) {
+  const result = emptySyncResult();
+  const forceSync = options?.forceSync ?? false;
+  const featureByExternalId = /* @__PURE__ */ new Map();
+  for (const milestone of roadmap.milestones) {
+    for (const feature of milestone.features) {
+      if (feature.externalId) {
+        featureByExternalId.set(feature.externalId, feature);
+      }
+    }
+  }
+  if (featureByExternalId.size === 0) return result;
+  const fetchResult = await adapter.fetchAllTickets();
+  if (!fetchResult.ok) {
+    result.errors.push({ featureOrId: "*", error: fetchResult.error });
+    return result;
+  }
+  for (const ticketState of fetchResult.value) {
+    const feature = featureByExternalId.get(ticketState.externalId);
+    if (!feature) continue;
+    if (ticketState.assignee !== feature.assignee) {
+      result.assignmentChanges.push({
+        feature: feature.name,
+        from: feature.assignee,
+        to: ticketState.assignee
+      });
+      feature.assignee = ticketState.assignee;
+    }
+    const resolvedStatus = resolveReverseStatus(ticketState.status, ticketState.labels, config);
+    if (resolvedStatus && resolvedStatus !== feature.status) {
+      const newStatus = resolvedStatus;
+      if (!forceSync && isRegression(feature.status, newStatus)) {
+        continue;
+      }
+      feature.status = newStatus;
+    }
+  }
+  return result;
+}
+var syncMutex = Promise.resolve();
+async function fullSync(roadmapPath, adapter, config, options) {
+  const previousSync = syncMutex;
+  let releaseMutex;
+  syncMutex = new Promise((resolve5) => {
+    releaseMutex = resolve5;
+  });
+  await previousSync;
+  try {
+    const raw = fs20.readFileSync(roadmapPath, "utf-8");
+    const parseResult = parseRoadmap(raw);
+    if (!parseResult.ok) {
+      return {
+        ...emptySyncResult(),
+        errors: [{ featureOrId: "*", error: parseResult.error }]
+      };
+    }
+    const roadmap = parseResult.value;
+    const pushResult = await syncToExternal(roadmap, adapter, config);
+    const pullResult = await syncFromExternal(roadmap, adapter, config, options);
+    fs20.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    return {
+      created: pushResult.created,
+      updated: pushResult.updated,
+      assignmentChanges: pullResult.assignmentChanges,
+      errors: [...pushResult.errors, ...pullResult.errors]
+    };
+  } finally {
+    releaseMutex();
+  }
+}
+
+// src/roadmap/pilot-scoring.ts
+var PRIORITY_RANK = {
+  P0: 0,
+  P1: 1,
+  P2: 2,
+  P3: 3
+};
+var POSITION_WEIGHT = 0.5;
+var DEPENDENTS_WEIGHT = 0.3;
+var AFFINITY_WEIGHT = 0.2;
+function scoreRoadmapCandidates(roadmap, options) {
+  const allFeatures = roadmap.milestones.flatMap((m) => m.features);
+  const allFeatureNames = new Set(allFeatures.map((f) => f.name.toLowerCase()));
+  const doneFeatures = new Set(
+    allFeatures.filter((f) => f.status === "done").map((f) => f.name.toLowerCase())
+  );
+  const dependentsCount = /* @__PURE__ */ new Map();
+  for (const feature of allFeatures) {
+    for (const blocker of feature.blockedBy) {
+      const key = blocker.toLowerCase();
+      dependentsCount.set(key, (dependentsCount.get(key) ?? 0) + 1);
+    }
+  }
+  const maxDependents = Math.max(1, ...dependentsCount.values());
+  const milestoneMap = /* @__PURE__ */ new Map();
+  for (const ms of roadmap.milestones) {
+    milestoneMap.set(
+      ms.name,
+      ms.features.map((f) => f.name.toLowerCase())
+    );
+  }
+  const userCompletedFeatures = /* @__PURE__ */ new Set();
+  if (options?.currentUser) {
+    const user = options.currentUser.toLowerCase();
+    for (const record of roadmap.assignmentHistory) {
+      if (record.action === "completed" && record.assignee.toLowerCase() === user) {
+        userCompletedFeatures.add(record.feature.toLowerCase());
+      }
+    }
+  }
+  let totalPositions = 0;
+  for (const ms of roadmap.milestones) {
+    totalPositions += ms.features.length;
+  }
+  totalPositions = Math.max(1, totalPositions);
+  const candidates = [];
+  let globalPosition = 0;
+  for (const ms of roadmap.milestones) {
+    for (let featureIdx = 0; featureIdx < ms.features.length; featureIdx++) {
+      const feature = ms.features[featureIdx];
+      globalPosition++;
+      if (feature.status !== "planned" && feature.status !== "backlog") continue;
+      const isBlocked = feature.blockedBy.some((blocker) => {
+        const key = blocker.toLowerCase();
+        return allFeatureNames.has(key) && !doneFeatures.has(key);
+      });
+      if (isBlocked) continue;
+      const positionScore = 1 - (globalPosition - 1) / totalPositions;
+      const deps = dependentsCount.get(feature.name.toLowerCase()) ?? 0;
+      const dependentsScore = deps / maxDependents;
+      let affinityScore = 0;
+      if (userCompletedFeatures.size > 0) {
+        const completedBlockers = feature.blockedBy.filter(
+          (b) => userCompletedFeatures.has(b.toLowerCase())
+        );
+        if (completedBlockers.length > 0) {
+          affinityScore = 1;
+        } else {
+          const siblings = milestoneMap.get(ms.name) ?? [];
+          const completedSiblings = siblings.filter((s) => userCompletedFeatures.has(s));
+          if (completedSiblings.length > 0) {
+            affinityScore = 0.5;
+          }
+        }
+      }
+      const weightedScore = POSITION_WEIGHT * positionScore + DEPENDENTS_WEIGHT * dependentsScore + AFFINITY_WEIGHT * affinityScore;
+      const priorityTier = feature.priority ? PRIORITY_RANK[feature.priority] : null;
+      candidates.push({
+        feature,
+        milestone: ms.name,
+        positionScore,
+        dependentsScore,
+        affinityScore,
+        weightedScore,
+        priorityTier
+      });
+    }
+  }
+  candidates.sort((a, b) => {
+    if (a.priorityTier !== null && b.priorityTier === null) return -1;
+    if (a.priorityTier === null && b.priorityTier !== null) return 1;
+    if (a.priorityTier !== null && b.priorityTier !== null) {
+      if (a.priorityTier !== b.priorityTier) return a.priorityTier - b.priorityTier;
+    }
+    return b.weightedScore - a.weightedScore;
+  });
+  return candidates;
+}
+function assignFeature(roadmap, feature, assignee, date) {
+  if (feature.assignee === assignee) return;
+  if (feature.assignee !== null) {
+    roadmap.assignmentHistory.push({
+      feature: feature.name,
+      assignee: feature.assignee,
+      action: "unassigned",
+      date
+    });
+  }
+  feature.assignee = assignee;
+  roadmap.assignmentHistory.push({
+    feature: feature.name,
+    assignee,
+    action: "assigned",
+    date
+  });
+}
+
 // src/interaction/types.ts
 import { z as z7 } from "zod";
 var InteractionTypeSchema = z7.enum(["question", "confirmation", "transition"]);
@@ -10379,17 +10940,18 @@ var EmitInteractionInputSchema = z7.object({
 });
 
 // src/blueprint/scanner.ts
-import * as fs20 from "fs/promises";
+import * as fs21 from "fs/promises";
 import * as path20 from "path";
 var ProjectScanner = class {
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
+  rootDir;
   async scan() {
     let projectName = path20.basename(this.rootDir);
     try {
       const pkgPath = path20.join(this.rootDir, "package.json");
-      const pkgRaw = await fs20.readFile(pkgPath, "utf-8");
+      const pkgRaw = await fs21.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.name) projectName = pkg.name;
     } catch {
@@ -10430,7 +10992,7 @@ var ProjectScanner = class {
 };
 
 // src/blueprint/generator.ts
-import * as fs21 from "fs/promises";
+import * as fs22 from "fs/promises";
 import * as path21 from "path";
 import * as ejs from "ejs";
 
@@ -10515,13 +11077,13 @@ var BlueprintGenerator = class {
       styles: STYLES,
       scripts: SCRIPTS
     });
-    await fs21.mkdir(options.outputDir, { recursive: true });
-    await fs21.writeFile(path21.join(options.outputDir, "index.html"), html);
+    await fs22.mkdir(options.outputDir, { recursive: true });
+    await fs22.writeFile(path21.join(options.outputDir, "index.html"), html);
   }
 };
 
 // src/update-checker.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as path22 from "path";
 import * as os from "os";
 import { spawn } from "child_process";
@@ -10540,7 +11102,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs22.readFileSync(getStatePath(), "utf-8");
+    const raw = fs23.readFileSync(getStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "lastCheckTime" in parsed && typeof parsed.lastCheckTime === "number" && "currentVersion" in parsed && typeof parsed.currentVersion === "string") {
       const state = parsed;
@@ -11052,7 +11614,7 @@ function getModelPrice(model, dataset) {
 }
 
 // src/pricing/cache.ts
-import * as fs23 from "fs/promises";
+import * as fs24 from "fs/promises";
 import * as path23 from "path";
 
 // src/pricing/fallback.json
@@ -11113,7 +11675,7 @@ function getStalenessMarkerPath(projectRoot) {
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs23.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs24.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -11121,8 +11683,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs23.mkdir(path23.dirname(cachePath), { recursive: true });
-  await fs23.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs24.mkdir(path23.dirname(cachePath), { recursive: true });
+  await fs24.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -11149,7 +11711,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs23.readFile(markerPath, "utf-8");
+    const raw = await fs24.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -11161,8 +11723,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs23.mkdir(path23.dirname(markerPath), { recursive: true });
-      await fs23.writeFile(
+      await fs24.mkdir(path23.dirname(markerPath), { recursive: true });
+      await fs24.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -11172,7 +11734,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs23.unlink(getStalenessMarkerPath(projectRoot));
+    await fs24.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -11342,7 +11904,7 @@ function aggregateByDay(records) {
 }
 
 // src/usage/jsonl-reader.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as path24 from "path";
 function parseLine(line, lineNumber) {
   let entry;
@@ -11385,7 +11947,7 @@ function readCostRecords(projectRoot) {
   const costsFile = path24.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs24.readFileSync(costsFile, "utf-8");
+    raw = fs25.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -11403,7 +11965,7 @@ function readCostRecords(projectRoot) {
 }
 
 // src/usage/cc-parser.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as path25 from "path";
 import * as os2 from "os";
 function extractUsage(entry) {
@@ -11451,7 +12013,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs25.readFileSync(filePath, "utf-8");
+    raw = fs26.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -11476,7 +12038,7 @@ function parseCCRecords() {
   const projectsDir = path25.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs25.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path25.join(projectsDir, d.name));
+    projectDirs = fs26.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path25.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -11484,7 +12046,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs25.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path25.join(dir, f));
+      files = fs26.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path25.join(dir, f));
     } catch {
       continue;
     }
@@ -11542,6 +12104,7 @@ export {
   ForbiddenImportCollector,
   GateConfigSchema,
   GateResultSchema,
+  GitHubIssuesSyncAdapter,
   HandoffSchema,
   HarnessStateSchema,
   InteractionTypeSchema,
@@ -11563,6 +12126,7 @@ export {
   RuleRegistry,
   SECURITY_DESCRIPTOR,
   STALENESS_WARNING_DAYS,
+  STATUS_RANK,
   SecurityConfigSchema,
   SecurityScanner,
   SharableBoundaryConfigSchema,
@@ -11596,6 +12160,7 @@ export {
   archiveLearnings,
   archiveSession,
   archiveStream,
+  assignFeature,
   buildDependencyGraph,
   buildExclusionSet,
   buildSnapshot,
@@ -11660,6 +12225,7 @@ export {
   formatGitHubSummary,
   formatOutline,
   formatTerminalOutput,
+  fullSync,
   generateAgentsMap,
   generateSuggestions,
   getActionEmitter,
@@ -11677,6 +12243,7 @@ export {
   injectionRules,
   insecureDefaultsRules,
   isDuplicateFinding,
+  isRegression,
   isSmallSuggestion,
   isUpdateCheckEnabled,
   listActiveSessions,
@@ -11730,6 +12297,7 @@ export {
   resetParserCache,
   resolveFileToLayer,
   resolveModelTier,
+  resolveReverseStatus,
   resolveRuleSeverity,
   resolveSessionDir,
   resolveStreamPath,
@@ -11750,6 +12318,7 @@ export {
   saveStreamIndex,
   scanForInjection,
   scopeContext,
+  scoreRoadmapCandidates,
   searchSymbols,
   secretRules,
   serializeRoadmap,
@@ -11758,7 +12327,9 @@ export {
   shouldRunCheck,
   spawnBackgroundCheck,
   syncConstraintNodes,
+  syncFromExternal,
   syncRoadmap,
+  syncToExternal,
   tagUncitedFindings,
   touchStream,
   trackAction,