@opengsd/gsd-core 1.5.0-rc.2 → 1.5.0-rc.3

package/gsd-core/bin/lib/capability-state.cjs

@@ -4,8 +4,8 @@
  *
  * Unified capability-state resolver that composes the three toggle systems
  * (install profile, runtime surface, config activation) into one per-capability
- * view. ADDITIVE — install/surface/workflows are untouched; this resolver is
- * consumed by nothing yet (phase-6 wiring is out of scope).
+ * view. The loop resolver consumes this state so workflow dispatch and the
+ * `gsd-tools capability state` diagnostic share the same enablement answer.
  *
  * Exports (three things, mirroring loop-resolver):
  *   resolveCapabilityState({ registry, installedSkills, surfacedSkills, config, cwd })
@@ -19,9 +19,9 @@
  * cmdCapabilityState is the I/O handler.
  *
  * Dependencies (leaf modules only — no core.cjs circular risk):
- *   - node:path (used by _resolveActivationValue via loop-resolver)
+ *   - node:path
  *   - ./core.cjs               (output, error)
- *   - ./loop-resolver.cjs      (_resolveActivationValue — reuse the export)
+ *   - ./capability-activation.cjs (_resolveActivationValue)
  *   - ./install-profiles.cjs   (readActiveProfile, loadSkillsManifest, resolveProfile)
  *   - ./surface.cjs            (resolveSurface)
  *   - ./config-loader.cjs      (loadConfig)
@@ -36,8 +36,8 @@ const node_path_1 = __importDefault(require("node:path"));
 const core = require("./core.cjs");
 const { output: coreOutput, error: coreError } = core;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const loopResolverMod = require("./loop-resolver.cjs");
-const { _resolveActivationValue } = loopResolverMod;
+const activationMod = require("./capability-activation.cjs");
+const { _resolveActivationValue } = activationMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configLoaderMod = require("./config-loader.cjs");
 const { loadConfig } = configLoaderMod;
@@ -133,6 +133,7 @@ function resolveCapabilityState(input) {
         else {
             surfaced = skills.every((s) => surfacedSkills.has(s));
         }
+        const enabled = installed && surfaced;
         // ── hooks ──────────────────────────────────────────────────────────────────
         // Collect from steps, gates, contributions. Each may have a `when` key.
         // Activation semantics (mirrors loop-resolver.isActive exactly):
@@ -149,21 +150,21 @@ function resolveCapabilityState(input) {
                 const point = typeof h['point'] === 'string' ? h['point'] : '';
                 // Carry the raw `when` value through for visibility
                 const whenRaw = h['when'];
-                let active;
+                let configured;
                 if (whenRaw === undefined || whenRaw === null) {
                     // No `when` field → unconditional, always active
-                    active = true;
+                    configured = true;
                 }
                 else if (typeof whenRaw === 'string' && whenRaw.length > 0) {
                     // Non-empty string `when` → resolve via _resolveActivationValue
-                    active = _resolveActivationValue(whenRaw, config, cwd, registry);
+                    configured = _resolveActivationValue(whenRaw, config, cwd, registry);
                 }
                 else {
                     // Present-but-empty-string or non-string `when` → malformed, inactive
                     // (mirrors loop-resolver.isActive: `typeof when !== 'string' || when.length === 0` → false)
-                    active = false;
+                    configured = false;
                 }
-                hooks.push({ point, kind, when: whenRaw, active });
+                hooks.push({ point, kind, when: whenRaw, configured, active: enabled && configured });
             }
         }
         const stepsRaw = capObj['steps'];
@@ -172,7 +173,7 @@ function resolveCapabilityState(input) {
         processHooks(Array.isArray(stepsRaw) ? stepsRaw : [], 'step');
         processHooks(Array.isArray(gatesRaw) ? gatesRaw : [], 'gate');
         processHooks(Array.isArray(contributionsRaw) ? contributionsRaw : [], 'contribution');
-        results.push({ id: capId, tier, skills, installed, surfaced, hooks });
+        results.push({ id: capId, tier, skills, installed, surfaced, enabled, hooks });
     }
     // Deterministic sort by id for stable output across calls
     results.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
@@ -222,7 +223,7 @@ function _resolveCommandsGsdDir() {
  * @param raw              Whether to emit raw JSON (core.output raw mode)
  * @param _options         Reserved for future use
  */
-function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
+function resolveCapabilityRuntimeState(cwd, runtimeConfigDir) {
     const warnings = [];
     // Resolve runtimeConfigDir using the canonical runtime-homes resolver.
     // When not provided, getGlobalConfigDir(runtime) is called with 'claude'
@@ -277,7 +278,6 @@ function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
         // Genuine resolution failure — surface it so the caller is not misled.
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`profile-resolution failed: ${msg}`);
-        coreError(`capability state: profile resolution failed: ${msg}`);
         // Degrade to empty set (not '*') so installed=false is reported accurately.
         installedSkills = new Set();
     }
@@ -297,7 +297,6 @@ function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
         // Genuine surface resolution failure — surface it so the caller is not misled.
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`surface-resolution failed: ${msg}`);
-        coreError(`capability state: surface resolution failed: ${msg}`);
         surfacedSkills = new Set();
     }
     // ── Load config ───────────────────────────────────────────────────────────────
@@ -316,19 +315,33 @@ function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
         config,
         cwd,
     });
+    return {
+        runtimeConfigDir: resolvedConfigDir,
+        warnings,
+        registry,
+        config,
+        capabilities: result.capabilities,
+    };
+}
+function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
+    const result = resolveCapabilityRuntimeState(cwd, runtimeConfigDir);
+    for (const warning of result.warnings) {
+        coreError(`capability state: ${warning}`);
+    }
     // Build envelope — include warnings array only when non-empty so the nominal
     // path keeps the output clean and callers can check `warnings` for degraded state.
     const envelope = {
-        runtimeConfigDir: resolvedConfigDir,
+        runtimeConfigDir: result.runtimeConfigDir,
         capabilities: result.capabilities,
     };
-    if (warnings.length > 0) {
-        envelope.warnings = warnings;
+    if (result.warnings.length > 0) {
+        envelope.warnings = result.warnings;
     }
     coreOutput(envelope, raw);
 }
 module.exports = {
     resolveCapabilityState,
+    resolveCapabilityRuntimeState,
     cmdCapabilityState,
     // Exported for tests
     _resolveCommandsGsdDir,

package/gsd-core/bin/lib/check-command-router.cjs

@@ -18,8 +18,14 @@ const { output, error, ERROR_REASON } = core;
 const decisions_cjs_1 = require("./decisions.cjs");
 const ui_safety_gate_cjs_1 = require("./ui-safety-gate.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
+const verifyModule = require("./verify.cjs");
+const { cmdVerifySchemaDrift, cmdVerifyCodebaseDrift } = verifyModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const roadmapModule = require("./roadmap.cjs");
 const { getRoadmapPhaseWithFallback } = roadmapModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const gapCheckerModule = require("./gap-checker.cjs");
+const { runGapAnalysis } = gapCheckerModule;
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 function normalizePhrase(text) {
     // eslint-disable-next-line @typescript-eslint/no-base-to-string
@@ -439,6 +445,297 @@ function cmdUiPlanGate(projectDir, args, raw) {
     }
     output(computeUiPlanGate(projectDir, phase), raw, undefined);
 }
+// ─── ui-safety-gate ───────────────────────────────────────────────────────────
+/**
+ * ui-safety-gate: post-wave check that verifies UI-changed files conform to
+ * the active UI-SPEC for the phase. Called after each wave by execute:wave:post.
+ *
+ * Returns JSON: { frontend: boolean, hasUiFiles: boolean, hasUiSpec: boolean, block: boolean, message?: string }
+ *   block = frontend && hasUiFiles && !hasUiSpec
+ *
+ * Args: check ui-safety-gate <phase>
+ * Invocable as: gsd_run check ui-safety-gate <phase>
+ *             or gsd_run check ui.safety-gate <phase> (dots normalized to hyphens)
+ *
+ * Uses checkUiPresence from ui-safety-gate.cjs — does NOT reimplement frontend detection.
+ * Checks whether any files changed in recent git history match frontend file patterns.
+ * Also checks whether a *-UI-SPEC.md exists in the phase directory (same as ui-plan-gate).
+ *
+ * Limitation: uses git diff HEAD~1..HEAD which covers only the last commit; in a
+ * multi-plan wave the wave-start commit would be more accurate but is not yet stored
+ * in the wave manifest. This is tracked as a known limitation.
+ */
+const UI_FILE_EXTENSIONS_RE = /\.(tsx|jsx|css|scss|sass|less|vue|svelte|html)$/i;
+const UI_PATH_PATTERNS_RE = /\/(components|pages|views|screens|layouts|ui|frontend)\//i;
+/**
+ * Pure logic for ui-safety-gate — exposed for direct behavioral testing.
+ *
+ * Given a projectDir and phase number:
+ *   (a) Reads the phase section from ROADMAP.md via getRoadmapPhaseWithFallback —
+ *       same lookup as computeUiPlanGate — to determine if this is a frontend phase.
+ *   (b) Runs checkUiPresence (frontend detection) — no reimplementation.
+ *   (c) Checks git diff HEAD~1..HEAD for UI file changes in the current worktree.
+ *   (d) Resolves the phase directory via core.findPhaseInternal; checks for *-UI-SPEC.md.
+ *
+ * Returns: { frontend, hasUiFiles, hasUiSpec, block, message?, phaseLookupFailed? }
+ *   block = frontend && hasUiFiles && !hasUiSpec
+ *   phaseLookupFailed = ROADMAP.md present but phase header not found
+ */
+function computeUiSafetyGate(projectDir, phase) {
+    // (a) Read the phase section text (same two-pass lookup as computeUiPlanGate)
+    let phaseSection = '';
+    let phaseLookupFailed;
+    try {
+        const section = getRoadmapPhaseWithFallback(projectDir, phase);
+        if (section === null) {
+            const planDir = typeof core['planningDir'] === 'function'
+                ? core['planningDir'](projectDir)
+                : node_path_1.default.join(projectDir, '.planning');
+            const roadmapPath = node_path_1.default.join(planDir, 'ROADMAP.md');
+            if (node_fs_1.default.existsSync(roadmapPath)) {
+                phaseLookupFailed = true;
+            }
+        }
+        else {
+            phaseSection = section;
+        }
+    }
+    catch { /* roadmap read failure → treat as empty (non-frontend) */ }
+    // (b) Run checkUiPresence (frontend detection) — reuse existing helper; no reimplementation
+    const presenceResult = (0, ui_safety_gate_cjs_1.checkUiPresence)(phaseSection);
+    const frontend = presenceResult.hasUI;
+    // (c) Check whether any UI files were changed in recent git commits
+    // Uses git diff HEAD~1..HEAD to detect frontend file changes since last commit.
+    // Known limitation: multi-plan waves may need the wave-start commit for full coverage.
+    let hasUiFiles = false;
+    try {
+        const changed = (0, node_child_process_1.execFileSync)('git', ['diff', '--name-only', 'HEAD~1', 'HEAD'], {
+            cwd: projectDir,
+            encoding: 'utf-8',
+            maxBuffer: 2 * 1024 * 1024,
+            windowsHide: true,
+        });
+        hasUiFiles = changed.split('\n').some((f) => f.trim() && (UI_FILE_EXTENSIONS_RE.test(f) || UI_PATH_PATTERNS_RE.test(f)));
+    }
+    catch { /* git unavailable or no prior commit — treat as no UI files changed */ }
+    // (d) Resolve phase directory and check for *-UI-SPEC.md (same as computeUiPlanGate)
+    const coreModule = core;
+    let phaseDir = '';
+    try {
+        const findPhase = coreModule['findPhaseInternal'];
+        if (typeof findPhase === 'function') {
+            const result = findPhase(projectDir, phase);
+            if (result && typeof result === 'object') {
+                const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
+                if (relDir) {
+                    phaseDir = node_path_1.default.resolve(projectDir, relDir);
+                }
+            }
+            else if (typeof result === 'string') {
+                phaseDir = result;
+            }
+        }
+    }
+    catch { /* phase dir lookup failure → hasUiSpec=false */ }
+    const uiSpecPath = findUiSpecInDir(phaseDir);
+    const hasUiSpec = uiSpecPath !== '';
+    // block only when: this is a frontend phase AND UI files were changed AND no UI-SPEC exists
+    const block = frontend && hasUiFiles && !hasUiSpec;
+    const result = { frontend, hasUiFiles, hasUiSpec, block };
+    if (block) {
+        result.message = `UI files changed in this wave but no UI-SPEC.md exists for Phase ${phase}. ` +
+            `Run /gsd:ui-phase ${phase} to generate the design contract before continuing.`;
+    }
+    if (phaseLookupFailed)
+        result.phaseLookupFailed = true;
+    return result;
+}
+function cmdUiSafetyGate(projectDir, args, raw) {
+    // args[0] = 'check', args[1] = 'ui-safety-gate', args[2] = phase
+    const phase = args[2] || '';
+    if (!phase) {
+        error('ui-safety-gate requires a phase argument: check ui-safety-gate <phase>', ERROR_REASON.SDK_MISSING_ARG);
+        return;
+    }
+    output(computeUiSafetyGate(projectDir, phase), raw, undefined);
+}
+function cmdTddReviewCheckpoint(projectDir, args, raw) {
+    // args[0] = 'check', args[1] = 'tdd-review-checkpoint' (normalized), args[2] = phase
+    const phase = args[2] || '';
+    if (!phase) {
+        error('tdd.review-checkpoint requires a phase argument: check tdd.review-checkpoint <phase>', ERROR_REASON.SDK_MISSING_ARG);
+        return;
+    }
+    // Resolve phase directory
+    const coreModule = core;
+    let phaseDir = '';
+    try {
+        const findPhase = coreModule['findPhaseInternal'];
+        if (typeof findPhase === 'function') {
+            const result = findPhase(projectDir, phase);
+            if (result && typeof result === 'object') {
+                const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
+                if (relDir)
+                    phaseDir = node_path_1.default.resolve(projectDir, relDir);
+            }
+            else if (typeof result === 'string') {
+                phaseDir = result;
+            }
+        }
+    }
+    catch { /* phase dir lookup failure */ }
+    // Find all PLAN.md files with type: tdd in frontmatter
+    const tddPlanFiles = [];
+    if (phaseDir) {
+        try {
+            const files = node_fs_1.default.readdirSync(phaseDir).filter(f => f.endsWith('-PLAN.md'));
+            for (const file of files) {
+                const planPath = node_path_1.default.join(phaseDir, file);
+                const content = readIfExists(planPath);
+                // Check frontmatter for type: tdd
+                const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+                if (frontmatterMatch) {
+                    const fm = frontmatterMatch[1];
+                    if (/^type:\s*tdd\s*$/m.test(fm)) {
+                        tddPlanFiles.push(planPath);
+                    }
+                }
+            }
+        }
+        catch { /* directory read failure */ }
+    }
+    if (tddPlanFiles.length === 0) {
+        const result = {
+            // Uniform gate contract: block = violations > 0 (advisory; never truly blocks).
+            block: false,
+            passed: true,
+            tddPlans: 0,
+            violations: 0,
+            table: '',
+            rows: [],
+            message: `No type:tdd plans found in phase ${phase}. TDD review skipped.`,
+        };
+        // Pass undefined as rawValue so --raw emits JSON (not plain text).
+        // The human-readable report is carried in `result.message` for the
+        // dispatch's advisory branch to surface.
+        output(result, raw, undefined);
+        return;
+    }
+    // For each TDD plan, extract the plan ID (padded plan number) and check git log
+    const rows = [];
+    for (const planPath of tddPlanFiles) {
+        // Extract plan ID from filename (e.g. "01-02-PLAN.md" → "01-02", or "03-PLAN.md" → "03")
+        const basename = node_path_1.default.basename(planPath, '-PLAN.md');
+        // planId for commit grep: phase-plan format, e.g. "01-02"
+        const planId = basename;
+        // Check for RED gate commit: test({planId}):
+        let red = false;
+        let green = false;
+        let refactor = false;
+        try {
+            const redCommit = (0, node_child_process_1.execFileSync)('git', ['log', '--oneline', `--grep=^test(${planId}):`, '--', '.'], { cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true });
+            red = redCommit.trim().length > 0;
+        }
+        catch { /* git unavailable or no match */ }
+        try {
+            const greenCommit = (0, node_child_process_1.execFileSync)('git', ['log', '--oneline', `--grep=^feat(${planId}):`, '--', '.'], { cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true });
+            green = greenCommit.trim().length > 0;
+        }
+        catch { /* git unavailable or no match */ }
+        try {
+            const refactorCommit = (0, node_child_process_1.execFileSync)('git', ['log', '--oneline', `--grep=^refactor(${planId}):`, '--', '.'], { cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true });
+            refactor = refactorCommit.trim().length > 0;
+        }
+        catch { /* git unavailable or no match */ }
+        const missing = [];
+        if (!red)
+            missing.push('RED');
+        if (!green)
+            missing.push('GREEN');
+        const status = missing.length === 0 ? 'Pass' : 'FAIL';
+        rows.push({ planId, red, green, refactor, status, missing });
+    }
+    const violations = rows.filter(r => r.status === 'FAIL').length;
+    // Build review table
+    const sep = '━'.repeat(53);
+    const tableHeader = '| Plan | RED | GREEN | REFACTOR | Status |';
+    const tableDivider = '|------|-----|-------|----------|--------|';
+    const tableRows = rows.map(r => `| ${r.planId.padEnd(4)} | ${r.red ? ' ✓ ' : ' ✗ '} | ${r.green ? '  ✓  ' : '  ✗  '} | ${r.refactor ? '   ✓    ' : '   —    '} | ${r.status.padEnd(6)} |`);
+    let table = [
+        sep,
+        ` TDD REVIEW — Phase ${phase}`,
+        sep,
+        '',
+        `TDD Plans: ${tddPlanFiles.length} | Gate violations: ${violations}`,
+        '',
+        tableHeader,
+        tableDivider,
+        ...tableRows,
+    ].join('\n');
+    if (violations > 0) {
+        table += '\n\n⚠ Gate violations are advisory — review before advancing.';
+        for (const r of rows.filter(row => row.status === 'FAIL')) {
+            table += `\n  Plan ${r.planId} missing: ${r.missing.join(', ')} gate commit(s).`;
+            table += `\n  Expected commit pattern: test(${r.planId}): ... → feat(${r.planId}): ...`;
+        }
+    }
+    const result = {
+        // Uniform gate contract: block = violations > 0.
+        // This gate is advisory (blocking: false in capability.json) so block:true
+        // only surfaces as a warning, never halts. Kept here so the host-loop
+        // dispatch can read a single consistent `block` field.
+        block: violations > 0,
+        passed: true,
+        tddPlans: tddPlanFiles.length,
+        violations,
+        table,
+        rows,
+        // Human-readable report in `message` so the dispatch's advisory branch
+        // can surface it. --raw emits JSON (rawValue=undefined), not plain text.
+        message: table,
+    };
+    // Pass undefined as rawValue so --raw emits JSON (not the raw table text).
+    // The review table is carried in `result.message` and `result.table` so
+    // the host-loop dispatch's advisory branch can surface it.
+    output(result, raw, undefined);
+}
+// ─── gap-analysis-plan-post ───────────────────────────────────────────────────
+/**
+ * gap-analysis-plan-post: non-blocking advisory check that runs the post-planning
+ * gap analysis after all PLAN.md files are generated for a phase.
+ *
+ * Cross-references every REQ-ID and D-ID from REQUIREMENTS.md and CONTEXT.md
+ * against the concatenated text of all *-PLAN.md files, emitting a coverage table.
+ *
+ * This gate is always advisory (passed: true) — it never blocks phase advancement.
+ *
+ * Args: check gap-analysis.plan-post <phase-dir> [phase-req-ids]
+ * Invocable as: gsd_run check gap-analysis.plan-post <phase-dir> [phase-req-ids]
+ */
+function cmdGapAnalysisPlanPost(projectDir, args, raw) {
+    // args[0] = 'check', args[1] = 'gap-analysis-plan-post' (normalized), args[2] = phaseDir, args[3] = phaseReqIds
+    const phaseDir = args[2] || '';
+    if (!phaseDir) {
+        error('gap-analysis.plan-post requires a phase-dir argument: check gap-analysis.plan-post <phase-dir> [phase-req-ids]', ERROR_REASON.SDK_MISSING_ARG);
+        return;
+    }
+    const phaseReqIds = args[3] ?? undefined;
+    const result = runGapAnalysis(projectDir, phaseDir, { phaseReqIds });
+    // Uniform gate contract: block = false (gap-analysis is always advisory, never blocks).
+    // `message` carries the human-readable gap analysis report so the dispatch's
+    // advisory branch can surface it. --raw emits JSON (rawValue=undefined), not
+    // plain markdown text.
+    output({
+        block: false,
+        passed: true,
+        enabled: result.enabled,
+        table: result.table,
+        summary: result.summary,
+        counts: result.counts,
+        // Human-readable report in `message` for the host-loop advisory branch.
+        message: result.table || result.summary || '',
+    }, raw, undefined);
+}
 function routeCheckCommand({ args, cwd, raw }) {
     // Normalize dots to hyphens in the subcommand so both forms are accepted.
     // This makes `check.query = "ui.plan-gate"` (dotted form in capability.json gates)
@@ -464,11 +761,41 @@ function routeCheckCommand({ args, cwd, raw }) {
         cmdUiPlanGate(cwd, args, raw);
         return;
     }
-    error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, ui-plan-gate', ERROR_REASON.SDK_UNKNOWN_COMMAND);
+    if (subcommand === 'gap-analysis-plan-post') {
+        cmdGapAnalysisPlanPost(cwd, args, raw);
+        return;
+    }
+    if (subcommand === 'tdd-review-checkpoint') {
+        cmdTddReviewCheckpoint(cwd, args, raw);
+        return;
+    }
+    if (subcommand === 'ui-safety-gate') {
+        cmdUiSafetyGate(cwd, args, raw);
+        return;
+    }
+    if (subcommand === 'verify-schema-drift') {
+        // Delegates to verify.schema-drift — drift capability gate at execute:wave:post (blocking).
+        // Dot-to-hyphen normalization means query "verify.schema-drift" routes here.
+        // Honor GSD_SKIP_SCHEMA_CHECK=true to bypass the gate (preserves the original inline gate behavior).
+        const phaseArg = typeof args[2] === 'string' ? args[2] : '';
+        const skipSchemaCheck = process.env['GSD_SKIP_SCHEMA_CHECK'] === 'true';
+        cmdVerifySchemaDrift(cwd, phaseArg, skipSchemaCheck, raw);
+        return;
+    }
+    if (subcommand === 'verify-codebase-drift') {
+        // Delegates to verify.codebase-drift — drift capability gate at execute:wave:post (non-blocking).
+        // Dot-to-hyphen normalization means query "verify.codebase-drift" routes here.
+        cmdVerifyCodebaseDrift(cwd, raw);
+        return;
+    }
+    error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, gap-analysis-plan-post, tdd-review-checkpoint, ui-plan-gate, ui-safety-gate, verify-schema-drift, verify-codebase-drift', ERROR_REASON.SDK_UNKNOWN_COMMAND);
 }
 module.exports = {
     routeCheckCommand,
     decisionMentioned,
     extractPlanDesignatedSections,
     computeUiPlanGate,
+    computeUiSafetyGate,
+    cmdGapAnalysisPlanPost,
+    cmdTddReviewCheckpoint,
 };

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

@@ -112,6 +112,8 @@ exports.CLUSTERS = Object.freeze({
         'review-backlog',
         'debug',
         'extract-learnings',
+        'mempalace-recall',
+        'mempalace-capture',
         'surface',
     ]),
 });

package/gsd-core/bin/lib/command-roster.cjs

@@ -0,0 +1,19 @@
+'use strict';
+/**
+ * Command Roster Module
+ *
+ * Read-only helper for discovering canonical commands/gsd command stems and
+ * applying the shared GSD slash-command namespace transform.
+ */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const slashCommandTransformer = require('../../../scripts/fix-slash-commands.cjs');
+function readGsdCommandNames() {
+    return slashCommandTransformer.readCmdNames();
+}
+module.exports = {
+    readGsdCommandNames,
+    transformContentToHyphen: slashCommandTransformer.transformContentToHyphen,
+    transformContent: slashCommandTransformer.transformContent,
+    buildPattern: slashCommandTransformer.buildPattern,
+    buildColonPattern: slashCommandTransformer.buildColonPattern,
+};

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

@@ -44,11 +44,19 @@ function determinePhaseStatus(plans, summaries, phaseDir, defaultPending) {
         const verificationFile = files.find(f => f === 'VERIFICATION.md' || f.endsWith('-VERIFICATION.md'));
         if (verificationFile) {
             const content = (0, shell_command_projection_cjs_1.platformReadSync)(node_path_1.default.join(phaseDir, verificationFile)) || '';
-            if (/status:\s*passed/i.test(content))
+            // #1159 (Defect A): read ONLY the frontmatter `status` key to avoid false
+            // matches from historical body metadata such as `previous_status: gaps_found`.
+            // Full-text regexes like /status:\s*gaps_found/ match the substring inside
+            // `previous_status: gaps_found`, producing incorrect phase status labels.
+            const fm = extractFrontmatter(content);
+            // Normalise to lower-case to preserve the prior case-insensitive behaviour
+            // while reading only the frontmatter `status` key (not the full body text).
+            const fmStatus = typeof fm['status'] === 'string' ? fm['status'].trim().toLowerCase() : '';
+            if (fmStatus === 'passed')
                 return 'Complete';
-            if (/status:\s*human_needed/i.test(content))
+            if (fmStatus === 'human_needed')
                 return 'Needs Review';
-            if (/status:\s*gaps_found/i.test(content))
+            if (fmStatus === 'gaps_found')
                 return 'Executed';
             // Verification exists but unrecognized status — treat as executed
             return 'Executed';
@@ -505,13 +513,12 @@ function cmdCommit(cwd, message, files, raw, amend, noVerify) {
 /**
  * Route a list of changed files to their sub-repo prefixes.
  *
- * Bucket sub-repos by their first path segment. Any file that matches a
+ * Bucket sub-repos by their first path segment (#311). Any file that matches a
  * sub-repo prefix must share that sub-repo's first segment, so we only scan
- * the (small) bucket for the file's first segment instead of all sub-repos
- * — O(F + R) expected vs the prior O(F*R) find-in-loop. Candidates stay in
- * sub-repo array order, preserving the original first-match semantics
- * (incl. multi-segment sub-repos like "vendor/pkg", which resolve via the
- * inner startsWith). (#311)
+ * the (small) same-first-segment bucket instead of all sub-repos. Within that
+ * bucket all candidates are scanned to find the longest (most-specific)
+ * matching prefix, so nested sub_repos (e.g. ['packages', 'packages/core'])
+ * route to the deepest match regardless of sub_repos array order (#391).
  *
  * @param files    - changed file paths (relative to project root)
  * @param subRepos - sub-repo path prefixes from config.sub_repos
@@ -531,7 +538,23 @@ function groupFilesBySubrepo(files, subRepos) {
     const unmatched = [];
     for (const file of files) {
         const candidates = reposByFirstSeg.get(file.split('/')[0]);
-        const match = candidates ? candidates.find(repo => file.startsWith(repo + '/')) : undefined;
+        // Select the longest (most-specific) matching sub-repo prefix so nested
+        // sub_repos (e.g. ['packages', 'packages/core']) route correctly regardless
+        // of array order. (#391) String() guards the length read so non-string
+        // entries never throw, matching the tolerance of the prior `.find` path.
+        let match;
+        let matchLen = -1;
+        if (candidates) {
+            for (const repo of candidates) {
+                if (file.startsWith(repo + '/')) {
+                    const repoLen = String(repo).length;
+                    if (repoLen > matchLen) {
+                        match = repo;
+                        matchLen = repoLen;
+                    }
+                }
+            }
+        }
         if (match) {
             (grouped[match] ||= []).push(file);
         }

package/gsd-core/bin/lib/config-loader.cjs

@@ -38,7 +38,7 @@ const { detectSubRepos } = coreUtilsModule;
 const configuration_cjs_1 = require("./configuration.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configSchema = require("./config-schema.cjs");
-const { VALID_CONFIG_KEYS, DYNAMIC_KEY_PATTERNS, isValidConfigKey: _isValidConfigKeyFn } = configSchema;
+const { VALID_CONFIG_KEYS, DYNAMIC_KEY_PATTERNS, isCentralConfigKey: _isCentralConfigKeyFn } = configSchema;
 const model_catalog_cjs_1 = require("./model-catalog.cjs");
 // ─── Federated Config (ADR-857 phase 3b) ─────────────────────────────────────
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -331,7 +331,7 @@ function _applyFederatedOverlay(baseConfig, userConfig) {
         return baseConfig;
     const _fedOverlay = mergeFederatedConfig({
         configSchema: _fedRegistrySchema,
-        isCentralKey: (key) => _isValidConfigKeyFn(key),
+        isCentralKey: (key) => _isCentralConfigKeyFn(key),
         userConfig,
     });
     // True no-op: if no federated keys, return UNCHANGED (byte-identical, no clone)
@@ -472,7 +472,7 @@ function loadConfig(cwd, options = {}) {
             // Internal keys loadConfig reads but config-set doesn't expose
             'model_overrides', 'context_window', 'resolve_model_ids', 'claude_md_path', 'effort', 'fast_mode',
             // Deprecated keys (still accepted for migration, not in config-set)
-            'depth', 'multiRepo', 'branching_strategy',
+            'depth', 'multiRepo', 'branching_strategy', 'research',
         ]);
         // FIX 3: Compute federated overlay BEFORE the unknown-key warning, so that
         // federated top-level keys are added to KNOWN_TOP_LEVEL before the check runs.
@@ -483,7 +483,7 @@ function loadConfig(cwd, options = {}) {
             if (_fedRegistrySchemaEarly && typeof _fedRegistrySchemaEarly === 'object') {
                 const _earlyOverlay = mergeFederatedConfig({
                     configSchema: _fedRegistrySchemaEarly,
-                    isCentralKey: (key) => _isValidConfigKeyFn(key),
+                    isCentralKey: (key) => _isCentralConfigKeyFn(key),
                     userConfig: parsed,
                 });
                 _preWarningFedValidKeys = _earlyOverlay.validKeys;
@@ -554,7 +554,6 @@ function loadConfig(cwd, options = {}) {
             brave_search: get('brave_search') ?? defaults.brave_search,
             firecrawl: get('firecrawl') ?? defaults.firecrawl,
             exa_search: get('exa_search') ?? defaults.exa_search,
-            tdd_mode: get('tdd_mode', { section: 'workflow', field: 'tdd_mode' }) ?? false,
             mvp_mode: get('mvp_mode', { section: 'workflow', field: 'mvp_mode' }) ?? false,
             text_mode: get('text_mode', { section: 'workflow', field: 'text_mode' }) ?? defaults.text_mode,
             auto_advance: get('auto_advance', { section: 'workflow', field: 'auto_advance' }) ?? false,
@@ -608,7 +607,7 @@ function loadConfig(cwd, options = {}) {
                 if (_fedRegistrySchema && typeof _fedRegistrySchema === 'object') {
                     const _fedOverlay = mergeFederatedConfig({
                         configSchema: _fedRegistrySchema,
-                        isCentralKey: (key) => _isValidConfigKeyFn(key),
+                        isCentralKey: (key) => _isCentralConfigKeyFn(key),
                         userConfig: parsed,
                     });
                     // Apply dotted-path values (e.g. "workflow.ui_phase" → _baseConfig.workflow.ui_phase)
@@ -634,8 +633,8 @@ function loadConfig(cwd, options = {}) {
                 return loadConfig(cwd, { workstream: null });
             }
             // FIX 2: Apply the federated overlay on the no-config path.
-            // With the current registry (all keys central), _applyFederatedOverlay returns
-            // `defaults` UNCHANGED (true no-op, preserves byte-identical output).
+            // Migrated Capability keys are surfaced from the generated registry even
+            // when the project has no config.json, so schema defaults still apply.
             try {
                 return _applyFederatedOverlay(defaults, {});
             }