@opengsd/gsd-core 1.6.0-rc.2 → 1.6.0

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/graphify-command-router.cjs

@@ -26,46 +26,63 @@
 const graphify = require("./graphify.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const io = require("./io.cjs");
+// Phase 2 (#1646): route through the Hub per ADR-959 §III(B) line 75.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const commandRoutingHub = require("./command-routing-hub.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const cjsCommandRouterAdapter = require("./cjs-command-router-adapter.cjs");
 const { output, ERROR_REASON } = io;
+const { makeInvalidArgs } = commandRoutingHub;
+const { routeHubCommandFamily } = cjsCommandRouterAdapter;
 // ─── Implementation ───────────────────────────────────────────────────────────
 function routeGraphifyCommand({ args, cwd, raw, error, _graphify }) {
-    const subcommand = args[1];
     const g = _graphify ?? graphify;
-    if (subcommand === 'query') {
-        const term = args[2];
-        if (!term) {
-            error('Usage: gsd-tools graphify query <term>', ERROR_REASON.USAGE);
-            return;
-        }
-        const budgetIdx = args.indexOf('--budget');
-        let budget = null;
-        if (budgetIdx !== -1) {
-            const rawBudget = args[budgetIdx + 1];
-            if (rawBudget === undefined || Number.isNaN(parseInt(rawBudget, 10))) {
-                error('Usage: gsd-tools graphify query <term> [--budget <N>]', ERROR_REASON.USAGE);
-                return;
-            }
-            budget = parseInt(rawBudget, 10);
-        }
-        output(g.graphifyQuery(cwd, term, { budget }), raw);
-    }
-    else if (subcommand === 'status') {
-        output(g.graphifyStatus(cwd), raw);
-    }
-    else if (subcommand === 'diff') {
-        output(g.graphifyDiff(cwd), raw);
-    }
-    else if (subcommand === 'build') {
-        if (args[2] === 'snapshot') {
-            output(g.writeSnapshot(cwd), raw);
-        }
-        else {
-            output(g.graphifyBuild(cwd), raw);
-        }
-    }
-    else {
-        error('Unknown graphify subcommand. Available: build, query, status, diff', ERROR_REASON.SDK_UNKNOWN_COMMAND);
-    }
+    // Phase 2 (#1646): routes through the Command Routing Hub per ADR-959 §III(B)
+    // line 75. Validation handlers return `makeInvalidArgs(...)` Results (Q2=C,
+    // Q4=ii); the Hub → adapter translation preserves ERROR_REASON granularity
+    // via the exitReason field (Phase 1, #1644). Success handlers keep direct
+    // `output()` calls (audit's formatAuditReport quirk sets this precedent).
+    // The unknown-subcommand path is owned by the Hub's manifest check; the
+    // adapter passes SDK_UNKNOWN_COMMAND for UnknownCommand Results.
+    routeHubCommandFamily({
+        family: 'graphify',
+        args,
+        // Alphabetical order produces a stable, byte-identical `Available:` list
+        // in the unknown-subcommand message (matches the pre-conversion text).
+        subcommands: ['build', 'diff', 'query', 'status'],
+        handlers: {
+            query: () => {
+                const term = args[2];
+                if (!term) {
+                    return makeInvalidArgs('term', 'Usage: gsd-tools graphify query <term>', ERROR_REASON.USAGE);
+                }
+                const budgetIdx = args.indexOf('--budget');
+                let budget = null;
+                if (budgetIdx !== -1) {
+                    const rawBudget = args[budgetIdx + 1];
+                    if (rawBudget === undefined || Number.isNaN(parseInt(rawBudget, 10))) {
+                        return makeInvalidArgs('--budget', 'Usage: gsd-tools graphify query <term> [--budget <N>]', ERROR_REASON.USAGE);
+                    }
+                    budget = parseInt(rawBudget, 10);
+                }
+                output(g.graphifyQuery(cwd, term, { budget }), raw);
+            },
+            status: () => output(g.graphifyStatus(cwd), raw),
+            diff: () => output(g.graphifyDiff(cwd), raw),
+            build: () => {
+                if (args[2] === 'snapshot') {
+                    output(g.writeSnapshot(cwd), raw);
+                }
+                else {
+                    output(g.graphifyBuild(cwd), raw);
+                }
+            },
+        },
+        unknownMessage: (subcommand, available) => `Unknown graphify subcommand. Available: ${available.join(', ')}`,
+        error,
+        cwd,
+        raw,
+    });
 }
 module.exports = {
     routeGraphifyCommand,

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,
@@ -1724,10 +1829,14 @@ function cmdAgentSkills(cwd, agentType, raw, jsonMode) {
         }, raw);
         return;
     }
-    if (block) {
-        process.stdout.write(block);
-    }
-    process.exit(0);
+    // #1400: emit the raw block via the synchronous-flush output() helper (the same
+    // one the --json branch uses) rather than process.stdout.write + process.exit(0).
+    // When stdout is a pipe/file (how workflows consume this via command
+    // substitution) the async stdout buffer is torn down by process.exit() before
+    // it drains — on Windows this reliably truncates the write to 0 bytes, so every
+    // ${AGENT_SKILLS_*} substitution expands empty. output() writes every byte with
+    // writeAllSync and returns, letting the event loop drain naturally.
+    output(block || '', true, block || '');
 }
 function buildSkillManifest(cwd, skillsDir = null) {
     const canonicalRoots = skillsDir

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

@@ -523,9 +523,12 @@ function stageSkillsForRuntimeAsSkills(srcCommandsDir, resolvedProfile, converte
  *
  * @param srcAgentsDir    source agents directory (e.g. agents/)
  * @param resolvedProfile profile filter from resolveProfile()
- * @param converter       (content: string) → string  pure per-file converter
+ * @param converter       (content: string, isGlobal?: boolean) → string per-file
+ *                        converter; scope-aware converters (copilot/antigravity)
+ *                        read isGlobal, single-arg converters ignore it (#1173)
+ * @param isGlobal        install scope passed through to the converter
  */
-function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, converter) {
+function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, converter, isGlobal = false) {
     if (!node_fs_1.default.existsSync(srcAgentsDir))
         return srcAgentsDir;
     const stageDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'gsd-profile-runtime-agents-'));
@@ -544,7 +547,7 @@ function stageAgentsForRuntimeWithConverter(srcAgentsDir, resolvedProfile, conve
                 }
             }
             const content = node_fs_1.default.readFileSync(node_path_1.default.join(srcAgentsDir, entry.name), 'utf8');
-            const converted = converter(content);
+            const converted = converter(content, isGlobal);
             node_fs_1.default.writeFileSync(node_path_1.default.join(stageDir, entry.name), converted, 'utf8');
         }
     }