@slope-dev/slope 1.64.1 → 2.0.0

package/dist/core/roadmap.js

@@ -1,5 +1,6 @@
 // SLOPE — Roadmap: Strategic planning types and compute functions
 // Course-level methodology — vision → roadmap → review → iteration
+import { compareSprintIdKeys, parseSprintId, sprintIdKey } from './sprint-id.js';
 /** Return true for legacy encoded inserted half-sprint ids like 435 => S43.5.
  *  Decimal roadmap ids such as 75.5 are already explicit and are left as-is.
  *  The encoding is intentionally limited to pre-S100-style three-digit ids
@@ -19,6 +20,8 @@ export function sprintOrderValue(id) {
 }
 /** Format the numeric portion of a sprint id for human-facing output. */
 export function formatSprintNumber(id) {
+    if (typeof id === 'string')
+        return sprintIdKey(id) ?? id;
     if (isEncodedInsertedSprintId(id)) {
         return `${Math.floor(id / 10)}.${id % 10}`;
     }
@@ -91,13 +94,13 @@ export function compareSprintIds(a, b) {
 }
 /** Return the next canonical sprint id after a completed sprint/inserted sprint. */
 export function nextCanonicalSprintId(id) {
-    if (isEncodedInsertedSprintId(id)) {
-        return Math.floor(id / 10) + 1;
-    }
-    if (!Number.isInteger(id)) {
-        return Math.floor(id) + 1;
+    if (typeof id === 'number' && isEncodedInsertedSprintId(id)) {
+        return String(Math.floor(id / 10) + 1);
     }
-    return id + 1;
+    const parsed = parseSprintId(id);
+    if (!parsed)
+        return '1';
+    return String(parsed.base + 1);
 }
 export const ROADMAP_TERMINAL_STATUSES = new Set([
     'complete',
@@ -169,13 +172,31 @@ export function isEncodedInsertedSprintInRoadmap(roadmap, id) {
     return sprintIds.has(base) || sprintIds.has(base + 1);
 }
 export function roadmapSprintOrderValue(roadmap, id) {
-    return isEncodedInsertedSprintInRoadmap(roadmap, id) ? sprintOrderValue(id) : id;
+    const key = roadmapSprintKeyFromId(roadmap, id);
+    const parsed = key ? parseSprintId(key) : null;
+    if (!parsed)
+        return typeof id === 'number' ? id : Number(id);
+    if (parsed.insert === null)
+        return parsed.base;
+    return parsed.base + parsed.insert / (10 ** parsed.insertDigits.length);
 }
 export function compareRoadmapSprintIds(roadmap, a, b) {
-    return roadmapSprintOrderValue(roadmap, a) - roadmapSprintOrderValue(roadmap, b);
+    const ka = roadmapSprintKeyFromId(roadmap, a) ?? String(a);
+    const kb = roadmapSprintKeyFromId(roadmap, b) ?? String(b);
+    return compareSprintIdKeys(ka, kb);
+}
+function areAdjacentSprintKeys(previousKey, currentKey) {
+    const previous = parseSprintId(previousKey);
+    const current = parseSprintId(currentKey);
+    if (!previous || !current)
+        return false;
+    if (previous.base === current.base) {
+        return current.insert !== null && compareSprintIdKeys(previousKey, currentKey) < 0;
+    }
+    return current.base === previous.base + 1 && current.insert === null;
 }
 export function formatRoadmapSprintLabel(roadmap, id) {
-    return isEncodedInsertedSprintInRoadmap(roadmap, id) ? formatSprintLabel(id) : `S${id}`;
+    return `S${roadmapSprintKeyFromId(roadmap, id) ?? id}`;
 }
 /**
  * Canonical string identity for a sprint: the authored `id_key` when present
@@ -190,6 +211,24 @@ export function roadmapSprintKey(roadmap, sprint) {
         ? formatSprintNumber(sprint.id)
         : String(sprint.id);
 }
+/** Resolve a canonical sprint key from either a key or a legacy numeric mirror. */
+export function roadmapSprintKeyFromId(roadmap, id) {
+    const inputKey = sprintIdKey(id);
+    if (inputKey === null)
+        return null;
+    const canonical = roadmap.sprints.find(sprint => roadmapSprintKey(roadmap, sprint) === inputKey);
+    if (canonical)
+        return roadmapSprintKey(roadmap, canonical);
+    const mirror = roadmap.sprints.find(sprint => sprint.id === Number(inputKey));
+    return mirror ? roadmapSprintKey(roadmap, mirror) : inputKey;
+}
+/** Find one roadmap sprint by canonical key, with numeric mirrors as legacy input. */
+export function findRoadmapSprint(roadmap, id) {
+    const key = roadmapSprintKeyFromId(roadmap, id);
+    return key == null
+        ? undefined
+        : roadmap.sprints.find(sprint => roadmapSprintKey(roadmap, sprint) === key);
+}
 /** Validate a roadmap definition for structural correctness.
  *  Optionally cross-check sprint status against scorecards and/or shipped
  *  sprint commits on main when provided. Caller is responsible for collecting
@@ -198,8 +237,7 @@ export function roadmapSprintKey(roadmap, sprint) {
 export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
     const errors = [];
     const warnings = [];
-    const sprintIds = new Set(roadmap.sprints.map(s => s.id));
-    const orderOf = (id) => roadmapSprintOrderValue(roadmap, id);
+    const sprintIds = new Set(roadmap.sprints.map(s => roadmapSprintKey(roadmap, s)));
     const labelOf = (id) => formatRoadmapSprintLabel(roadmap, id);
     // Canonical identity so 458.10 and 458.1 are distinct sprints with distinct
     // ticket-key prefixes (GH #635).
@@ -210,12 +248,9 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
         return { valid: false, errors, warnings };
     }
     // Check: sprint numbering continuity
-    const sortedIds = [...sprintIds].sort((a, b) => orderOf(a) - orderOf(b));
+    const sortedIds = [...sprintIds].sort((a, b) => compareSprintIdKeys(a, b));
     for (let i = 1; i < sortedIds.length; i++) {
-        const prev = orderOf(sortedIds[i - 1]);
-        const current = orderOf(sortedIds[i]);
-        const allowedInsertedStep = current > prev && current <= Math.floor(prev) + 1;
-        if (!allowedInsertedStep && current !== prev + 1) {
+        if (!areAdjacentSprintKeys(sortedIds[i - 1], sortedIds[i])) {
             // A long-lived roadmap legitimately skips numbers as sprints are
             // absorbed, cancelled, or renumbered, so a numbering discontinuity is
             // informational rather than a structural error. Genuinely-structural
@@ -236,19 +271,20 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
     // Build a set of all ticket keys across all sprints for cross-sprint dependency validation
     const allTicketKeys = new Set(roadmap.sprints.flatMap(s => s.tickets.map(getRoadmapTicketKey).filter((key) => key !== null)));
     for (const sprint of roadmap.sprints) {
+        const sprintKey = roadmapSprintKey(roadmap, sprint);
         // Check: ticket count (3-4 per sprint)
         if (sprint.tickets.length < 3) {
             warnings.push({
                 type: 'warning',
-                sprint: sprint.id,
-                message: `${labelOf(sprint.id)} has ${sprint.tickets.length} tickets (recommended 3-4)`,
+                sprint: sprintKey,
+                message: `${keyLabelOf(sprint)} has ${sprint.tickets.length} tickets (recommended 3-4)`,
             });
         }
         if (sprint.tickets.length > 4) {
             warnings.push({
                 type: 'warning',
-                sprint: sprint.id,
-                message: `${labelOf(sprint.id)} has ${sprint.tickets.length} tickets (recommended 3-4)`,
+                sprint: sprintKey,
+                message: `${keyLabelOf(sprint)} has ${sprint.tickets.length} tickets (recommended 3-4)`,
             });
         }
         // Check: ticket key format matches sprint
@@ -258,15 +294,15 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
             if (!ticketKey) {
                 errors.push({
                     type: 'error',
-                    sprint: sprint.id,
-                    message: `Ticket in ${labelOf(sprint.id)} is missing key/id`,
+                    sprint: sprintKey,
+                    message: `Ticket in ${keyLabelOf(sprint)} is missing key/id`,
                 });
                 continue;
             }
             if (!ticketKey.startsWith(expected)) {
                 errors.push({
                     type: 'error',
-                    sprint: sprint.id,
+                    sprint: sprintKey,
                     ticket: ticketKey,
                     message: `Ticket ${ticketKey} does not match sprint ${keyLabelOf(sprint)} (expected prefix ${expected})`,
                 });
@@ -281,7 +317,7 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
                 if (!allTicketKeys.has(dep)) {
                     errors.push({
                         type: 'error',
-                        sprint: sprint.id,
+                        sprint: sprintKey,
                         ticket: ticketKey,
                         message: `Ticket ${ticketKey} depends on ${dep} which does not exist in the roadmap`,
                     });
@@ -290,11 +326,12 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
         }
         // Check: sprint dependencies exist
         for (const dep of sprint.depends_on ?? []) {
-            if (!sprintIds.has(dep)) {
+            const depKey = roadmapSprintKeyFromId(roadmap, dep);
+            if (depKey === null || !sprintIds.has(depKey)) {
                 errors.push({
                     type: 'error',
-                    sprint: sprint.id,
-                    message: `${labelOf(sprint.id)} depends on ${labelOf(dep)} which does not exist in the roadmap`,
+                    sprint: sprintKey,
+                    message: `${labelOf(roadmapSprintKey(roadmap, sprint))} depends on ${labelOf(dep)} which does not exist in the roadmap`,
                 });
             }
         }
@@ -302,8 +339,8 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
         if (sprint.par < 3 || sprint.par > 5) {
             errors.push({
                 type: 'error',
-                sprint: sprint.id,
-                message: `${labelOf(sprint.id)} has invalid par ${sprint.par} (must be 3, 4, or 5)`,
+                sprint: sprintKey,
+                message: `${keyLabelOf(sprint)} has invalid par ${sprint.par} (must be 3, 4, or 5)`,
             });
         }
     }
@@ -317,8 +354,10 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
     }
     // Check: phases reference valid sprint IDs
     for (const phase of roadmap.phases) {
-        for (const sid of phase.sprints) {
-            if (!sprintIds.has(sid)) {
+        const phaseSprintIds = phase.sprint_keys ?? phase.sprints;
+        for (const sid of phaseSprintIds) {
+            const sidKey = roadmapSprintKeyFromId(roadmap, sid);
+            if (sidKey === null || !sprintIds.has(sidKey)) {
                 errors.push({
                     type: 'error',
                     message: `Phase "${phase.name}" references ${labelOf(sid)} which does not exist`,
@@ -328,22 +367,22 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
     }
     // Cross-validate sprint status against scorecards when provided
     if (scorecards) {
-        const scorecardSprintIds = new Set(scorecards.map(s => s.sprint_number));
+        const scorecardSprintIds = new Set(scorecards.map(s => roadmapSprintKeyFromId(roadmap, s.sprint_number)));
         for (const sprint of roadmap.sprints) {
-            const hasScorecard = scorecardSprintIds.has(sprint.id);
+            const hasScorecard = scorecardSprintIds.has(roadmapSprintKey(roadmap, sprint));
             const status = sprint.status;
             if (hasScorecard && status !== 'complete') {
                 warnings.push({
                     type: 'warning',
-                    sprint: sprint.id,
-                    message: `${labelOf(sprint.id)} has a scorecard but roadmap status is "${status ?? 'planned'}" — expected "complete"`,
+                    sprint: roadmapSprintKey(roadmap, sprint),
+                    message: `${keyLabelOf(sprint)} has a scorecard but roadmap status is "${status ?? 'planned'}" — expected "complete"`,
                 });
             }
             if (!hasScorecard && status === 'complete') {
                 warnings.push({
                     type: 'warning',
-                    sprint: sprint.id,
-                    message: `${labelOf(sprint.id)} is marked "complete" in roadmap but no scorecard exists (phantom sprint)`,
+                    sprint: roadmapSprintKey(roadmap, sprint),
+                    message: `${keyLabelOf(sprint)} is marked "complete" in roadmap but no scorecard exists (phantom sprint)`,
                 });
             }
         }
@@ -355,21 +394,25 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
         // bookkeeping, not a feature ship). Treat those terminal-but-not-complete
         // statuses as final rather than demanding "complete".
         const TERMINAL_NOT_COMPLETE = new Set(['superseded', 'skipped', 'cancelled', 'cancelled-absorbed', 'absorbed']);
+        const shippedSprintKeys = new Set([...shippedSprintIds]
+            .map(id => roadmapSprintKeyFromId(roadmap, id))
+            .filter((id) => id !== null));
         for (const sprint of roadmap.sprints) {
             const status = sprint.status;
-            const isShipped = shippedSprintIds.has(sprint.id);
+            const key = roadmapSprintKey(roadmap, sprint);
+            const isShipped = shippedSprintKeys.has(key);
             if (isShipped && status !== 'complete' && !TERMINAL_NOT_COMPLETE.has(status ?? '')) {
                 errors.push({
                     type: 'error',
-                    sprint: sprint.id,
-                    message: `${labelOf(sprint.id)} has shipped commits on main but status is "${status ?? 'planned'}" — expected "complete"`,
+                    sprint: key,
+                    message: `${keyLabelOf(sprint)} has shipped commits on main but status is "${status ?? 'planned'}" — expected "complete"`,
                 });
             }
             if (!isShipped && status === 'complete') {
                 warnings.push({
                     type: 'warning',
-                    sprint: sprint.id,
-                    message: `${labelOf(sprint.id)} is marked "complete" but no shipped commits found on main`,
+                    sprint: key,
+                    message: `${keyLabelOf(sprint)} is marked "complete" but no shipped commits found on main`,
                 });
             }
         }
@@ -379,29 +422,34 @@ export function validateRoadmap(roadmap, scorecards, shippedSprintIds) {
 // --- Dependency Graph ---
 /** Detect cycles in sprint dependency graph. Returns cycle path or null. */
 function detectCycle(sprints) {
+    const roadmap = { name: '', phases: [], sprints };
+    const sprintMap = new Map(sprints.map(sprint => [roadmapSprintKey(roadmap, sprint), sprint]));
     const visited = new Set();
     const inStack = new Set();
     const parent = new Map();
     function dfs(id) {
         visited.add(id);
         inStack.add(id);
-        const sprint = sprints.find(s => s.id === id);
+        const sprint = sprintMap.get(id);
         for (const dep of sprint?.depends_on ?? []) {
-            if (!visited.has(dep)) {
-                parent.set(dep, id);
-                const result = dfs(dep);
+            const depKey = roadmapSprintKeyFromId(roadmap, dep);
+            if (depKey === null)
+                continue;
+            if (!visited.has(depKey)) {
+                parent.set(depKey, id);
+                const result = dfs(depKey);
                 if (result)
                     return result;
             }
-            else if (inStack.has(dep)) {
+            else if (inStack.has(depKey)) {
                 // Build cycle path
-                const cycle = [dep];
+                const cycle = [depKey];
                 let current = id;
-                while (current !== dep) {
+                while (current !== depKey) {
                     cycle.push(current);
                     current = parent.get(current);
                 }
-                cycle.push(dep);
+                cycle.push(depKey);
                 return cycle.reverse();
             }
         }
@@ -409,8 +457,9 @@ function detectCycle(sprints) {
         return null;
     }
     for (const sprint of sprints) {
-        if (!visited.has(sprint.id)) {
-            const result = dfs(sprint.id);
+        const key = roadmapSprintKey(roadmap, sprint);
+        if (!visited.has(key)) {
+            const result = dfs(key);
             if (result)
                 return result;
         }
@@ -419,7 +468,7 @@ function detectCycle(sprints) {
 }
 /** Compute the critical path (longest dependency chain) through the roadmap */
 export function computeCriticalPath(roadmap) {
-    const sprintMap = new Map(roadmap.sprints.map(s => [s.id, s]));
+    const sprintMap = new Map(roadmap.sprints.map(s => [roadmapSprintKey(roadmap, s), s]));
     // Compute longest path ending at each sprint via topological order
     const longestTo = new Map();
     // Topological sort
@@ -433,7 +482,8 @@ export function computeCriticalPath(roadmap) {
         else {
             let best = { length: 0, path: [] };
             for (const dep of deps) {
-                const depPath = longestTo.get(dep);
+                const depKey = roadmapSprintKeyFromId(roadmap, dep);
+                const depPath = depKey ? longestTo.get(depKey) : undefined;
                 if (depPath && depPath.length > best.length) {
                     best = depPath;
                 }
@@ -460,16 +510,22 @@ export function computeCriticalPath(roadmap) {
 }
 /** Topological sort of sprints by dependency order */
 function topologicalSort(sprints) {
+    const roadmap = { name: '', phases: [], sprints };
     const inDegree = new Map();
     const adjacency = new Map();
     for (const sprint of sprints) {
-        inDegree.set(sprint.id, 0);
-        adjacency.set(sprint.id, []);
+        const key = roadmapSprintKey(roadmap, sprint);
+        inDegree.set(key, 0);
+        adjacency.set(key, []);
     }
     for (const sprint of sprints) {
+        const key = roadmapSprintKey(roadmap, sprint);
         for (const dep of sprint.depends_on ?? []) {
-            adjacency.get(dep)?.push(sprint.id);
-            inDegree.set(sprint.id, (inDegree.get(sprint.id) ?? 0) + 1);
+            const depKey = roadmapSprintKeyFromId(roadmap, dep);
+            if (depKey === null)
+                continue;
+            adjacency.get(depKey)?.push(key);
+            inDegree.set(key, (inDegree.get(key) ?? 0) + 1);
         }
     }
     const queue = [];
@@ -504,7 +560,7 @@ export function findParallelOpportunities(roadmap) {
     for (const [depth, ids] of byDepth) {
         if (ids.length > 1) {
             groups.push({
-                sprints: ids.sort((a, b) => a - b),
+                sprints: ids.sort(compareSprintIdKeys),
                 reason: `Same dependency depth (${depth}) — no mutual dependencies`,
             });
         }
@@ -513,19 +569,23 @@ export function findParallelOpportunities(roadmap) {
 }
 /** Compute the depth (longest path from a root) of each sprint */
 function computeDepthMap(sprints) {
+    const roadmap = { name: '', phases: [], sprints };
     const depthMap = new Map();
-    const sprintMap = new Map(sprints.map(s => [s.id, s]));
+    const sprintMap = new Map(sprints.map(s => [roadmapSprintKey(roadmap, s), s]));
     function getDepth(id) {
         if (depthMap.has(id))
             return depthMap.get(id);
         const sprint = sprintMap.get(id);
         const deps = sprint?.depends_on ?? [];
-        const depth = deps.length === 0 ? 0 : Math.max(...deps.map(getDepth)) + 1;
+        const depKeys = deps
+            .map(dep => roadmapSprintKeyFromId(roadmap, dep))
+            .filter((dep) => dep !== null);
+        const depth = depKeys.length === 0 ? 0 : Math.max(...depKeys.map(getDepth)) + 1;
         depthMap.set(id, depth);
         return depth;
     }
     for (const sprint of sprints) {
-        getDepth(sprint.id);
+        getDepth(roadmapSprintKey(roadmap, sprint));
     }
     return depthMap;
 }
@@ -593,29 +653,30 @@ export function formatRoadmapSummary(roadmap) {
     lines.push('');
     // Phases
     for (const phase of roadmap.phases) {
-        const phaseSprintIds = phase.sprints;
-        const phaseSprints = roadmap.sprints.filter(s => phaseSprintIds.includes(s.id));
+        const phaseSprintIds = phase.sprint_keys ?? phase.sprints;
+        const phaseSprintKeys = new Set(phaseSprintIds.map(id => roadmapSprintKeyFromId(roadmap, id)));
+        const phaseSprints = roadmap.sprints.filter(sprint => phaseSprintKeys.has(roadmapSprintKey(roadmap, sprint)));
         lines.push(`## ${phase.name}`);
         lines.push('');
         for (const sprint of phaseSprints) {
             const deps = sprint.depends_on?.length
-                ? ` (depends on: ${sprint.depends_on.map(formatSprintLabel).join(', ')})`
+                ? ` (depends on: ${sprint.depends_on.map(id => formatRoadmapSprintLabel(roadmap, id)).join(', ')})`
                 : ' (no dependencies)';
-            lines.push(`- **${formatSprintLabel(sprint.id)}** — ${sprint.theme} | Par ${sprint.par} | ${sprint.tickets.length} tickets${deps}`);
+            lines.push(`- **${formatRoadmapSprintLabel(roadmap, roadmapSprintKey(roadmap, sprint))}** — ${sprint.theme} | Par ${sprint.par} | ${sprint.tickets.length} tickets${deps}`);
         }
         lines.push('');
     }
     // Critical path
     lines.push('## Critical Path');
     lines.push('');
-    lines.push(`${criticalPath.path.map(formatSprintLabel).join(' → ')} (${criticalPath.length} sprints, par ${criticalPath.totalPar})`);
+    lines.push(`${criticalPath.path.map(id => formatRoadmapSprintLabel(roadmap, id)).join(' → ')} (${criticalPath.length} sprints, par ${criticalPath.totalPar})`);
     lines.push('');
     // Parallel opportunities
     if (parallelGroups.length > 0) {
         lines.push('## Parallel Opportunities');
         lines.push('');
         for (const group of parallelGroups) {
-            lines.push(`- ${group.sprints.map(formatSprintLabel).join(', ')}: ${group.reason}`);
+            lines.push(`- ${group.sprints.map(id => formatRoadmapSprintLabel(roadmap, id)).join(', ')}: ${group.reason}`);
         }
         lines.push('');
     }
@@ -630,21 +691,23 @@ export function formatRoadmapSummary(roadmap) {
 }
 /** Format strategic context for briefings — concise 3-5 line summary */
 export function formatStrategicContext(roadmap, currentSprint) {
-    const currentOrder = roadmapSprintOrderValue(roadmap, currentSprint);
-    const sprint = roadmap.sprints.find(s => roadmapSprintOrderValue(roadmap, s.id) === currentOrder);
+    const sprint = findRoadmapSprint(roadmap, currentSprint);
     if (!sprint)
         return null;
-    const resolvedSprint = sprint.id;
+    const resolvedSprint = roadmapSprintKey(roadmap, sprint);
     const criticalPath = computeCriticalPath(roadmap);
-    const onCriticalPath = criticalPath.path.some(id => roadmapSprintOrderValue(roadmap, id) === currentOrder);
+    const onCriticalPath = criticalPath.path.includes(resolvedSprint);
     const totalSprints = roadmap.sprints.length;
-    const sprintIndex = roadmap.sprints.findIndex(s => s.id === resolvedSprint) + 1;
+    const sprintIndex = roadmap.sprints.findIndex(s => roadmapSprintKey(roadmap, s) === resolvedSprint) + 1;
     // Find which phase this sprint belongs to
-    const phase = roadmap.phases.find(p => p.sprints.some(id => roadmapSprintOrderValue(roadmap, id) === currentOrder));
+    const phase = roadmap.phases.find(p => {
+        const keys = p.sprint_keys ?? p.sprints;
+        return keys.some(id => roadmapSprintKeyFromId(roadmap, id) === resolvedSprint);
+    });
     // Find what depends on this sprint
     const dependents = roadmap.sprints
-        .filter(s => s.depends_on?.some(id => roadmapSprintOrderValue(roadmap, id) === currentOrder))
-        .map(s => formatRoadmapSprintLabel(roadmap, s.id));
+        .filter(s => s.depends_on?.some(id => roadmapSprintKeyFromId(roadmap, id) === resolvedSprint))
+        .map(s => formatRoadmapSprintLabel(roadmap, roadmapSprintKey(roadmap, s)));
     const lines = [];
     lines.push(`Sprint ${sprintIndex} of ${totalSprints} — ${formatRoadmapSprintLabel(roadmap, resolvedSprint)}: ${sprint.theme}`);
     if (phase) {
@@ -661,14 +724,13 @@ export function formatStrategicContext(roadmap, currentSprint) {
     if (next) {
         const blockers = (next.depends_on ?? [])
             .filter(d => {
-            const depOrder = roadmapSprintOrderValue(roadmap, d);
-            const dep = roadmap.sprints.find(s => roadmapSprintOrderValue(roadmap, s.id) === depOrder);
+            const dep = findRoadmapSprint(roadmap, d);
             return !dep || dep.status !== 'complete';
         });
         const status = blockers.length === 0
             ? 'ready'
             : `blocked by ${blockers.map(id => formatRoadmapSprintLabel(roadmap, id)).join(', ')}`;
-        lines.push(`Next: ${formatRoadmapSprintLabel(roadmap, next.id)}: ${next.theme} (${status})`);
+        lines.push(`Next: ${formatRoadmapSprintLabel(roadmap, roadmapSprintKey(roadmap, next))}: ${next.theme} (${status})`);
     }
     return lines.join('\n');
 }
@@ -678,19 +740,25 @@ export function formatStrategicContext(roadmap, currentSprint) {
  *  Returns null if no candidate found.
  */
 export function findNextPlannedSprint(roadmap, currentSprint) {
-    const currentOrder = roadmapSprintOrderValue(roadmap, currentSprint);
+    const currentKey = roadmapSprintKeyFromId(roadmap, currentSprint);
+    if (currentKey === null)
+        return null;
     const candidates = roadmap.sprints
         .filter(s => {
-        return isRoadmapSprintPending(s) && roadmapSprintOrderValue(roadmap, s.id) > currentOrder;
+        return isRoadmapSprintPending(s)
+            && compareSprintIdKeys(roadmapSprintKey(roadmap, s), currentKey) > 0;
     })
-        .sort((a, b) => compareRoadmapSprintIds(roadmap, a.id, b.id));
+        .sort((a, b) => compareSprintIdKeys(roadmapSprintKey(roadmap, a), roadmapSprintKey(roadmap, b)));
     if (candidates.length === 0)
         return null;
     const completedIds = new Set(roadmap.sprints
         .filter(s => s.status === 'complete')
-        .map(s => roadmapSprintOrderValue(roadmap, s.id)));
+        .map(s => roadmapSprintKey(roadmap, s)));
     // Prefer the lowest-id candidate whose dependencies are all complete
-    const ready = candidates.find(s => (s.depends_on ?? []).every(d => completedIds.has(roadmapSprintOrderValue(roadmap, d))));
+    const ready = candidates.find(s => (s.depends_on ?? []).every(d => {
+        const key = roadmapSprintKeyFromId(roadmap, d);
+        return key !== null && completedIds.has(key);
+    }));
     return ready ?? candidates[0];
 }
 //# sourceMappingURL=roadmap.js.map