@opengsd/gsd-core 1.6.0-rc.3 → 1.6.1

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

@@ -205,20 +205,59 @@ function reconstructFrontmatter(obj) {
     }
     return lines.join('\n');
 }
+/**
+ * Slice a frontmatter YAML body into per-top-level-key raw text segments. Each segment
+ * runs from a column-0 `key:` line through the line before the next column-0 key (or the
+ * end), capturing all nested indented content. Used by `spliceFrontmatter` for per-key
+ * identity preservation (#1572): a structurally-unchanged key keeps its original raw
+ * text, so the lossy `reconstructFrontmatter` never touches object-lists the caller did
+ * not modify (e.g. must_haves.artifacts / .prohibitions).
+ */
+function sliceTopLevelFrontmatterSegments(yaml) {
+    const lines = yaml.split(/\r?\n/);
+    const segments = [];
+    let current = null;
+    for (const line of lines) {
+        // A column-0 `key:` (no leading whitespace) starts a new top-level segment.
+        if (/^[A-Za-z0-9_-]+:/.test(line)) {
+            if (current)
+                segments.push({ key: current.key, raw: current.raw.join('\n') });
+            const keyName = line.match(/^([A-Za-z0-9_-]+):/)[1];
+            current = { key: keyName, raw: [line] };
+        }
+        else if (current) {
+            current.raw.push(line);
+        }
+        // Stray lines before the first top-level key (rare in frontmatter) are dropped.
+    }
+    if (current)
+        segments.push({ key: current.key, raw: current.raw.join('\n') });
+    return segments;
+}
+/**
+ * Regenerate one frontmatter key's serialization, fail-closed if the lossy
+ * `reconstructFrontmatter` cannot represent the value (#1572 codex review). Object-list
+ * items (e.g. must_haves.artifacts `{path, provides}` maps) serialize as the literal
+ * string "[object Object]"; rather than silently emit that and destroy the data, refuse
+ * so the caller (cmdFrontmatterSet/Merge) errors out WITHOUT writing — directing the
+ * user to edit the file directly. The reported #1572 case (mutating an UNRELATED field)
+ * is unaffected: unchanged keys preserve their original raw text and never reach here.
+ */
+function regenerateFrontmatterKey(key, value) {
+    const rendered = reconstructFrontmatter({ [key]: value });
+    if (/\[object Object\]/.test(rendered)) {
+        throw new Error(`frontmatter: cannot faithfully serialize key "${key}" — it contains a nested object-list ` +
+            `(e.g. must_haves.artifacts) the frontmatter writer cannot represent, and serializing it would ` +
+            `emit "[object Object]". Edit the file directly instead of using frontmatter set/merge.`);
+    }
+    return rendered;
+}
 function spliceFrontmatter(content, newObj) {
     const match = content.match(/^---\r?\n[\s\S]+?\r?\n---/);
     if (match) {
-        // Identity-preservation (additive, lossless round-trip): `reconstructFrontmatter` is a
-        // deliberately lossy serializer — it cannot faithfully re-emit nested object-list items
-        // (e.g. must_haves.artifacts / must_haves.prohibitions, whose items are `{ path, provides }`
-        // / `{ statement, status, … }` maps). When the caller is writing back a value that is
-        // STRUCTURALLY UNCHANGED from the original parse (the canonical CRUD round-trip and the
-        // #644 prohibition schema round-trip both do this), regenerating from the lossy object would
-        // silently mangle those blocks. Detect that case by deep-equality against a re-parse of the
-        // original frontmatter and preserve the ORIGINAL raw text verbatim — a true no-op splice.
-        // This touches neither the parser (`extractFrontmatter`) nor `parseMustHavesBlock`; it only
-        // makes the existing splice faithful when nothing changed. A genuine mutation (different
-        // object) still flows through `reconstructFrontmatter` exactly as before.
+        const fmBlock = match[0];
+        // Whole-document no-op guard: a true no-op returns content verbatim (byte-exact,
+        // including any formatting the lossy serializer would normalize).
         try {
             if (frontmatterDeepEqual(extractFrontmatter(content), newObj)) {
                 return content;
@@ -227,10 +266,63 @@ function spliceFrontmatter(content, newObj) {
         catch {
             /* fall through to regeneration on any comparison hiccup */
         }
-        const yamlStr = reconstructFrontmatter(newObj);
-        return `---\n${yamlStr}\n---` + content.slice(match[0].length);
+        // Per-key identity preservation (#1572). `reconstructFrontmatter` is a deliberately
+        // lossy serializer — it cannot faithfully re-emit nested object-list items (e.g.
+        // must_haves.artifacts / .prohibitions, whose items are `{ path, provides }` /
+        // `{ statement, status }` maps; `extractFrontmatter` flattens those to scalar
+        // strings, so a round-trip drops `provides:` and collapses the list to a malformed
+        // inline array). For any top-level key whose value is STRUCTURALLY UNCHANGED between
+        // the original parse and `newObj`, preserve that key's ORIGINAL raw text verbatim;
+        // regenerate only keys that actually changed. This generalizes the whole-document
+        // no-op guard above to per-key fidelity, so mutating `wave` no longer destroys an
+        // unrelated `must_haves` block. Keys absent from the original (genuinely new) are
+        // regenerated and appended; keys absent from `newObj` are preserved (never silently
+        // deleted by a set/merge).
+        const fmLines = fmBlock.split(/\r?\n/);
+        const inner = fmLines.slice(1, -1).join('\n'); // drop the opening `---` and closing `---`
+        let originalParsed;
+        try {
+            originalParsed = extractFrontmatter(fmBlock);
+        }
+        catch {
+            originalParsed = {};
+        }
+        const segments = sliceTopLevelFrontmatterSegments(inner);
+        const emitted = [];
+        const seen = new Set();
+        for (const seg of segments) {
+            seen.add(seg.key);
+            if (Object.prototype.hasOwnProperty.call(newObj, seg.key)) {
+                // Key is in newObj: preserve original raw text if structurally unchanged,
+                // otherwise regenerate. The key SET is defined by newObj — keys that were in
+                // the original but are absent from newObj are intentionally dropped (the real
+                // cmdSet/cmdMerge flow always passes the full merged object, so this only
+                // matters for direct unit callers and matches spliceFrontmatter's contract:
+                // the result frontmatter IS newObj).
+                if (frontmatterDeepEqual(newObj[seg.key], originalParsed[seg.key])) {
+                    emitted.push(seg.raw); // unchanged → preserve original raw text verbatim
+                }
+                else {
+                    emitted.push(regenerateFrontmatterKey(seg.key, newObj[seg.key])); // changed → regenerate (fail-closed on object-lists)
+                }
+            }
+            // else: key absent from newObj → drop (not emitted).
+        }
+        // Append genuinely-new keys not present in the original frontmatter.
+        for (const k of Object.keys(newObj)) {
+            if (!seen.has(k)) {
+                emitted.push(regenerateFrontmatterKey(k, newObj[k]));
+            }
+        }
+        const yamlStr = emitted.join('\n');
+        return `---\n${yamlStr}\n---` + content.slice(fmBlock.length);
     }
+    // No existing frontmatter — generate from scratch, fail-closed on unrepresentable values.
     const yamlStr = reconstructFrontmatter(newObj);
+    if (/\[object Object\]/.test(yamlStr)) {
+        throw new Error('frontmatter: cannot faithfully serialize the requested frontmatter — it contains a nested ' +
+            'object-list (e.g. must_haves.artifacts) the writer cannot represent. Edit the file directly.');
+    }
     return `---\n${yamlStr}\n---\n\n` + content;
 }
 /**
@@ -434,9 +526,35 @@ function cmdFrontmatterSet(cwd, filePath, field, value, raw) {
     }
     fm[field] = parsedValue;
     const newContent = spliceFrontmatter(content, fm);
+    // #1660: a no-op set (newContent unchanged) with a dict-valued field means the lossy
+    // frontmatter parser made the new value's projection equal the original's — the change
+    // did not apply (bites object-list fields like must_haves). Detection lives in the pure
+    // exported helper noOpObjectListSetError so the mutation gate (property/unit set) covers
+    // it — the cmd path itself is not in that set.
+    const noOpErr = noOpObjectListSetError(content, newContent, parsedValue);
+    if (noOpErr) {
+        output({ error: noOpErr, field }, raw, undefined);
+        return;
+    }
     (0, shell_command_projection_cjs_1.platformWriteSync)(fullPath, newContent);
     output({ updated: true, field, value: parsedValue }, raw, 'true');
 }
+/**
+ * #1660: detect a frontmatter `set` that would be a silent no-op on a dict-valued field.
+ * Returns an error message when the splice produced no content change but the new value
+ * is a dict (object-list fields like must_haves, whose `{path, provides}` items flatten to
+ * scalar strings under extractFrontmatter so a replacement can deep-equal the original's
+ * projection), else null. Scalars and scalar arrays round-trip faithfully, so idempotent
+ * sets of those are intentionally NOT flagged. Pure and unit-tested directly (the cmd path
+ * is not in Stryker's property/unit set, so the detection must be testable in isolation).
+ */
+function noOpObjectListSetError(originalContent, newContent, parsedValue) {
+    if (newContent !== originalContent)
+        return null;
+    if (parsedValue === null || typeof parsedValue !== 'object' || Array.isArray(parsedValue))
+        return null;
+    return 'frontmatter set had no effect — the supplied value is equivalent to the existing field under the frontmatter parser, which cannot faithfully round-trip object-list fields like must_haves. Edit the file directly.';
+}
 function cmdFrontmatterMerge(cwd, filePath, data, raw) {
     if (!filePath || !data) {
         error('file and data required');
@@ -489,6 +607,7 @@ module.exports = {
     parseFrontmatter: extractFrontmatter,
     reconstructFrontmatter,
     spliceFrontmatter,
+    noOpObjectListSetError,
     parseMustHavesBlock,
     FRONTMATTER_SCHEMAS,
     cmdFrontmatterGet,

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

@@ -43,6 +43,10 @@ const security_cjs_1 = require("./security.cjs");
 const runtime_homes_cjs_1 = require("./runtime-homes.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- frontmatter.cjs is an export= CommonJS module
 const frontmatterMod = require("./frontmatter.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- verification.cjs is an export= CommonJS module
+const verificationMod = require("./verification.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- uat-predicate.cjs is an export= CommonJS module
+const uatPredicateMod = require("./uat-predicate.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- agent-install-check.cjs is an export= CommonJS module
 const agentInstallCheck = require("./agent-install-check.cjs");
 const { checkAgentsInstalled } = agentInstallCheck;
@@ -61,6 +65,8 @@ const { pruneOrphanedWorktrees } = worktreeSafety;
 const { planningPaths, planningDir, planningRoot, findContextMdIn, } = planningWorkspace;
 const { determinePhaseStatus } = commandsMod;
 const { extractFrontmatter } = frontmatterMod;
+const { readVerificationStatus } = verificationMod;
+const { evaluateUatPassed } = uatPredicateMod;
 // Unused but imported for structural parity
 void stripShippedMilestones;
 // Accept all bold/colon variants of the Requirements header (#2769)
@@ -71,6 +77,45 @@ function listPhaseSummaryFiles(phaseDir) {
 function listPhasePlanFiles(phaseDir) {
     return scanPhasePlans(phaseDir)['planFiles'];
 }
+function verificationNextCommand(status, phaseNumber, slashRuntime) {
+    if (status === 'gaps_found') {
+        return `${(0, runtime_slash_cjs_1.formatGsdSlash)('plan-phase', slashRuntime)} ${phaseNumber} --gaps`;
+    }
+    if (status === 'human_needed' || status === 'stale') {
+        return `${(0, runtime_slash_cjs_1.formatGsdSlash)('verify-work', slashRuntime)} ${phaseNumber}`;
+    }
+    if (status === 'missing' || status === 'unknown') {
+        return `${(0, runtime_slash_cjs_1.formatGsdSlash)('execute-phase', slashRuntime)} ${phaseNumber}`;
+    }
+    return '';
+}
+function projectCompletionStatus(implementationComplete, verificationPassed) {
+    if (implementationComplete && verificationPassed)
+        return 'complete';
+    if (implementationComplete)
+        return 'executed';
+    return 'incomplete';
+}
+function buildPhaseCompletionProjection(cwd, phaseNumber, phaseDir, planCount, summaryCount, slashRuntime) {
+    const implementationComplete = planCount > 0 && summaryCount >= planCount;
+    const phaseFullDir = phaseDir ? node_path_1.default.join(cwd, phaseDir) : '';
+    const verificationStatus = implementationComplete
+        ? readVerificationStatus(phaseFullDir)
+        : { status: 'not_required', next_action: '', next_command: '' };
+    const projectedVerificationStatus = verificationStatus.status;
+    const projectedVerificationAction = verificationStatus.next_action;
+    const verificationPassed = projectedVerificationStatus === 'passed';
+    const phaseComplete = implementationComplete && verificationPassed;
+    return {
+        implementation_complete: implementationComplete,
+        verification_status: projectedVerificationStatus,
+        verification_passed: verificationPassed,
+        phase_complete: phaseComplete,
+        completion_status: projectCompletionStatus(implementationComplete, verificationPassed),
+        verification_next_action: projectedVerificationAction,
+        verification_next_command: verificationNextCommand(projectedVerificationStatus, phaseNumber, slashRuntime),
+    };
+}
 function getLatestCompletedMilestone(cwd) {
     const milestonesPath = node_path_1.default.join(planningRoot(cwd), 'MILESTONES.md');
     const content = (0, shell_command_projection_cjs_1.platformReadSync)(milestonesPath);
@@ -636,6 +681,7 @@ function cmdInitVerifyWork(cwd, phase, raw) {
         error('phase required for init verify-work');
     }
     const config = loadConfig(cwd);
+    const _slashRuntime = (0, runtime_slash_cjs_1.resolveRuntime)(cwd);
     let phaseInfo = findPhaseInternal(cwd, phase);
     if (phaseInfo?.['archived']) {
         const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
@@ -664,15 +710,30 @@ function cmdInitVerifyWork(cwd, phase, raw) {
             };
         }
     }
+    const phaseDir = phaseInfo?.['directory'] || null;
+    const planCount = phaseInfo?.['plans']?.length || 0;
+    const summaryCount = phaseInfo?.['summaries']?.length || 0;
+    const completion = buildPhaseCompletionProjection(cwd, phaseInfo?.['phase_number'] || phase, phaseDir, planCount, summaryCount, _slashRuntime);
+    const uatReport = phaseDir
+        ? evaluateUatPassed(node_path_1.default.join(cwd, phaseDir), {
+            policy: { requireVerification: true },
+        })
+        : null;
     const result = {
         planner_model: resolveModelInternal(cwd, 'gsd-planner'),
         checker_model: resolveModelInternal(cwd, 'gsd-plan-checker'),
         commit_docs: config.commit_docs,
         phase_found: !!phaseInfo,
-        phase_dir: phaseInfo?.['directory'] || null,
+        phase_dir: phaseDir,
         phase_number: phaseInfo?.['phase_number'] || null,
         phase_name: phaseInfo?.['phase_name'] || null,
         has_verification: phaseInfo?.['has_verification'] || false,
+        phase_completion: {
+            ...completion,
+            uat_passed: uatReport?.passed ?? false,
+            uat_blockers: uatReport?.blockers ?? [],
+            ready_to_transition: completion.phase_complete && (uatReport?.passed ?? false),
+        },
     };
     output(withProjectRoot(cwd, result), raw);
 }
@@ -1035,18 +1096,23 @@ function cmdInitManager(cwd, raw) {
         let hasResearch = false;
         let lastActivity = null;
         let isActive = false;
+        let completion = buildPhaseCompletionProjection(cwd, phaseNum, null, planCount, summaryCount, _slashRuntime);
         try {
             const dirs = _phaseDirEntries.filter(isDirInMilestone);
             const dirMatch = dirs.find((d) => phaseTokenMatches(d, normalized));
             if (dirMatch) {
                 const fullDir = node_path_1.default.join(phasesDir, dirMatch);
+                const phaseDirRel = toPosixPath(node_path_1.default.relative(cwd, fullDir));
                 const phaseFiles = node_fs_1.default.readdirSync(fullDir);
                 planCount = listPhasePlanFiles(fullDir).length;
                 summaryCount = listPhaseSummaryFiles(fullDir).length;
                 hasContext = findContextMdIn(fullDir) !== null;
                 hasResearch = phaseFiles.some((f) => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md');
-                if (summaryCount >= planCount && planCount > 0)
+                completion = buildPhaseCompletionProjection(cwd, phaseNum, phaseDirRel, planCount, summaryCount, _slashRuntime);
+                if (completion.phase_complete)
                     diskStatus = 'complete';
+                else if (completion.implementation_complete)
+                    diskStatus = 'executed';
                 else if (summaryCount > 0)
                     diskStatus = 'partial';
                 else if (planCount > 0)
@@ -1079,7 +1145,7 @@ function cmdInitManager(cwd, raw) {
             /* intentionally empty */
         }
         const roadmapComplete = _checkboxStates.get(phaseNum) || false;
-        if (roadmapComplete && diskStatus !== 'complete') {
+        if (roadmapComplete && completion.phase_complete && diskStatus !== 'complete') {
             diskStatus = 'complete';
         }
         phases.push({
@@ -1093,6 +1159,7 @@ function cmdInitManager(cwd, raw) {
             plan_count: planCount,
             summary_count: summaryCount,
             roadmap_complete: roadmapComplete,
+            ...completion,
             last_activity: lastActivity,
             is_active: isActive,
         });
@@ -1107,22 +1174,42 @@ function cmdInitManager(cwd, raw) {
             phase['display_name'] = name;
         }
     }
-    const completedNums = new Set(phases.filter((p) => p['disk_status'] === 'complete').map((p) => p['number']));
+    function normalizePhaseNumber(value) {
+        return value
+            .split('.')
+            .map((part) => {
+            const match = /^(\d+)([A-Z]?)$/i.exec(part);
+            if (!match)
+                return part;
+            return `${Number(match[1])}${match[2].toUpperCase()}`;
+        })
+            .join('.');
+    }
+    const completedNums = new Set(phases
+        .filter((p) => p['phase_complete'] === true)
+        .map((p) => normalizePhaseNumber(p['number'])));
+    const phaseMap = new Map(phases.map((p) => [normalizePhaseNumber(p['number']), p]));
     const _allCompletedPattern = /-\s*\[x\]\s*.*Phase\s+(\d+[A-Z]?(?:\.\d+)*)[:\s]/gi;
     let _allMatch;
     while ((_allMatch = _allCompletedPattern.exec(rawContent)) !== null) {
-        completedNums.add(_allMatch[1]);
+        const phaseNum = normalizePhaseNumber(_allMatch[1]);
+        const phase = phaseMap.get(phaseNum);
+        if (!phase || phase['phase_complete'] === true) {
+            completedNums.add(phaseNum);
+        }
     }
-    const phaseMap = new Map(phases.map((p) => [p['number'], p]));
     function reaches(from, to, visited = new Set()) {
-        if (visited.has(from))
+        const normalizedFrom = normalizePhaseNumber(from);
+        const normalizedTo = normalizePhaseNumber(to);
+        if (visited.has(normalizedFrom))
             return false;
-        visited.add(from);
-        const p = phaseMap.get(from);
+        visited.add(normalizedFrom);
+        const p = phaseMap.get(normalizedFrom);
         if (!p || !p['dep_phases'] || p['dep_phases'].length === 0)
             return false;
-        if (p['dep_phases'].includes(to))
+        if (p['dep_phases'].some((dep) => normalizePhaseNumber(dep) === normalizedTo)) {
             return true;
+        }
         return p['dep_phases'].some((dep) => reaches(dep, to, visited));
     }
     function hasDepRelationship(numA, numB) {
@@ -1134,8 +1221,8 @@ function cmdInitManager(cwd, raw) {
             phase['deps_satisfied'] = true;
         }
         else {
-            const depNums = phase['depends_on'].match(/\d+(?:\.\d+)*/g) || [];
-            phase['deps_satisfied'] = depNums.every((n) => completedNums.has(n));
+            const depNums = phase['depends_on'].match(/\d+[A-Z]?(?:\.\d+)*/gi) || [];
+            phase['deps_satisfied'] = depNums.every((n) => completedNums.has(normalizePhaseNumber(n)));
             phase['dep_phases'] = depNums;
         }
     }
@@ -1167,7 +1254,16 @@ function cmdInitManager(cwd, raw) {
             continue;
         if (/^999(?:\.|$)/.test(phase['number']))
             continue;
-        if (phase['disk_status'] === 'planned' && phase['deps_satisfied']) {
+        if (phase['disk_status'] === 'executed') {
+            recommendedActions.push({
+                phase: phase['number'],
+                phase_name: phase['name'],
+                action: 'verify',
+                reason: `Implementation complete; verification ${phase['verification_status']}`,
+                command: phase['verification_next_command'],
+            });
+        }
+        else if (phase['disk_status'] === 'planned' && phase['deps_satisfied']) {
             recommendedActions.push({
                 phase: phase['number'],
                 phase_name: phase['name'],
@@ -1211,7 +1307,7 @@ function cmdInitManager(cwd, raw) {
         return true;
     });
     const nonBacklogPhases = phases.filter((p) => !/^999(?:\.|$)/.test(p['number']));
-    const completedCount = nonBacklogPhases.filter((p) => p['disk_status'] === 'complete').length;
+    const completedCount = nonBacklogPhases.filter((p) => p['phase_complete'] === true).length;
     const sanitizeFlags = (rawVal) => {
         const val = typeof rawVal === 'string' ? rawVal : '';
         if (!val)
@@ -1238,7 +1334,7 @@ function cmdInitManager(cwd, raw) {
         phases,
         phase_count: phases.length,
         completed_count: completedCount,
-        in_progress_count: phases.filter((p) => ['partial', 'planned', 'discussed', 'researched'].includes(p['disk_status'])).length,
+        in_progress_count: phases.filter((p) => ['executed', 'partial', 'planned', 'discussed', 'researched'].includes(p['disk_status'])).length,
         recommended_actions: filteredActions,
         waiting_signal: waitingSignal,
         all_complete: completedCount === nonBacklogPhases.length && nonBacklogPhases.length > 0,
@@ -1258,6 +1354,7 @@ function cmdInitProgress(cwd, raw) {
     }
     const config = loadConfig(cwd);
     const milestone = getMilestoneInfo(cwd);
+    const _slashRuntime = (0, runtime_slash_cjs_1.resolveRuntime)(cwd);
     const phasesDir = node_path_1.default.join(planningDir(cwd), 'phases');
     const phases = [];
     let currentPhase = null;
@@ -1307,24 +1404,29 @@ function cmdInitProgress(cwd, raw) {
             const plans = listPhasePlanFiles(phasePath);
             const summaries = listPhaseSummaryFiles(phasePath);
             const hasResearch = phaseFiles.some((f) => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md');
-            const status = summaries.length >= plans.length && plans.length > 0
+            const phaseDirRel = toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningDir(cwd), 'phases', dir)));
+            const completion = buildPhaseCompletionProjection(cwd, phaseNumber, phaseDirRel, plans.length, summaries.length, _slashRuntime);
+            const status = completion.phase_complete
                 ? 'complete'
-                : plans.length > 0
-                    ? 'in_progress'
-                    : hasResearch
-                        ? 'researched'
-                        : 'pending';
+                : completion.implementation_complete
+                    ? 'executed'
+                    : plans.length > 0
+                        ? 'in_progress'
+                        : hasResearch
+                            ? 'researched'
+                            : 'pending';
             const phaseInfo = {
                 number: phaseNumber,
                 name: phaseName,
-                directory: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningDir(cwd), 'phases', dir))),
+                directory: phaseDirRel,
                 status,
                 plan_count: plans.length,
                 summary_count: summaries.length,
                 has_research: hasResearch,
+                ...completion,
             };
             phases.push(phaseInfo);
-            if (!currentPhase && (status === 'in_progress' || status === 'researched')) {
+            if (!currentPhase && (status === 'executed' || status === 'in_progress' || status === 'researched')) {
                 currentPhase = phaseInfo;
             }
             if (!nextPhase && status === 'pending') {
@@ -1340,7 +1442,8 @@ function cmdInitProgress(cwd, raw) {
         if (!seenPhaseNums.has(stripped)) {
             const checkboxComplete = roadmapCheckboxStates.get(num) === true ||
                 roadmapCheckboxStates.get(stripped) === true;
-            const status = checkboxComplete ? 'complete' : 'not_started';
+            const completion = buildPhaseCompletionProjection(cwd, num, null, 0, 0, _slashRuntime);
+            const status = 'not_started';
             const phaseInfo = {
                 number: num,
                 name: name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, ''),
@@ -1349,9 +1452,11 @@ function cmdInitProgress(cwd, raw) {
                 plan_count: 0,
                 summary_count: 0,
                 has_research: false,
+                roadmap_complete: checkboxComplete,
+                ...completion,
             };
             phases.push(phaseInfo);
-            if (!nextPhase && !currentPhase && status !== 'complete') {
+            if (!nextPhase && !currentPhase && !checkboxComplete) {
                 nextPhase = phaseInfo;
             }
         }
@@ -1373,7 +1478,7 @@ function cmdInitProgress(cwd, raw) {
         phases,
         phase_count: phases.length,
         completed_count: phases.filter((p) => p['status'] === 'complete').length,
-        in_progress_count: phases.filter((p) => p['status'] === 'in_progress').length,
+        in_progress_count: phases.filter((p) => ['executed', 'in_progress'].includes(p['status'])).length,
         current_phase: currentPhase,
         next_phase: nextPhase,
         paused_at: pausedAt,

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

@@ -167,6 +167,7 @@ const ERROR_REASON = Object.freeze({
     SDK_MISSING_ARG: 'sdk_missing_arg',
     // workflow / phase
     PHASE_NOT_FOUND: 'phase_not_found',
+    PHASE_VERIFICATION_INCOMPLETE: 'phase_verification_incomplete',
     SUMMARY_NO_PLANNING: 'summary_no_planning',
     // graphify
     GRAPHIFY_NO_GRAPH: 'graphify_no_graph',

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

@@ -165,6 +165,14 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
                 })();
                 while ((pm = phasePattern.exec(scopedContent)) !== null) {
                     const phaseNum = pm[1];
+                    // 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
+                    // (phase-id getMilestoneFromPhaseId, roadmap-command-router SENTINELS,
+                    // the #1445 /^999/ progress filters). (#1580)
+                    const major = parseInt(phaseNum, 10);
+                    if (major === 0 || major === 999)
+                        continue;
                     const normalized = normalizePhaseName(phaseNum);
                     // A phase has disk_status: 'no_directory' when no phase directory
                     // with a matching token exists on disk. Use the same phaseTokenMatches

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

@@ -52,6 +52,9 @@ const clock_cjs_1 = require("./clock.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- uat-predicate.cjs is an export= CommonJS module
 const uatPredicate = require("./uat-predicate.cjs");
 const { evaluateUatPassed } = uatPredicate;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- verification.cjs is an export= CommonJS module
+const verificationMod = require("./verification.cjs");
+const { readVerificationStatus } = verificationMod;
 const { planningDir, withPlanningLock } = planningWorkspace;
 const { extractFrontmatter } = frontmatterMod;
 const { readModifyWriteStateMd, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, syncStateFrontmatter, withStateLock, updatePerformanceMetricsSection, } = stateMod;
@@ -1077,8 +1080,8 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
         : 0;
     let requirementsUpdated = false;
     const warnings = [];
+    const phaseFullDir = node_path_1.default.join(cwd, phaseInfo['directory']);
     try {
-        const phaseFullDir = node_path_1.default.join(cwd, phaseInfo['directory']);
         const phaseFiles = node_fs_1.default.readdirSync(phaseFullDir);
         for (const file of phaseFiles.filter((f) => f.includes('-UAT') && f.endsWith('.md'))) {
             const content = node_fs_1.default.readFileSync(node_path_1.default.join(phaseFullDir, file), 'utf-8');
@@ -1113,7 +1116,11 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
     let nextPhaseNum = null;
     let nextPhaseName = null;
     let isLastPhase = true;
-    withPlanningLock(cwd, () => {
+    const verificationBlocked = withPlanningLock(cwd, () => {
+        const verificationStatus = readVerificationStatus(phaseFullDir);
+        if (verificationStatus.status !== 'passed') {
+            return verificationStatus;
+        }
         const runPhaseCompleteTransaction = () => {
             const writes = [];
             let roadmapContent = null;
@@ -1280,7 +1287,19 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
             if (isLastPhase && roadmapContent !== null) {
                 try {
                     const roadmapForPhases = extractCurrentMilestone(roadmapContent, cwd);
-                    const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n]+)/gi;
+                    // #1591: match BOTH heading-style phases (`### Phase N:`) AND
+                    // checkbox-list items, INCLUDING the canonical bold form the roadmap
+                    // template emits (`- [ ] **Phase N: Name**`). When the active
+                    // milestone's checklist is `- [ ]` items inside a <details> block
+                    // (and the next phase has no directory yet, so the disk-based
+                    // resolver finds nothing), this roadmap-enumeration fallback is the
+                    // only path that can find the next phase. The prior heading-only
+                    // pattern missed checkbox items, and a checkbox-only broadening still
+                    // missed the bold template rows → is_last_phase=true on a mid-milestone
+                    // phase. Allow optional `**`/`__` emphasis after the marker and stop
+                    // the name capture at emphasis so bold names slug cleanly; the number
+                    // capture is unchanged.
+                    const phasePattern = /(?:#{2,4}|-\s*\[[ xX]\])\s*(?:\*\*|__)?\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n*]+)/gi;
                     let pm;
                     while ((pm = phasePattern.exec(roadmapForPhases)) !== null) {
                         if (comparePhaseNum(pm[1], phaseNum) > 0) {
@@ -1381,7 +1400,14 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
         else {
             runPhaseCompleteTransaction();
         }
+        return null;
     });
+    if (verificationBlocked) {
+        const nextStep = verificationBlocked.next_command
+            ? ` Next: ${verificationBlocked.next_command}`
+            : '';
+        error(`Phase ${phaseNum} verification is incomplete: ${verificationBlocked.next_action}${nextStep}`, ERROR_REASON.PHASE_VERIFICATION_INCOMPLETE);
+    }
     let autoPruned = false;
     try {
         const configPath = node_path_1.default.join(planningDir(cwd), 'config.json');

package/gsd-core/bin/lib/plan-scan.cjs

@@ -63,8 +63,8 @@ function scanPhasePlans(phaseDir) {
     if ((0, node_fs_1.existsSync)(nestedDir)) {
         try {
             const nestedFiles = (0, node_fs_1.readdirSync)(nestedDir);
-            nestedPlanFiles = nestedFiles.filter(isNestedPlanFile);
-            nestedSummaryFiles = nestedFiles.filter(isNestedSummaryFile);
+            nestedPlanFiles = nestedFiles.filter(isNestedPlanFile).map((file) => `plans/${file}`);
+            nestedSummaryFiles = nestedFiles.filter(isNestedSummaryFile).map((file) => `plans/${file}`);
             hasNestedPlans = nestedPlanFiles.length > 0;
         }
         catch { /* ignore unreadable nested layout */ }

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

@@ -249,6 +249,15 @@ function cmdRoadmapAnalyze(cwd, raw) {
     const phasePattern = /#{2,4}\s*(?:\[[^\]]+\]\s*)?Phase\s+(\d+[A-Z]?(?:[.-]\d+)*)\s*:\s*([^\n]+)/gi;
     const phases = [];
     let match;
+    // Phase 0 (pre-milestone) and Phase 999 (backlog) are sentinels, not real
+    // phases. They legitimately have no directory and must never be surfaced as
+    // current/next phase or counted in phase_count. Mirrors the engine-wide
+    // sentinel convention (phase-id getMilestoneFromPhaseId, roadmap-command-router
+    // SENTINELS, the #1445 /^999/ progress filters). (#1580)
+    const isSentinelPhase = (num) => {
+        const major = parseInt(num, 10);
+        return major === 0 || major === 999;
+    };
     // Build phase directory lookup once (O(1) readdir instead of O(N) per phase)
     const _phaseDirNames = (() => {
         try {
@@ -262,6 +271,8 @@ function cmdRoadmapAnalyze(cwd, raw) {
     })();
     while ((match = phasePattern.exec(content)) !== null) {
         const phaseNum = match[1];
+        if (isSentinelPhase(phaseNum))
+            continue;
         const phaseName = match[2].replace(/\(INSERTED\)/i, '').trim();
         // Extract goal from the section
         const sectionStart = match.index;
@@ -362,7 +373,7 @@ function cmdRoadmapAnalyze(cwd, raw) {
         checklistPhases.add(checklistMatch[1]);
     }
     const detailPhases = new Set(phases.map(p => p.number));
-    const missingDetails = [...checklistPhases].filter(p => !detailPhases.has(p));
+    const missingDetails = [...checklistPhases].filter(p => !detailPhases.has(p) && !isSentinelPhase(p));
     const result = {
         milestones,
         phases,