@opengsd/gsd-core 1.14.0 → 1.15.0

package/gsd-core/bin/lib/init.cjs

@@ -41,6 +41,8 @@ const { SCOPE } = planningScopeMod;
 const secrets_cjs_1 = require("./secrets.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- plan-scan.cjs is an export= CommonJS module
 const scanPhasePlans = require("./plan-scan.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- plan-document.cjs is an export= CommonJS module
+const planDocument = require("./plan-document.cjs");
 const state_document_cjs_1 = require("./state-document.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
 const host_runtime_detection_cjs_1 = require("./host-runtime-detection.cjs");
@@ -87,9 +89,9 @@ const { resolveModelInternal, resolveGranularityInternal, assertValidGranularity
 const { findPhaseInternal, listMilestonePhaseDirs, listAllPhaseDirs } = phaseLocator;
 const { getRoadmapPhaseInternal, getMilestoneInfo, stripShippedMilestones, extractCurrentMilestone, } = roadmapParser;
 const { pathExistsInternal, generateSlugInternal, toPosixPath } = coreUtils;
-const { comparePhaseNum, normalizePhaseName, matchPhaseDirs, stripProjectCodePrefix, PHASE_NUMBER_TOKEN_SOURCE, isForeignPrefixedPhaseQuery, isSentinelPhaseId, extractPhaseToken, scopeToPhase, renderPhaseBranchName } = phaseId;
+const { comparePhaseNum, normalizePhaseName, stripProjectCodePrefix, PHASE_NUMBER_TOKEN_SOURCE, PHASE_DEP_REF_SOURCE, isForeignPrefixedPhaseQuery, isSentinelPhaseId, extractPhaseToken, scopeToPhase, renderPhaseBranchName, parsePhaseId, renderPhaseId, phaseHeadingPrefixSrcFor, PHASE_HEADING_BASELINE, buildPhaseHeadingScanRegex, } = phaseId;
 const { pruneOrphanedWorktrees } = worktreeSafety;
-const { planningPaths, planningDir, planningRoot, todosDir, listAvailableWorkstreams, peekActiveWorkstream, diagnoseUnresolvedActiveWorkstream, describeUnresolvedWorkstreamReason, findContextMdIn, } = planningWorkspace;
+const { planningPaths, planningDir, planningRoot, todosDir, listAvailableWorkstreams, peekActiveWorkstream, resolveEnvWorkstream, diagnoseUnresolvedActiveWorkstream, describeUnresolvedWorkstreamReason, findContextMdIn, resolvePhaseIdConvention, } = planningWorkspace;
 const { determinePhaseStatus } = commandsMod;
 const { extractFrontmatter } = frontmatterMod;
 const { isPhaseComplete, resolveVerificationFile, resolveUatFile } = verificationMod;
@@ -100,7 +102,6 @@ const { resolveCapabilityRuntimeState } = capabilityStateMod;
 // Unused but imported for structural parity
 void stripShippedMilestones;
 // Accept all bold/colon variants of the Requirements header (#2769)
-const REQUIREMENTS_HEADER_RE = /^\*\*Requirements:?\*\*[^\S\n]*:?[^\S\n]*([^\n]*)$/m;
 // #2056/#2104: isForeignPrefixedPhaseQuery is imported from phase-id.cts
 // (the canonical predicate). parsePhasePrefix is no longer needed locally.
 // phaseInfoMatchesExactPrefix and roadmapPhaseMatchesExactPrefix are local
@@ -110,9 +111,18 @@ function phaseInfoMatchesExactPrefix(phaseInfo, phase) {
     const numStr = typeof num === 'string' ? num : (typeof num === 'number' ? String(num) : '');
     return numStr.toUpperCase() === phase.toUpperCase();
 }
+// #4906 Phase 5 (#4984): NOT migrated onto the heading-baseline selector —
+// this site was never one of the five ADR-4910 §8 call sites this phase owns
+// (init milestone/progress heading scans + milestone.cts's unstarted-phase
+// guard, all via buildPhaseHeadingScanRegex), and adding a NEW direct
+// any-bracket selector consumer here inflated init.cts's
+// tests/adr-612-bracket-heading-selection.test.cjs census past its pinned
+// count. Left bracket-blind deliberately, matching this call's pre-#4984
+// behavior; folding it into the census is Phase 6 work.
 function roadmapPhaseMatchesExactPrefix(roadmapPhase, phase) {
     const sectionRaw = roadmapPhase?.['section'];
     const section = typeof sectionRaw === 'string' ? sectionRaw : '';
+    // phase-id-owner: deliberately unmigrated (#4984 revert) — see comment above the function.
     return new RegExp(`^#{2,4}\\s*Phase\\s+${(0, pattern_cjs_1.escapeRegex)(phase)}(?:\\b|\\s|:)`, 'i').test(section);
 }
 // #2104: shared helpers that wrap findPhaseInternal / getRoadmapPhaseInternal
@@ -584,6 +594,13 @@ function detectPhaseMvpMode(cwd, phaseNumber) {
         const rawContent = node_fs_1.default.readFileSync(roadmapPath, 'utf-8');
         const content = extractCurrentMilestone(rawContent, cwd);
         const escapedPhase = (0, pattern_cjs_1.escapeRegex)(phaseNumber);
+        // #4906 Phase 5 (#4984): NOT migrated onto phaseHeadingPrefixSrcFor — same
+        // out-of-scope reasoning as roadmapPhaseMatchesExactPrefix above (only the
+        // five buildPhaseHeadingScanRegex sites in init.cts/milestone.cts are this
+        // phase's owned migration); a direct selector call here would have added
+        // a fourth uncounted ANY_BRACKET consumer to init.cts's pinned
+        // tests/adr-612-bracket-heading-selection.test.cjs census.
+        // phase-id-owner: deliberately unmigrated (#4984 revert) — see comment above.
         const phaseHeader = new RegExp(`#{2,4}\\s*Phase\\s+${escapedPhase}(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:`, 'i');
         const headerMatch = content.match(phaseHeader);
         if (!headerMatch || headerMatch.index === undefined)
@@ -751,6 +768,54 @@ function buildSectionManifestField(cwd, phaseInfo, options, workflow, overrides
 function milestoneRecord(cwd) {
     return (getMilestoneInfo(cwd).value ?? {});
 }
+/**
+ * #4683 — threat IDs claimed by more than one of the phase's live PLAN files.
+ * `scanPhasePlans().planFiles` is the right input set twice over: it excludes
+ * derivative files (OUTLINE / PLAN-REVIEW / pre-bounce) AND `status: superseded`
+ * plans (#2349) — a superseded plan's IDs were deliberately reassigned to its
+ * replacement, so they must not hold against it. The per-document row parse is
+ * planDocument.extractThreatRegisterIds; only `<threat_model>` register rows
+ * count, and the reserved `T-{phase}-SC` shape is excluded there by grammar
+ * (every plan keeps that row by design). A missing/unreadable phase directory
+ * degrades to "no duplicates" — planning a brand-new phase has nothing to
+ * collide with.
+ */
+function findDuplicateThreatIds(cwd, phaseDirRel) {
+    if (!phaseDirRel)
+        return [];
+    const phaseDir = node_path_1.default.join(cwd, phaseDirRel);
+    let planFiles;
+    try {
+        planFiles = scanPhasePlans(phaseDir).planFiles;
+    }
+    catch {
+        return [];
+    }
+    const owners = new Map();
+    for (const planFile of planFiles) {
+        let content;
+        try {
+            content = node_fs_1.default.readFileSync(node_path_1.default.join(phaseDir, planFile), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const id of planDocument.extractThreatRegisterIds(content)) {
+            const claimed = owners.get(id);
+            if (claimed) {
+                if (!claimed.includes(planFile))
+                    claimed.push(planFile);
+            }
+            else {
+                owners.set(id, [planFile]);
+            }
+        }
+    }
+    return [...owners.entries()]
+        .filter(([, claims]) => claims.length > 1)
+        .map(([id, plans]) => ({ id, plans: [...plans].sort() }))
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
 function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
     if (!phase) {
         error('phase required for init execute-phase');
@@ -788,9 +853,14 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
             has_reviews: false,
         };
     });
-    const reqMatch = roadmapPhase?.['section']?.match(REQUIREMENTS_HEADER_RE);
-    const reqExtracted = reqMatch
-        ? reqMatch[1].replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean).join(', ')
+    // #4731: multiline-aware — the Requirements field may hard-wrap, so the
+    // value is extracted past the line break before the ID scan.
+    const phaseSection = roadmapPhase?.['section'];
+    const reqLine = phaseSection
+        ? roadmapParser.extractPhaseFieldMultiline(phaseSection, 'Requirements')
+        : null;
+    const reqExtracted = reqLine
+        ? reqLine.replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean).join(', ')
         : null;
     const phase_req_ids = reqExtracted && reqExtracted !== 'TBD' ? reqExtracted : null;
     // #3188: these paths are null when the file is absent, matching the contract
@@ -800,6 +870,8 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
     const statePath = node_path_1.default.join(planningDir(cwd), 'STATE.md');
     const roadmapPath = node_path_1.default.join(planningDir(cwd), 'ROADMAP.md');
     const requirementsPath = node_path_1.default.join(planningDir(cwd), 'REQUIREMENTS.md');
+    // #4683: computed once — see the threat_id_duplicates fields in the payload.
+    const threatIdDuplicates = findDuplicateThreatIds(cwd, phaseInfo?.['directory']);
     const result = {
         executor_model: resolveModelInternal(cwd, 'gsd-executor'),
         verifier_model: resolveModelInternal(cwd, 'gsd-verifier'),
@@ -819,6 +891,13 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
             ? toPosixPath(node_path_1.default.join(cwd, phaseInfo['directory']))
             : null,
         phase_number: phaseInfo?.['phase_number'] || null,
+        // #4748: the disk path hands back the directory's padded number (`03A`)
+        // but the ROADMAP fallback above hands back the heading's bare one (`3A`),
+        // and execute-phase.md's review lookup needs the padded form for
+        // `{PADDED}-REVIEW.md`. It used to re-pad in shell with `printf "%02d"`,
+        // which cannot pad a letter id and reads an already-padded `08` as octal.
+        // Emit the canonical normalization, as the plan-phase/code-review inits do.
+        padded_phase: phaseInfo?.['phase_number'] ? normalizePhaseName(phaseInfo['phase_number']) : null,
         // #3171: prefer the ROADMAP's curated display name for `phase_name`. When
         // the phase directory already exists on disk, the disk-lookup path
         // (searchPhaseInDir) derives phase_name from the directory-name remainder
@@ -837,6 +916,12 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
         incomplete_plans: phaseInfo?.['incomplete_plans'] || [],
         plan_count: phaseInfo?.['plans']?.length || 0,
         incomplete_count: phaseInfo?.['incomplete_plans']?.length || 0,
+        // #4683: cross-plan threat-ID collisions (gap-closure plans renumbering
+        // from T-{phase}-01 again). execute-phase.md hard-stops on a non-empty
+        // list BEFORE any dispatch — SECURITY.md rows and VALIDATION.md's Threat
+        // Ref column key on this ID, so a reused ID is ambiguous downstream.
+        threat_id_duplicates: threatIdDuplicates,
+        threat_id_duplicate_count: threatIdDuplicates.length,
         // #2830: the halt-aware view, forwarded from the shared computation in
         // phase-locator. Additive — `incomplete_plans`/`incomplete_count` above keep
         // their exact name, type and semantics. Without this passthrough the shared
@@ -930,9 +1015,14 @@ function cmdInitPlanPhase(cwd, phase, raw, options = {}) {
             has_reviews: false,
         };
     });
-    const reqMatch = roadmapPhase?.['section']?.match(REQUIREMENTS_HEADER_RE);
-    const reqExtracted = reqMatch
-        ? reqMatch[1].replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean).join(', ')
+    // #4731: multiline-aware — the Requirements field may hard-wrap, so the
+    // value is extracted past the line break before the ID scan.
+    const phaseSection = roadmapPhase?.['section'];
+    const reqLine = phaseSection
+        ? roadmapParser.extractPhaseFieldMultiline(phaseSection, 'Requirements')
+        : null;
+    const reqExtracted = reqLine
+        ? reqLine.replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean).join(', ')
         : null;
     const phase_req_ids = reqExtracted && reqExtracted !== 'TBD' ? reqExtracted : null;
     const phaseDirPlan = phaseInfo?.['directory'] || null;
@@ -952,6 +1042,8 @@ function cmdInitPlanPhase(cwd, phase, raw, options = {}) {
     }
     const granularityOverride = options['granularity'];
     assertValidGranularityOverride(granularityOverride, error);
+    // #4683: computed once — see the threat_id_duplicates fields in the payload.
+    const threatIdDuplicatesPlan = findDuplicateThreatIds(cwd, phaseDirPlan);
     const granularity = resolveGranularityInternal(cwd, 'planning', granularityOverride || undefined);
     // #3188: see cmdInitExecutePhase — null when absent, parity with the
     // conditional sibling fields in this same result object.
@@ -996,6 +1088,11 @@ function cmdInitPlanPhase(cwd, phase, raw, options = {}) {
         has_reviews: phaseInfo?.['has_reviews'] || false,
         has_plans: (phaseInfo?.['plans']?.length || 0) > 0,
         plan_count: phaseInfo?.['plans']?.length || 0,
+        // #4683: the same cross-plan threat-ID duplicate list execute-phase gates
+        // on, surfaced at PLAN time so the checker/reviewer catches the collision
+        // before the plans are approved — not just before execution.
+        threat_id_duplicates: threatIdDuplicatesPlan,
+        threat_id_duplicate_count: threatIdDuplicatesPlan.length,
         planning_exists: node_fs_1.default.existsSync(planningDir(cwd)),
         roadmap_exists: node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'ROADMAP.md')),
         // #2376: absolute — see comment on phase_dir above.
@@ -1336,7 +1433,7 @@ function cmdInitNewMilestone(cwd, raw, options = {}) {
     // would otherwise silently delete a stale/invalid pointer as a side effect
     // of building a JSON report field, and (per #3579) could change what a
     // LATER resolution in the same process observes.
-    const resolvedWorkstream = process.env['GSD_WORKSTREAM'] || peekActiveWorkstream(cwd);
+    const resolvedWorkstream = resolveEnvWorkstream() ?? peekActiveWorkstream(cwd);
     const workstreamActive = !!resolvedWorkstream;
     const flatMode = !workstreamActive;
     // #2992 (Phase 6.1): additive, optional field — degrades to null, never throws.
@@ -2225,14 +2322,16 @@ function cmdInitMilestoneOp(cwd, raw) {
         const roadmapPath = node_path_1.default.join(planningDir(cwd), 'ROADMAP.md');
         const roadmapRaw = node_fs_1.default.readFileSync(roadmapPath, 'utf-8');
         const currentSection = extractCurrentMilestone(roadmapRaw, cwd);
-        // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag (literal mirror of OPTIONAL_PHASE_TAG_SOURCE).
-        const phasePattern = new RegExp(`#{2,4}\\s*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:`, 'gi');
+        // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag, owned by
+        // buildPhaseHeadingScanRegex (phase-id.cts) so this scan also recognizes
+        // bracket-convention headings instead of hand-rolling a literal `Phase\s+`.
+        const { regex: phasePattern, phaseNumGroup } = buildPhaseHeadingScanRegex(PHASE_HEADING_BASELINE.ANY_BRACKET, resolvePhaseIdConvention(cwd));
         let m;
         while ((m = phasePattern.exec(currentSection)) !== null) {
             // #3185: canonical sentinel predicate (SENTINEL_RANGES [0,999]) — this was a local 999-only literal that admitted Phase 0.
-            if (isSentinelPhaseId(m[1]))
+            if (isSentinelPhaseId(m[phaseNumGroup]))
                 continue;
-            roadmapPhaseNumbers.push(m[1]);
+            roadmapPhaseNumbers.push(m[phaseNumGroup]);
         }
     }
     catch {
@@ -2375,6 +2474,10 @@ function cmdInitManager(cwd, raw) {
     const config = loadConfig(cwd);
     const milestone = milestoneRecord(cwd);
     const _slashRuntime = (0, runtime_slash_cjs_1.resolveRuntime)(cwd);
+    const phaseIdConvention = resolvePhaseIdConvention(cwd);
+    const capturesBracketId = phaseIdConvention === 'bracket';
+    const phaseHeadingPrefix = phaseHeadingPrefixSrcFor(PHASE_HEADING_BASELINE.LABEL_ONLY, phaseIdConvention, capturesBracketId);
+    const phaseHeadingPrefixNoCapture = phaseHeadingPrefixSrcFor(PHASE_HEADING_BASELINE.LABEL_ONLY, phaseIdConvention);
     const paths = planningPaths(cwd);
     if (!node_fs_1.default.existsSync(paths.roadmap)) {
         error(`No ROADMAP.md found. Run ${(0, runtime_slash_cjs_1.formatGsdSlash)('new-milestone', _slashRuntime)} first.`);
@@ -2384,38 +2487,48 @@ function cmdInitManager(cwd, raw) {
     }
     const rawContent = node_fs_1.default.readFileSync(paths.roadmap, 'utf-8');
     const content = extractCurrentMilestone(rawContent, cwd);
-    const phasesDir = paths.phases;
     // #3185 (ADR-3180 Decision 1): "which phase directories belong to the
     // CURRENT milestone" is the scoped question listMilestonePhaseDirs owns —
     // routed through it instead of a hand-rolled readdirSync + a separate
     // getMilestonePhaseFilter window check (which also never excluded
     // sentinels, unlike the owner).
-    const _phaseDirEntries = listMilestonePhaseDirs(phasesDir, { cwd }).value;
     const _checkboxStates = new Map();
-    const _cbPattern = new RegExp(`-\\s*\\[(x| )\\]\\s*.*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})[:\\s]`, 'gi');
+    const _cbPattern = new RegExp(`-\\s*\\[(x| )\\]\\s*.*${phaseHeadingPrefix}(${PHASE_NUMBER_TOKEN_SOURCE})[:\\s]`, 'gi');
     let _cbMatch;
     while ((_cbMatch = _cbPattern.exec(content)) !== null) {
-        _checkboxStates.set(_cbMatch[2], _cbMatch[1].toLowerCase() === 'x');
+        const phaseGroup = capturesBracketId ? 3 : 2;
+        _checkboxStates.set(_cbMatch[phaseGroup], _cbMatch[1].toLowerCase() === 'x');
     }
     // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag (literal mirror of OPTIONAL_PHASE_TAG_SOURCE).
-    const phasePattern = new RegExp(`#{2,4}\\s*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:\\s*([^\\n]+)`, 'gi');
+    const phasePattern = new RegExp(`#{2,4}\\s*${phaseHeadingPrefix}(${PHASE_NUMBER_TOKEN_SOURCE})(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:\\s*([^\\n]+)`, 'gi');
     const phases = [];
     let match;
     while ((match = phasePattern.exec(content)) !== null) {
-        const phaseNum = match[1];
-        const phaseName = match[2].replace(/\(INSERTED\)/i, '').trim();
+        const bracketId = capturesBracketId ? match[1] : undefined;
+        const phaseNum = capturesBracketId ? match[2] : match[1];
+        const phaseName = (capturesBracketId ? match[3] : match[2])
+            .replace(/\(INSERTED\)/i, '')
+            .trim();
+        let displayId;
+        if (bracketId) {
+            try {
+                displayId = renderPhaseId(parsePhaseId(`${bracketId}-${phaseNum}`));
+            }
+            catch {
+                // The bracket selector is deliberately read-tolerant. If a heading is
+                // non-canonical, retain the manager row without fabricating display_id.
+            }
+        }
         const sectionStart = match.index;
         const restOfContent = content.slice(sectionStart);
-        const nextHeader = restOfContent.match(/\n#{2,4}\s+Phase\s+\d[\d.]*/i);
+        const nextHeader = restOfContent.match(new RegExp(`\\n#{2,4}\\s+${phaseHeadingPrefixNoCapture}\\d[\\d.]*`, 'i'));
         const sectionEnd = nextHeader
             ? sectionStart + nextHeader.index
             : content.length;
         const section = content.slice(sectionStart, sectionEnd);
-        const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
-        const goal = goalMatch ? goalMatch[1].trim() : null;
+        const goal = roadmapParser.extractPhaseFieldMultiline(section, 'Goal');
         const dependsMatch = section.match(/\*\*Depends on(?::\*\*|\*\*:)\s*([^\n]+)/i);
         const depends_on = dependsMatch ? dependsMatch[1].trim() : null;
-        const normalized = normalizePhaseName(phaseNum);
         let diskStatus = 'no_directory';
         let planCount = 0;
         let summaryCount = 0;
@@ -2428,14 +2541,23 @@ function cmdInitManager(cwd, raw) {
         let contextScope = SCOPE.COMPLETE;
         let completion = buildPhaseCompletionProjection(cwd, phaseNum, null, planCount, summaryCount, _slashRuntime);
         try {
-            // #3185 (ADR-3180 Decision 2) moved this lookup off the
-            // milestone-scoped set and onto the physical one; that scope choice is
-            // kept. Only the matcher is this PR's: matchPhaseDirs resolves
-            // digit-leading directory names the token predicate cannot (#2528).
-            const dirMatch = matchPhaseDirs(_phaseDirEntries, normalized).matches[0];
+            // #4801: resolve through the canonical locator instead of a private
+            // current-milestone-only scan. findPhaseInternal searches the live
+            // .planning/phases directory FIRST (same set the retired
+            // matchPhaseDirs/_phaseDirEntries pair scanned — the #3185 physical-dir
+            // scope choice is inherited by the locator's live arm) and then falls
+            // back through listArchiveVersionDirs (workstream-scoped, #2855), so an
+            // ARCHIVED phase directory with a passing verification resolves instead
+            // of reporting no_directory/phase_complete:false. Five other init
+            // commands already route through this same primitive; this was the
+            // holdout private copy (#4793-family declared-owner drift).
+            const located = findPhaseInternal(cwd, phaseNum, phaseIdConvention);
+            const dirMatch = located && located['found']
+                ? node_path_1.default.posix.basename(String(located['directory']))
+                : null;
             if (dirMatch) {
-                const fullDir = node_path_1.default.join(phasesDir, dirMatch);
-                const phaseDirRel = toPosixPath(node_path_1.default.relative(cwd, fullDir));
+                const fullDir = node_path_1.default.join(cwd, String(located['directory']));
+                const phaseDirRel = String(located['directory']);
                 // #4014 (epic #3473 B4-unreadable): this whole block used to swallow
                 // ANY readdirSync failure below into the bare `catch { /* empty */ }`
                 // at the bottom — an unreadable phase directory reported the exact
@@ -2509,6 +2631,7 @@ function cmdInitManager(cwd, raw) {
         const roadmapComplete = _checkboxStates.get(phaseNum) || false;
         phases.push({
             number: phaseNum,
+            ...(displayId ? { display_id: displayId } : {}),
             name: phaseName,
             goal,
             depends_on,
@@ -2549,7 +2672,7 @@ function cmdInitManager(cwd, raw) {
         .filter((p) => p['phase_complete'] === true)
         .map((p) => normalizePhaseNumber(p['number'])));
     const phaseMap = new Map(phases.map((p) => [normalizePhaseNumber(p['number']), p]));
-    const _allCompletedPattern = new RegExp(`-\\s*\\[x\\]\\s*.*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})[:\\s]`, 'gi');
+    const _allCompletedPattern = new RegExp(`-\\s*\\[x\\]\\s*.*${phaseHeadingPrefixNoCapture}(${PHASE_NUMBER_TOKEN_SOURCE})[:\\s]`, 'gi');
     let _allMatch;
     while ((_allMatch = _allCompletedPattern.exec(rawContent)) !== null) {
         const phaseNum = normalizePhaseNumber(_allMatch[1]);
@@ -2575,13 +2698,47 @@ function cmdInitManager(cwd, raw) {
     function hasDepRelationship(numA, numB) {
         return reaches(numA, numB) || reaches(numB, numA);
     }
+    // #4764: a phase reference in depends_on prose is a PHASE-SHAPED token in
+    // context — directly following "Phase"/"Phases" — never a bare digit run.
+    // The previous whole-field scrape matched the token grammar against every
+    // digit run, so calendar dates ("2026-09-14" → 2026, 09, 14), git shas
+    // ("8bf403100d" → 8b, 403100d, …), bracketed ledger ids (WINDOWS #1843) and
+    // the row's OWN number all became "dependencies", and deps_satisfied came
+    // back false for phases whose prose declares none (50 of 92 phases in the
+    // reporter's milestone). The anchored grammar (owned by phase-id.cts as
+    // PHASE_DEP_REF_SOURCE, shared with planning-inspect's dependencies) keeps
+    // lists fully extracted ("Phases 601 and 602", "Phase 601, 602, and 603",
+    // "Phase 1-3") — silently dropping a REAL dependency would clear
+    // deps_satisfied prematurely, the dangerous direction. Negation prose
+    // ("dropped the dependency on Phase 654") is NOT detected: the issue's own
+    // minimum keeps such tokens.
+    const depPhaseRefRe = new RegExp(`${PHASE_DEP_REF_SOURCE}`, 'gi');
+    const depTokenRe = new RegExp(`${PHASE_NUMBER_TOKEN_SOURCE}`, 'gi');
     for (const phase of phases) {
         if (!phase['depends_on'] ||
             /^none$/i.test(phase['depends_on'].trim())) {
             phase['deps_satisfied'] = true;
         }
         else {
-            const depNums = phase['depends_on'].match(new RegExp(`${PHASE_NUMBER_TOKEN_SOURCE}`, 'gi')) || [];
+            const prose = phase['depends_on'];
+            const ownNumber = normalizePhaseNumber(phase['number']);
+            const depNums = [];
+            const seen = new Set();
+            let refMatch;
+            depPhaseRefRe.lastIndex = 0;
+            while ((refMatch = depPhaseRefRe.exec(prose)) !== null) {
+                let tok;
+                depTokenRe.lastIndex = 0;
+                while ((tok = depTokenRe.exec(refMatch[1])) !== null) {
+                    const normalized = normalizePhaseNumber(tok[0]);
+                    if (normalized === ownNumber)
+                        continue; // #4764: never the row's own phase
+                    if (seen.has(normalized))
+                        continue;
+                    seen.add(normalized);
+                    depNums.push(tok[0]);
+                }
+            }
             phase['deps_satisfied'] = depNums.every((n) => completedNums.has(normalizePhaseNumber(n)));
             phase['dep_phases'] = depNums;
         }
@@ -2921,7 +3078,7 @@ function cmdInitUpdate(cwd, raw, options = {}) {
 function cmdInitTransition(cwd, raw, options = {}) {
     // #3579 root-cause fix: read-only informational field — peek, don't
     // self-heal (see cmdInitNewMilestone's identical rationale above).
-    const resolvedWorkstream = process.env['GSD_WORKSTREAM'] || peekActiveWorkstream(cwd);
+    const resolvedWorkstream = resolveEnvWorkstream() ?? peekActiveWorkstream(cwd);
     const workstreamActive = !!resolvedWorkstream;
     const result = {
         other_active_workstreams: workstreamActive
@@ -3013,7 +3170,7 @@ function cmdInitProgress(cwd, raw, options = {}) {
     // non-mutating peek so an unresolvable pointer isn't self-healed (cleared)
     // here and then found "absent" by diagnoseUnresolvedActiveWorkstream below,
     // which would misreport a present-but-bad marker as no marker at all.
-    const _resolvedWorkstream = process.env['GSD_WORKSTREAM'] || peekActiveWorkstream(cwd);
+    const _resolvedWorkstream = resolveEnvWorkstream() ?? peekActiveWorkstream(cwd);
     if (_availableWorkstreams.length > 0 && !_resolvedWorkstream) {
         // #3579: getActiveWorkstream now inherits a pointer-less session's read
         // from the shared .planning/active-workstream marker, so reaching this
@@ -3040,13 +3197,22 @@ function cmdInitProgress(cwd, raw, options = {}) {
     const roadmapCheckboxStates = new Map();
     try {
         const roadmapContent = extractCurrentMilestone(node_fs_1.default.readFileSync(node_path_1.default.join(planningDir(cwd), 'ROADMAP.md'), 'utf-8'), cwd);
-        // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag (literal mirror of OPTIONAL_PHASE_TAG_SOURCE).
-        const headingPattern = new RegExp(`#{2,4}\\s*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:\\s*([^\\n]+)`, 'gi');
+        const progressConvention = resolvePhaseIdConvention(cwd);
+        // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag, owned by
+        // buildPhaseHeadingScanRegex (phase-id.cts) so this scan also recognizes
+        // bracket-convention headings instead of hand-rolling a literal `Phase\s+`.
+        const { regex: headingPattern, phaseNumGroup: hNumGroup, phaseNameGroup: hNameGroup } = buildPhaseHeadingScanRegex(PHASE_HEADING_BASELINE.ANY_BRACKET, progressConvention);
         let hm;
         while ((hm = headingPattern.exec(roadmapContent)) !== null) {
-            roadmapPhaseNums.add(hm[1]);
-            roadmapPhaseNames.set(hm[1], hm[2].replace(/\(INSERTED\)/i, '').trim());
-        }
+            roadmapPhaseNums.add(hm[hNumGroup]);
+            roadmapPhaseNames.set(hm[hNumGroup], hm[hNameGroup].replace(/\(INSERTED\)/i, '').trim());
+        }
+        // #4906 Phase 5 (#4984): NOT migrated onto phaseHeadingPrefixSrcFor — same
+        // out-of-scope reasoning as roadmapPhaseMatchesExactPrefix/detectPhaseMvpMode
+        // above; a direct LABEL_ONLY selector call here would have added a third
+        // uncounted LABEL_ONLY consumer to init.cts's pinned
+        // tests/adr-612-bracket-heading-selection.test.cjs census.
+        // phase-id-owner: deliberately unmigrated (#4984 revert) — see comment above.
         const cbPattern = new RegExp(`-\\s*\\[(x| )\\]\\s*.*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})[:\\s]`, 'gi');
         let cbm;
         while ((cbm = cbPattern.exec(roadmapContent)) !== null) {

package/gsd-core/bin/lib/install-engine.cjs

@@ -730,6 +730,16 @@ function _copyStaged(stagedDir, destDir, kind, configDir, runtime) {
             continue;
         if (!entry.name.endsWith('.md'))
             continue;
+        // #4782: compact agent variants are consumed ONLY through the non-claude
+        // gate in init.cts's agent-skills persona fallback (`runtime !== 'claude'`
+        // — claude's contract is a skills-injection path, never a persona
+        // fallback). Staging them into Claude's agents directory shipped 29 dead
+        // files whose `name:` frontmatter is identical to their canonical
+        // sibling's, leaving the harness resolution unstated. Claude never
+        // selects compact, so claude is the one runtime whose agents kind skips
+        // them; every other runtime's emission is byte-identical.
+        if (kind.kind === 'agents' && runtime === 'claude' && entry.name.endsWith('.compact.md'))
+            continue;
         const stem = entry.name.slice(0, -3); // strip .md
         let destName;
         if (kind.kind === 'agents') {
@@ -1881,6 +1891,9 @@ function installOpencodeFamilyArtifacts(runtime, configDir, scope, resolvedProfi
         isWindowsHost: process.platform === 'win32',
         resolvedTarget: (0, shell_command_projection_cjs_1.posixNormalize)(node_path_1.default.resolve(configDir)),
         homeDir: (0, shell_command_projection_cjs_1.posixNormalize)(node_os_1.default.homedir()),
+        // #4377: the runtime's own localConfigDir, so an opted-in local install
+        // emits `<dir>/...` instead of this checkout's absolute path.
+        localDirName: runtimeArtifactConversion._localIncludeDirName(runtime),
     });
     // #2329: destDir is derived from the SAME hostBehaviors.flatCommandDir
     // descriptor value read by writeManifest's manifest-key prefix and by

package/gsd-core/bin/lib/installer-migrations.cjs

@@ -280,7 +280,14 @@ function readInstallManifest(configDir) {
         version: typeof m.version === 'string' ? m.version : null,
         timestamp: typeof m.timestamp === 'string' ? m.timestamp : null,
         mode: typeof m.mode === 'string' ? m.mode : null,
-        files: m.files && typeof m.files === 'object' ? m.files : {},
+        // #4544 (review): `typeof [] === 'object'` — a manifest whose `files` is a
+        // JSON array passed the object-shape guard, and Object.keys() then yielded
+        // "0","1",... as install-relative file paths. Consumers iterate these keys,
+        // so an array shape must degrade to the empty set exactly like a
+        // non-object shape does.
+        files: m.files && typeof m.files === 'object' && !Array.isArray(m.files)
+            ? m.files
+            : {},
         manifestVersion: normalizeManifestVersion(m.manifestVersion),
         runtime: normalizeReportedRuntime(rawRuntime),
         scope: (0, install_scope_cjs_1.isInstallScopeId)(m.scope) ? m.scope : null,

package/gsd-core/bin/lib/milestone.cjs

@@ -38,7 +38,7 @@ const stateContract = require("./state-contract.cjs");
 const { publishStateContract } = stateContract;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const phaseIdMod = require("./phase-id.cjs");
-const { normalizePhaseName, matchPhaseDirs, PHASE_NUMBER_TOKEN_SOURCE, isSentinelPhaseId, isSentinelPhaseDir } = phaseIdMod;
+const { normalizePhaseName, matchPhaseDirs, isSentinelPhaseId, isSentinelPhaseDir, buildPhaseHeadingScanRegex, PHASE_HEADING_BASELINE } = phaseIdMod;
 const pattern_cjs_1 = require("./pattern.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const roadmapParserMod = require("./roadmap-parser.cjs");
@@ -642,8 +642,21 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
             // windows converge to the same value regardless of which version drove
             // the lookup.
             const scopedContent = sliceMilestoneWindow(roadmapContent, version) ?? extractCurrentMilestone(roadmapContent, cwd);
-            // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag (literal mirror of OPTIONAL_PHASE_TAG_SOURCE).
-            const phasePattern = new RegExp(`#{2,4}\\s*Phase\\s+(${PHASE_NUMBER_TOKEN_SOURCE})(?:\\s*\\([^)\\n]{0,200}\\))?\\s*:\\s*([^\\n]+)`, 'gi');
+            // #1729: `(?:\s*\([^)\n]{0,200}\))?` tolerates a pre-colon ( ) tag, owned
+            // by buildPhaseHeadingScanRegex (phase-id.cts) so this guard also
+            // recognizes bracket-convention headings instead of hand-rolling a
+            // literal `Phase\s+`.
+            // #4984 fix: resolved ONCE and threaded into BOTH the heading scan and
+            // the disk-side matchPhaseDirs check below — the heading scan alone
+            // recognizing `[GSD.02] 01:` and extracting the bare phase-number token
+            // "01" is only half the fix. Without also passing this convention to
+            // matchPhaseDirs, its bracket-qualified match arm never fires, "01"
+            // matches no bracket directory name ("GSD.02-01-setup"), and every
+            // properly-scaffolded bracket phase reads as disk_status: 'no_directory'
+            // — turning a real bracket project's own phases into false "ROADMAP
+            // lists N unstarted phase(s)" failures on `milestone complete`.
+            const convention = resolvePhaseIdConvention(cwd);
+            const { regex: phasePattern, phaseNumGroup } = buildPhaseHeadingScanRegex(PHASE_HEADING_BASELINE.ANY_BRACKET, convention);
             const noDirectoryPhases = [];
             let pm;
             const phaseDirEntries = (() => {
@@ -658,7 +671,7 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
                 }
             })();
             while ((pm = phasePattern.exec(scopedContent)) !== null) {
-                const phaseNum = pm[1];
+                const phaseNum = pm[phaseNumGroup];
                 // Phase 0 (pre-milestone) and Phase 999 (backlog) are sentinels, not
                 // real phases — they legitimately have no directory and must not block
                 // milestone completion. Mirrors the engine-wide sentinel convention
@@ -672,7 +685,7 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
                 // with a matching token exists on disk. Use the same matchPhaseDirs
                 // owner that roadmap.analyze uses to avoid false positives on decimal
                 // (2.1) and letter-suffix (12A) phase IDs. (#2528)
-                const hasDirectory = matchPhaseDirs(phaseDirEntries, normalized).matches.length > 0;
+                const hasDirectory = matchPhaseDirs(phaseDirEntries, normalized, convention).matches.length > 0;
                 if (!hasDirectory) {
                     noDirectoryPhases.push(phaseNum);
                 }