@opengsd/gsd-core 1.14.0 → 1.16.0

package/gsd-core/bin/lib/phase-id-card.cjs

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Canonical bracket convention card (#3638 / ADR-612 PR-5).
+ *
+ * This module is the sole editable source of the compact grammar diagram.
+ * Render sites import phaseIdCard(); generated documentation is held to the
+ * same bytes by tests/phase-id-card.test.cjs. PR-6 can therefore inject the
+ * card broadly without inventing another copy.
+ */
+const PHASE_ID_CARD = [
+    '[GSD.02] 05.03-01',
+    ' │   │   │  │   │',
+    ' │   │   │  │   └── plan        01',
+    ' │   │   │  └────── subphase    03',
+    ' │   │   └───────── phase       05',
+    ' │   └───────────── milestone   02',
+    ' └───────────────── project     GSD',
+].join('\n');
+const PHASE_ID_LEGEND = "milestone = bracket integer; dots = phase-levels; one hyphen = plan; "
+    + "no 'Phase' word, no vX.Y";
+function phaseIdCard(options = {}) {
+    const parts = [];
+    if (options.title)
+        parts.push(options.title, '');
+    parts.push(PHASE_ID_CARD, '', PHASE_ID_LEGEND);
+    return parts.join('\n');
+}
+module.exports = {
+    phaseIdCard,
+    PHASE_ID_CARD,
+    PHASE_ID_LEGEND,
+};

package/gsd-core/bin/lib/phase-id-display.cjs

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Phase-ID display adapters (#3638 / ADR-612 PR-5).
+ *
+ * STATE.md and milestone metadata still expose the legacy `vN.0` marker on
+ * this stacked base. Display surfaces need to translate that metadata into a
+ * bracket identity without growing another renderer. These pure adapters do
+ * only the boundary normalization, then delegate identity parsing/rendering to
+ * phase-id.cts's canonical pair.
+ */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const phaseId = require("./phase-id.cjs");
+const { parsePhaseId, renderMilestoneId, renderPhaseId } = phaseId;
+function canonicalNumeric(value) {
+    let offset = 0;
+    while (offset < value.length - 1 && value[offset] === '0')
+        offset++;
+    const stripped = value.slice(offset);
+    return stripped.length < 2 ? stripped.padStart(2, '0') : stripped;
+}
+function isDigits(value) {
+    return value.length > 0
+        && [...value].every(char => char >= '0' && char <= '9');
+}
+function milestoneToken(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return null;
+    const raw = String(value).replace(/^v/i, '');
+    const parts = raw.split('.');
+    if (parts.length > 2 || parts.some(part => !isDigits(part)))
+        return null;
+    return canonicalNumeric(parts[0]);
+}
+function phaseToken(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return null;
+    const raw = String(value);
+    const parts = raw.split('.');
+    if (parts.length > 2 || parts.some(part => !isDigits(part)))
+        return null;
+    return parts.map(canonicalNumeric).join('.');
+}
+/**
+ * Render a bracket phase display from legacy milestone metadata.
+ * Returns null for incomplete or invalid metadata so cosmetic callers can
+ * degrade without breaking a command/statusline render.
+ */
+function renderBracketPhaseDisplay(milestone, phase, projectCode) {
+    const project = typeof projectCode === 'string' ? projectCode : '';
+    const mm = milestoneToken(milestone);
+    const pp = phaseToken(phase);
+    if (!project || mm === null || pp === null)
+        return null;
+    try {
+        return renderPhaseId(parsePhaseId(`${project}.${mm}-${pp}`));
+    }
+    catch {
+        return null;
+    }
+}
+/** Render only the bracket milestone label, still through canonical parsing. */
+function renderBracketMilestoneDisplay(milestone, projectCode) {
+    const project = typeof projectCode === 'string' ? projectCode : '';
+    const mm = milestoneToken(milestone);
+    if (!project || mm === null)
+        return null;
+    try {
+        // The sentinel phase is a validation vehicle, not a rendering artifact.
+        return renderMilestoneId(parsePhaseId(`${project}.${mm}-00`));
+    }
+    catch {
+        return null;
+    }
+}
+module.exports = {
+    renderBracketPhaseDisplay,
+    renderBracketMilestoneDisplay,
+};

package/gsd-core/bin/lib/phase-id.cjs

@@ -59,6 +59,20 @@ const OPTIONAL_PHASE_TAG_SOURCE = '(?:\\s*\\([^)\\n]{0,200}\\))?';
 // (scripts/lint-phase-id-drift.cjs) fails CI if a literal re-derivation is
 // introduced outside this module without a `// phase-id-owner:` justification.
 const PHASE_NUMBER_TOKEN_SOURCE = '\\d+[A-Z]?(?:\\.\\d+)*';
+// #4764: a phase REFERENCE in depends-on PROSE — the token in context, directly
+// following "Phase"/"Phases", with bare-token list continuation ("Phases 1 and 2",
+// "Phase 1, 2, and 3", "Phase 1-3"). Built HERE, beside the token grammar it is
+// anchored on, because two readers consume Depends-on prose (init.manager's
+// dep_phases and planning-inspect's dependencies) and re-deriving the anchored
+// form at each would drift exactly the way PHASE_NUMBER_TOKEN_SOURCE's own
+// anti-divergence rule exists to prevent. A bare digit run is the right shape
+// test for a phase id and the WRONG test for a reference: the whole-field
+// scrape this replaces pulled calendar dates ("2026-09-14" → 2026/09/14), git
+// shas ("8bf403100d" → 8b/403100d/…) and ledger ids (WINDOWS #1843) in as
+// dependencies. The `-` separator deliberately extracts range ENDPOINTS only
+// ("Phase 1-3" → 1, 3) — the pre-#4764 behavior; interior enumeration stays
+// out (a range's middle is not written as a reference).
+const PHASE_DEP_REF_SOURCE = `\\bphases?\\s+(${PHASE_NUMBER_TOKEN_SOURCE}(?:(?:\\s*,\\s*(?:and\\s+)?|\\s+and\\s+|\\s*&\\s*|\\s+(?:to|through)\\s+|\\s*-\\s*)${PHASE_NUMBER_TOKEN_SOURCE})*)`;
 // #2528 review: the CASE-FLEXIBLE renderings of the two sources above, for call
 // sites that scan directory names (where a project code or a variant suffix may
 // legitimately be lowercase) and therefore cannot use a case-sensitive class.
@@ -308,6 +322,30 @@ function phaseHeadingPrefixSrcFor(baseline, convention, capturing = false) {
     const bracketAlt = `\\[${id}\\][ \\t]*(?:Phase\\s+|(?=\\d))`;
     return `(?:${bracketAlt}|${base})`;
 }
+/**
+ * The single owner of the "scan a whole document for every phase heading"
+ * pattern (#4865 / ADR-4910 §8) — anchored (`^ {0,3}#{2,4}`, so indentation up
+ * to 3 spaces is tolerated but a heading is never matched mid-line), global,
+ * multiline, convention-aware via `phaseHeadingPrefixSrcFor`. Returns the
+ * capture-group layout alongside the regex so a caller never re-derives the
+ * bracket-convention offset (`const G = convention === 'bracket' ? 1 : 0`)
+ * itself — a second, independently-computed offset is exactly the kind of
+ * drift `scripts/lint-phase-id-drift.cjs` exists to catch structurally, not
+ * just by pattern text.
+ *
+ * Distinct from `buildPhaseHeadingRegex` (`src/roadmap.cts`), which searches
+ * for ONE already-known phase number (anchored `^`, no `g` flag, phase number
+ * interpolated literally) — a different contract for a different question.
+ * This function answers "which phases exist in this content", not "does this
+ * specific phase exist".
+ */
+function buildPhaseHeadingScanRegex(baseline, convention) {
+    const bracketGroup = convention === 'bracket' ? 1 : null;
+    const phaseNumGroup = bracketGroup ? 2 : 1;
+    const phaseNameGroup = phaseNumGroup + 1;
+    const regex = new RegExp(`^ {0,3}#{2,4}\\s*${phaseHeadingPrefixSrcFor(baseline, convention, true)}(${PHASE_NUMBER_TOKEN_SOURCE})${OPTIONAL_PHASE_TAG_SOURCE}:\\s*([^\\n]+)`, 'gim');
+    return { regex, bracketGroup, phaseNumGroup, phaseNameGroup };
+}
 function stripProjectCodePrefix(value, caseInsensitive = true) {
     const input = String(value);
     const re = caseInsensitive ? PROJECT_CODE_PREFIX_STRIP_RE_I : PROJECT_CODE_PREFIX_STRIP_RE;
@@ -451,10 +489,27 @@ function parsePhaseId(input) {
     // tokens unchanged.
     throw new Error(`parsePhaseId: not a bracket phase id: ${JSON.stringify(input)}`);
 }
+function renderMilestoneId(id) {
+    return `[${id.project}.${id.milestone}]`;
+}
 function renderPhaseId(id) {
     const sub = id.subphase ? `.${id.subphase}` : '';
     const plan = id.plan ? `-${id.plan}` : '';
-    return `[${id.project}.${id.milestone}] ${id.phase}${sub}${plan}`;
+    return `${renderMilestoneId(id)} ${id.phase}${sub}${plan}`;
+}
+/** Whether a legacy phase token has a lossless spelling in bracket display grammar. */
+function isBracketPhaseTokenRepresentable(token) {
+    try {
+        const bracketToken = normalizePhaseName(token)
+            .split('.')
+            .map((segment) => segment.padStart(2, '0'))
+            .join('.');
+        parsePhaseId(`[GSD.00] ${bracketToken}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 // PhaseId is a structural type: nothing forces a caller through parsePhaseId,
 // so toDir cannot trust project/milestone/phase/subphase are already
@@ -1017,7 +1072,7 @@ function isPhaseArtifact(fileName, phaseDirName, convention) {
  * whichever path produced the candidates, which is what makes a bracket dir
  * read exactly what its legacy twin reads.
  */
-function matchesPhaseTokenCandidates(fileName, rawCandidates) {
+function expandPhaseTokenCandidates(rawCandidates) {
     // Each reading is compared in BOTH its padded and de-padded form: files are
     // written padded by `normalizePhaseName` (`cmdScaffold`) while directories
     // are often not (`1-unpadded`), and legacy trees carry the reverse pairing.
@@ -1025,9 +1080,19 @@ function matchesPhaseTokenCandidates(fileName, rawCandidates) {
     // sub-phase (`03A`, `03.1`) has no meaningful de-padded form and is left
     // alone, so this only ever ADDS a reading and can never drop one.
     const depad = (t) => (/^\d+$/.test(t) ? String(Number(t)) : t);
-    const candidates = new Set(rawCandidates
+    return new Set(rawCandidates
         .flatMap(t => [t, normalizePhaseName(t), depad(t)])
         .map(t => t.toUpperCase()));
+}
+function matchesPhaseTokenCandidates(fileName, rawCandidates) {
+    const candidates = expandPhaseTokenCandidates(rawCandidates);
+    if (matchPhaseTokenCandidateSpan(fileName, candidates) !== null)
+        return true;
+    // FIX 2: token-less filename (bare "VERIFICATION.md"/"UAT.md") — containment
+    // in this phase's own directory listing is sufficient.
+    return derivePhaseTokenSegments(fileName).tokenSegments.length === 0;
+}
+function matchPhaseTokenCandidateSpan(fileName, candidates) {
     const fileUpper = fileName.toUpperCase();
     for (const candidate of candidates) {
         // A dotted sub-phase segment (e.g. `01.1-CONTEXT.md`) is a legitimate
@@ -1053,11 +1118,43 @@ function matchesPhaseTokenCandidates(fileName, rawCandidates) {
         if (fileUpper.startsWith(`${candidate}-`) ||
             fileUpper.startsWith(`${candidate}.`) ||
             fileUpper.startsWith(`${candidate}_`))
-            return true;
+            return { start: 0, end: candidate.length };
     }
-    // FIX 2: token-less filename (bare "VERIFICATION.md"/"UAT.md") — containment
-    // in this phase's own directory listing is sufficient.
-    return derivePhaseTokenSegments(fileName).tokenSegments.length === 0;
+    return null;
+}
+/**
+ * Return the exact leading token span by which the phase-artifact reader
+ * attributes a phase-qualified filename to `phaseDirName`.
+ *
+ * Membership is first decided by `isPhaseArtifact`, then the span is selected
+ * from the same padded, de-padded, case-folded candidate set used by
+ * `matchesPhaseTokenCandidates`. Token-less containment fallbacks return null
+ * because there is no phase token in the filename to replace.
+ */
+function phaseArtifactTokenSpan(fileName, phaseDirName, convention) {
+    if (!isPhaseArtifact(fileName, phaseDirName, convention))
+        return null;
+    if (convention === 'bracket') {
+        const bracketDir = phaseDirName.match(BRACKET_DIR_TOKEN_RE);
+        if (bracketDir) {
+            const qualified = fileName.match(BRACKET_QUALIFIED_KEY_RE);
+            if (qualified && bracketQualifiedKey(fileName, convention) !== null) {
+                return { start: 0, end: qualified[0].length };
+            }
+            const bracketCandidates = expandPhaseTokenCandidates([bracketDir[1]]);
+            return matchPhaseTokenCandidateSpan(fileName, bracketCandidates);
+        }
+    }
+    const { tokenSegments } = derivePhaseTokenSegments(phaseDirName);
+    if (tokenSegments.length === 0)
+        return null;
+    const literalToken = extractPhaseToken(phaseDirName);
+    const strippedDir = stripProjectCodePrefix(phaseDirName);
+    const strippedToken = strippedDir !== phaseDirName ? extractPhaseToken(strippedDir) : literalToken;
+    const leadingRunMatch = strippedDir.match(LEADING_DIGIT_RUN_RE);
+    const rawCandidates = [literalToken, strippedToken, leadingRunMatch?.[1]].filter((token) => Boolean(token));
+    const candidates = expandPhaseTokenCandidates(rawCandidates);
+    return matchPhaseTokenCandidateSpan(fileName, candidates);
 }
 /**
  * #3511: scope `fileNames` to the subset that passes
@@ -1245,7 +1342,7 @@ const unpad = (digits) => digits.replace(/^0+(?=\d)/, '');
  *   candidates (#2237).
  *
  *   TAKE `matches[0]` — `cmdPhasesList`, `cmdInitManager`, `cmdRoadmapAnalyze`,
- *   `cmdVerifySchemaDrift`, `detectVerifyFailed`. Each read a directory to
+ *   the schema-drift gate (`resolvePhaseDirByToken`), `detectVerifyFailed`. Each read a directory to
  *   DECORATE a row they are already emitting; each used `.find()` before this
  *   PR, so first-match is their prior behavior preserved verbatim, and each is
  *   order-stable because the directory list is sorted and this function filters
@@ -1538,6 +1635,7 @@ module.exports = {
     OPTIONAL_PROJECT_CODE_PREFIX_SOURCE,
     OPTIONAL_PHASE_TAG_SOURCE,
     PHASE_NUMBER_TOKEN_SOURCE,
+    PHASE_DEP_REF_SOURCE,
     CASE_FLEXIBLE_PROJECT_CODE_PREFIX_SOURCE,
     CASE_FLEXIBLE_PHASE_NUMBER_TOKEN_SOURCE,
     PHASE_CONTINUATION_SEGMENT_SOURCE,
@@ -1554,6 +1652,7 @@ module.exports = {
     BASE_PHASE_LABEL_PREFIX_SRC,
     PHASE_HEADING_BASELINE,
     phaseHeadingPrefixSrcFor,
+    buildPhaseHeadingScanRegex,
     foldBracketId,
     bracketQualifiedKey,
     stripProjectCodePrefix,
@@ -1561,7 +1660,9 @@ module.exports = {
     getMilestoneFromPhaseId,
     getPhaseDirFromPhaseId,
     parsePhaseId,
+    renderMilestoneId,
     renderPhaseId,
+    isBracketPhaseTokenRepresentable,
     toDir,
     SENTINEL_RANGES,
     isSentinelPhaseId,
@@ -1571,6 +1672,7 @@ module.exports = {
     comparePhaseNum,
     extractPhaseToken,
     isPhaseArtifact,
+    phaseArtifactTokenSpan,
     scopeToPhase,
     phaseTokenMatches,
     matchPhaseDirs,

package/gsd-core/bin/lib/phase-lifecycle.cjs

@@ -31,6 +31,9 @@ const markdown_table_cjs_1 = require("./markdown-table.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-id.cjs is an export= CommonJS module
 const phaseIdMod = require("./phase-id.cjs");
 const { isSentinelPhaseId } = phaseIdMod;
+// #5060: `phase-status.cjs` is a load-time leaf (no top-level requires), safe
+// to import here for the ROADMAP Status-cell reader.
+const phase_status_cjs_1 = require("./phase-status.cjs");
 /**
  * #3227: the single owner of "where is this ROADMAP's Progress table".
  * Lifted verbatim out of deriveProgressFromRoadmap so `state-contract.cts`
@@ -93,8 +96,6 @@ function deriveProgressFromRoadmap(roadmapContent) {
     const table = locateProgressTable(roadmapContent);
     if (table) {
         const allRows = table.rows;
-        const completed = allRows.filter((r) => /^complete$/i.test((r['Status'] ?? '').trim())).length;
-        completedPhases = completed > 0 ? completed : null;
         // Data rows only (exclude sentinel phases 0 and 999.x).
         // #3185: canonical sentinel predicate (SENTINEL_RANGES [0,999]) — this was a local 999-only literal that admitted Phase 0.
         const dataRows = allRows.filter((r) => {
@@ -102,6 +103,12 @@ function deriveProgressFromRoadmap(roadmapContent) {
             return /^\d/.test(phase) && !isSentinelPhaseId(phase);
         });
         totalPhases = dataRows.length > 0 ? dataRows.length : null;
+        // #5060: routed through the Phase Status Module's `parseRoadmapStatusCell`
+        // owner (rather than a local `/^complete$/i` regex) and counted over
+        // `dataRows` (not `allRows`) — a sentinel row's Status cell must never
+        // contribute to `completedPhases`.
+        const completed = dataRows.filter((r) => (0, phase_status_cjs_1.parseRoadmapStatusCell)(r['Status']) === phase_status_cjs_1.WIRE_STATUS.COMPLETE).length;
+        completedPhases = completed > 0 ? completed : null;
         let totalPlansSum = 0;
         for (const r of allRows) {
             const cell = (r['Plans Complete'] ?? '').trim();

package/gsd-core/bin/lib/phase-locator.cjs

@@ -35,7 +35,7 @@ const frontmatterModule = require("./frontmatter.cjs");
 const { extractFrontmatter } = frontmatterModule;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const planDependencyGraphModule = require("./plan-dependency-graph.cjs");
-const { computeHaltPropagation, buildSummaryFileIndex, isSummaryFileHalted } = planDependencyGraphModule;
+const { computeHaltPropagation, buildSummaryFileIndex, isSummaryFileHalted, isSummaryFileBlocked } = planDependencyGraphModule;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const roadmapParserModule = require("./roadmap-parser.cjs");
 const { getMilestonePhaseFilter } = roadmapParserModule;
@@ -146,13 +146,15 @@ function listArchiveVersionDirs(cwd, wsOverride) {
     }
     return out;
 }
-function searchPhaseInDir(baseDir, relBase, normalized) {
+function searchPhaseInDir(baseDir, relBase, normalized, convention) {
     try {
         const dirs = readSubdirectories(baseDir, true);
         // #2528: canonical two-pass selection (exact token match, then the
         // bare-integer leading-digit-run fallback) shared with the find-phase and
         // phase-plan-index scans — see phase-id.cts::matchPhaseDirs.
-        const { matches, usedBareFallback } = matchPhaseDirs(dirs, normalized);
+        // #4801: the convention is threaded (optional) so bracket-convention
+        // consumers get exact token matching here too.
+        const { matches, usedBareFallback } = matchPhaseDirs(dirs, normalized, convention);
         if (matches.length === 0)
             return null;
         // #2237: fail loud when multiple directories match the same bare phase
@@ -176,6 +178,7 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
                 halted_plans: [],
                 blocked_by: {},
                 runnable_plans: [],
+                ready_plans: [],
             };
         }
         const match = matches[0];
@@ -208,12 +211,19 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
         const planIds = plans.map(p => p.replace('-PLAN.md', '').replace('PLAN.md', ''));
         const planIdByLower = new Map(planIds.map(id => [id.toLowerCase(), id]));
         const canonicalToPlanId = new Map(plans.map((p, i) => [extractCanonicalPlanId(p).toLowerCase(), planIds[i]]));
+        // #4628: raw depends_on per plan, so readiness can fail closed on a
+        // DROPPED edge (a dep token that resolves to nothing carries no evidence)
+        // instead of the resolution silently shrinking the dependency list.
+        const rawDeps = plans.map((p) => parsePlanDependsOn(phaseDir, p));
+        // #4628: completion evidence excludes status:blocked summaries (#3345) —
+        // a failure record is not completion, matching cmdPhasePlanIndex's count.
+        const completionEvidence = buildSummaryFileIndex(summaries.filter((f) => !isSummaryFileBlocked(node_path_1.default.join(phaseDir, f))), extractCanonicalPlanId);
         const haltNodes = plans.map((p, i) => {
             const planId = planIds[i];
             const canonical = extractCanonicalPlanId(p);
             const summaryFile = summaryFileByPlanId.get(planId) ?? summaryFileByPlanId.get(canonical);
             const halted = summaryFile !== undefined && isSummaryFileHalted(node_path_1.default.join(phaseDir, summaryFile));
-            const resolvedDependsOn = parsePlanDependsOn(phaseDir, p)
+            const resolvedDependsOn = rawDeps[i]
                 .map((dep) => {
                 const lower = dep.toLowerCase();
                 return planIdByLower.get(lower) ?? canonicalToPlanId.get(lower) ?? null;
@@ -226,6 +236,7 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
         const incompletePlanSet = new Set(incompletePlans);
         const blockedByFiles = {};
         const runnablePlans = [];
+        const readyPlans = [];
         for (let i = 0; i < plans.length; i++) {
             const p = plans[i];
             if (!incompletePlanSet.has(p))
@@ -233,10 +244,16 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
             const causes = blockedBy.get(planIds[i]) ?? [];
             if (causes.length > 0) {
                 blockedByFiles[p] = causes;
+                continue;
             }
-            else {
-                runnablePlans.push(p);
-            }
+            runnablePlans.push(p);
+            // #4628: DAG-ready on top of runnable — every dependency must have
+            // completion evidence (a matching, non-blocked SUMMARY) and no dropped
+            // edge: both readers of this contract fail closed identically.
+            const depsComplete = rawDeps[i].length === haltNodes[i].resolvedDependsOn.length &&
+                haltNodes[i].resolvedDependsOn.every((dep) => completionEvidence.has(dep));
+            if (depsComplete)
+                readyPlans.push(p);
         }
         return {
             found: true,
@@ -259,19 +276,21 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
             halted_plans: haltedPlans,
             blocked_by: blockedByFiles,
             runnable_plans: runnablePlans,
+            ready_plans: readyPlans,
         };
     }
     catch {
         return null;
     }
 }
-function findPhaseInternal(cwd, phase) {
+function findPhaseInternal(cwd, phase, convention) {
     if (!phase)
         return null;
     const phasesDir = node_path_1.default.join(planningDir(cwd), 'phases');
     const normalized = normalizePhaseName(phase);
     const relPhasesDir = toPosixPath(node_path_1.default.relative(cwd, phasesDir));
-    const current = searchPhaseInDir(phasesDir, relPhasesDir, normalized);
+    // #4801: convention threaded through to the matcher (see searchPhaseInDir).
+    const current = searchPhaseInDir(phasesDir, relPhasesDir, normalized, convention);
     if (current)
         return current;
     // #2855: scope the archived-milestone fallback to the SAME workstream as the
@@ -285,7 +304,7 @@ function findPhaseInternal(cwd, phase) {
     // getArchivedPhaseDirs via listArchiveVersionDirs (see its doc comment).
     for (const { version, archivePath } of listArchiveVersionDirs(cwd)) {
         const relBase = toPosixPath(node_path_1.default.relative(cwd, archivePath));
-        const result = searchPhaseInDir(archivePath, relBase, normalized);
+        const result = searchPhaseInDir(archivePath, relBase, normalized, convention);
         if (result) {
             result.archived = version;
             return result;