@opengsd/gsd-core 1.18.0 → 1.19.0

package/gsd-core/bin/lib/roadmap-parser.cjs

@@ -78,6 +78,17 @@ function isClosedMilestoneHeading(headingText) {
 function stripShippedMilestones(content) {
     return (0, markdown_sectionizer_cjs_1.stripTaggedBlocks)(content, 'details');
 }
+/**
+ * #5543: run `edit` over the ROADMAP with every shipped `<details>` block hidden
+ * and restored byte-for-byte afterwards. For writers whose active milestone
+ * could not be resolved: the first `### Phase N:` in document order must never
+ * be the one inside a shipped block. Layout-independent (the active phase may
+ * sit before or after a shipped block) and, unlike a "region after the last
+ * `</details>`" cut, not fooled by a `</details>` in a fence or inline code.
+ */
+function editOutsideShippedBlocks(content, edit) {
+    return (0, markdown_sectionizer_cjs_1.editOutsideTaggedBlocks)(content, 'details', edit);
+}
 /**
  * #3982: strip only <details> blocks whose <summary> marks a CLOSED milestone
  * (ARCHIVED/SHIPPED/✅/… without an active marker) — the narrow form of
@@ -2287,6 +2298,7 @@ module.exports = {
     getMilestonePhaseFilter,
     currentMilestoneRawRanges,
     withPhaseSection,
+    editOutsideShippedBlocks,
     computeMilestoneSectionEnd,
     locateMilestoneHeadings,
     listMilestoneHeadings,

package/gsd-core/bin/lib/roadmap-upgrade.cjs

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const planningWorkspace = require("./planning-workspace.cjs");
@@ -1923,7 +1922,45 @@ function applyMigration(cwd, plan, options = {}) {
     // ── Real run: verify clean working tree ───────────────────────────────────
     let gitStatus;
     try {
-        gitStatus = (0, node_child_process_1.execSync)('git status --porcelain', { cwd, encoding: 'utf8', windowsHide: true, timeout: 10_000 });
+        // #5048: this is a read-only spawn, but git still refreshes the index under
+        // it and takes the optional `.git/index.lock` to write the refreshed copy
+        // back — which can lose a race against a real `git add` / `git commit` in
+        // the same repo. Routing through the shared execGit seam (CONTEXT.md, OS
+        // Shell Projection) is what gets GIT_OPTIONAL_LOCKS=0 here; a bare execSync
+        // bypassed the seam and therefore the opt-out, so this call site was the one
+        // read-only `git status` the seam change did not reach. shell-free, so no
+        // argv quoting or PATH-resolution policy is introduced.
+        const statusTimeoutMs = 10_000;
+        const result = (0, shell_command_projection_cjs_1.execGit)(['status', '--porcelain'], { cwd, timeout: statusTimeoutMs });
+        // #5048: execSync carried the cause on the thrown error. execGit reports a
+        // timeout, a spawn/buffer failure or a signal through `timedOut`/`error`/
+        // `signal` with an exit code of `status ?? 1` and often an empty stderr.
+        // Order matters: a maxBuffer overflow returns signal SIGTERM *and*
+        // error.code ENOBUFS — check `error` before `signal` so the real cause is
+        // not reported as "killed by SIGTERM". Only a genuine non-zero exit falls
+        // through. (ENOENT is rewritten by `_spawnResult` to exit 127 + stderr.)
+        if (result.timedOut) {
+            throw new Error(`git status timed out after ${statusTimeoutMs} ms`);
+        }
+        if (result.error) {
+            // The cause is not always a failed spawn: ENOBUFS and EPERM reach this
+            // branch with the process already started (a maxBuffer overflow returns
+            // signal SIGTERM *and* error.code ENOBUFS). So the message stays neutral
+            // about starting and names the code instead of inferring a cause from it.
+            const code = result.error.code;
+            const why = code === 'ENOBUFS' ? 'output exceeded the buffer' : code;
+            const detail = why && !result.error.message.includes(why)
+                ? `${result.error.message} (${why})`
+                : result.error.message;
+            throw new Error(detail);
+        }
+        if (result.signal) {
+            throw new Error(`git status was killed by ${result.signal}`);
+        }
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr || `git exited ${result.exitCode}`);
+        }
+        gitStatus = result.stdout;
     }
     catch (err) {
         throw new Error(`git status failed: ${err.message}`);

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

@@ -1111,13 +1111,26 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
         // Heading target: the exact grammar `planSectionPattern` /
         // `insertRowsPatternA|B` anchor on (an ATX phase heading for this phase).
         const headingTargetFound = new RegExp(phaseHeadingAnchor, 'i').test(gateActiveRegion);
+        // #5545: the phase-checklist bullet grammar, defined ONCE for the writer
+        // (an unchecked bullet to tick) and the gate probe (`anyState`).
+        // Line-anchored, with only an optional `**` before the label and horizontal
+        // whitespace, so a bullet that merely MENTIONS "Phase N" is not the phase's
+        // bullet and no `\s` can run past the line end (which used to land the
+        // `(completed …)` annotation on the NEXT line). A decorated bullet (emoji,
+        // blockquote, link) is deliberately NOT the phase's bullet either — the
+        // same narrowing #4965 made for `roadmap analyze`'s checklist reader.
+        // The lookahead only PEEKS (its `\s` may see a newline but consumes none):
+        // the label must be followed by `:`, whitespace or the end of the line, so
+        // `Phase 2.1` / `Phase 20` are not `Phase 2`. Capture group 1 is the opening
+        // `- [`, group 2 the rest of the line after the box.
+        const phaseChecklistBullet = (anyState) => new RegExp(`^([ \\t]*-[ \\t]*\\[)${anyState ? '[ x]' : ' '}(\\][ \\t]*(?:\\*\\*)?[ \\t]*Phase[ \\t]+${phasePattern}${OPTIONAL_PHASE_TAG_SOURCE}(?=[:\\s]|$)[^\\n]*)`, 'im');
         // Checklist target: when the phase is complete, its own checklist bullet
         // (`- [ ] **Phase N: …**`) IS a writable phase row — the completion
         // checkbox stamp below updates it. Same grammar as that writer, widened
         // one notch to `[ x]` so an ALREADY-checked bullet still counts as a
         // found target: an idempotent re-run then takes the honest
         // "no changes were needed" decline instead of this refusal.
-        const checklistTargetFound = isComplete && new RegExp(`-\\s*\\[[ x]\\]\\s*.*Phase\\s+${phasePattern}${OPTIONAL_PHASE_TAG_SOURCE}[:\\s]`, 'i').test(gateActiveRegion);
+        const checklistTargetFound = isComplete && phaseChecklistBullet(true).test(gateActiveRegion);
         // Table-row target: set by the row-scoped cell updates below.
         let tableRowFound = false;
         // Progress table row: update Plans Complete/Status/Completed columns BY
@@ -1399,24 +1412,25 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
         });
         // If complete: check checkbox
         if (isComplete) {
-            const checkboxPattern = new RegExp(`(-\\s*\\[)[ ](\\]\\s*.*Phase\\s+${phasePattern}${OPTIONAL_PHASE_TAG_SOURCE}[:\\s][^\\n]*)`, 'i');
-            roadmapContent = replaceInCurrentMilestone(roadmapContent, checkboxPattern, `$1x$2 (completed ${today})`);
+            roadmapContent = replaceInCurrentMilestone(roadmapContent, phaseChecklistBullet(false), `$1x$2 (completed ${today})`);
         }
         // Mark completed plan checkboxes (e.g. "- [ ] 50-01-PLAN.md", "- [ ] 50-01:", or "- [ ] **50-01**")
         // #4741: tick only plans the phase's own COUNT still counts. `plans` is the
         // superseded-filtered set (#2349 via scanPhasePlans) while `summaries` is
         // the raw *-SUMMARY.md listing — a superseded plan can carry a SUMMARY
         // (e.g. `status: halted`), and ticking it read as "executed" right under a
-        // count line that excludes it. The prefix match mirrors the checkbox regex
-        // below (rows match by planId prefix, which the PLAN-01.md naming shape
-        // relies on), so non-superseded plans tick exactly as before.
+        // count line that excludes it. #5542: a summary belongs to a live plan only
+        // by the SAME pairing rule the counts use (`summaryCandidates` via
+        // `countMatchedSummaries`), never by id prefix — a leftover `47-1` summary
+        // must not survive because a live `47-10` plan starts with `47-1`. Rows
+        // match the id up to a boundary (`planRowPattern`), so `47-1` never ticks
+        // `47-10-PLAN.md`.
         const tickableSummaries = phaseInfo.summaries
             .map((summaryFile) => ({ summaryFile, planId: summaryFile.replace('-SUMMARY.md', '').replace('SUMMARY.md', '') }))
-            .filter(({ planId }) => planId !== '' && phaseInfo.plans.some((planFile) => planFile.startsWith(planId)));
+            .filter(({ summaryFile, planId }) => planId !== ''
+            && coreUtils.summaryPairsWithAnyPlan(phaseInfo.plans, summaryFile));
         for (const { planId } of tickableSummaries) {
-            const planEscaped = (0, pattern_cjs_1.escapeRegex)(planId);
-            const planCheckboxPattern = new RegExp(`(-\\s*\\[) (\\]\\s*(?:\\*\\*)?${planEscaped}(?:\\*\\*)?)`, 'i');
-            roadmapContent = roadmapContent.replace(planCheckboxPattern, '$1x$2');
+            roadmapContent = roadmapContent.replace(coreUtils.planRowPattern(planId), '$1x$2');
         }
         // Compute the active (post-</details>) region offset ONCE.  Both the
         // missing-plan DETECTION and the row INSERTION must use the same active
@@ -1440,23 +1454,19 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
         //
         // #4786: a plan row may be written WITH the `-PLAN.md` suffix (canonical
         // template form) or WITHOUT it (hand-written form: `- [x] 659-01 — desc`).
-        // The tick loop above keys on the bare planId stem with a PREFIX match
-        // (pre-existing, out of scope here), while detection required the full
-        // `-PLAN.md` filename — so every suffix-less row was counted missing and
-        // the insertion fired BESIDE the recognized list — 32 checkbox lines for
-        // 16 plans, exit 0. The stem arm below accepts the bare id only up to a
-        // boundary (whitespace / `:` / dashes / `-PLAN.md` / `.md` / `**` / `)`),
-        // so `5-011` never satisfies `5-01`. Deliberately NOT in the boundary set:
-        // `.` — a dotted sub-id (`5-01.5`) is a real distinct plan, and counting
-        // its row as 5-01's presence would suppress a genuine insertion.
+        // The tick loop above keys on the bare planId stem, while detection required
+        // the full `-PLAN.md` filename — so every suffix-less row was counted
+        // missing and the insertion fired BESIDE the recognized list — 32 checkbox
+        // lines for 16 plans, exit 0. The stem arm below accepts the bare id only
+        // up to the SAME boundary the tick loop uses (`planRowPattern`, #5542), so
+        // `5-011` never satisfies `5-01` and a dotted sub-id (`5-01.5`) is a real
+        // distinct plan whose row does not count as 5-01's presence.
         const missingPlans = phaseInfo.plans.filter((planFile) => {
             const planEscaped = (0, pattern_cjs_1.escapeRegex)(planFile);
             if (new RegExp(`-\\s*\\[[x ]\\]\\s*(?:\\*\\*)?${planEscaped}`, 'i').test(activeRegion))
                 return false;
             const stem = planFile.replace(/-PLAN\.md$/i, '');
-            const stemEscaped = (0, pattern_cjs_1.escapeRegex)(stem);
-            const stemPresent = new RegExp(`-\\s*\\[[x ]\\]\\s*(?:\\*\\*)?${stemEscaped}(?=$|\\s|:|—|–|-PLAN\\.md|\\.md|\\*\\*|\\))`, 'i').test(activeRegion);
-            return !stemPresent;
+            return !coreUtils.planRowPattern(stem, { anyState: true }).test(activeRegion);
         });
         if (missingPlans.length > 0) {
             // Insert missing plan checklist rows (#1163).  We prefer to anchor to the
@@ -1502,9 +1512,7 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
                 // (#4741: same superseded-filtered tick list as the loop above — a
                 // pre-existing superseded row must stay unchecked on this path too).
                 for (const { planId } of tickableSummaries) {
-                    const planEscaped = (0, pattern_cjs_1.escapeRegex)(planId);
-                    const planCheckboxPattern = new RegExp(`(-\\s*\\[) (\\]\\s*(?:\\*\\*)?${planEscaped}(?:\\*\\*)?)`, 'i');
-                    roadmapContent = roadmapContent.replace(planCheckboxPattern, '$1x$2');
+                    roadmapContent = roadmapContent.replace(coreUtils.planRowPattern(planId), '$1x$2');
                 }
             }
         }