@opengsd/gsd-core 1.5.0-rc.4 → 1.5.0

package/gsd-core/bin/lib/loop-resolver.cjs

@@ -20,31 +20,27 @@
  * Both pure functions (resolveLoopHooks, renderLoopHooks) take explicit
  * registry/config arguments so they are trivially testable without I/O.
  *
- * Dependencies (leaf modules only — no core.cjs circular risk):
- *   - node:fs / node:path  (raw config.json read for capability-key activation)
+ * Dependencies (leaf modules only — no circular risk):
  *   - ./config-loader.cjs  (loadConfig)
- *   - ./planning-workspace.cjs  (planningDir — to locate config.json)
- *   - ./core.cjs           (output, error)
+ *   - ./io.cjs             (output, error)
+ *   - ./capability-activation.cjs (resolveConfigKey, _resolveActivationValue, _getNestedConfigValue, _readRawConfigKey)
  *   - loop-host-contract.cjs (CANONICAL_POINTS via LOOP_HOST_CONTRACT)
  *   - capability-registry.cjs (byLoopPoint, consumed at call time)
+ *   - capability-state.cjs (resolveCapabilityRuntimeState — for capabilities list)
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const core = require("./core.cjs");
-const { output: coreOutput, error: coreError } = core;
+const ioMod = require("./io.cjs");
+const { output: coreOutput, error: coreError } = ioMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configLoaderModule = require("./config-loader.cjs");
 const { loadConfig } = configLoaderModule;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const capabilityStateModule = require("./capability-state.cjs");
 const { resolveCapabilityRuntimeState } = capabilityStateModule;
+// ─── Capability-activation engine (single owner for config-key precedence) ────
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const planningWorkspaceMod = require("./planning-workspace.cjs");
-const { planningDir, planningRoot } = planningWorkspaceMod;
+const capabilityActivationModule = require("./capability-activation.cjs");
+const { _getNestedConfigValue, _readRawConfigKey, _resolveActivationValue, resolveConfigKey } = capabilityActivationModule;
 // ─── Canonical points (derived from LOOP_HOST_CONTRACT — authoritative 12) ───
 // FIX 2: Derive the authoritative canonical set from LOOP_HOST_CONTRACT so it
 // cannot drift from the host contract. CANONICAL_POINTS_FALLBACK is kept as an
@@ -92,123 +88,12 @@ const CANONICAL_POINTS_FALLBACK = CANONICAL_POINTS;
 function _getCanonicalPoints(_registry) {
     return CANONICAL_POINTS;
 }
-// ─── Prototype-pollution guard (inline literal, CodeQL barrier) ───────────────
-/**
- * Traverse a dotted config key through a nested config object.
- * E.g. "workflow.ui_phase" in { workflow: { ui_phase: true } } → { found: true, value: true }
- * Returns { found: false } if any segment is a forbidden key or not an own property.
- */
-function _getNestedConfigValue(config, dotKey) {
-    const segments = dotKey.split('.');
-    let current = config;
-    for (const seg of segments) {
-        // Inline literal prototype-pollution guard (CodeQL barrier)
-        if (seg === '__proto__' || seg === 'constructor' || seg === 'prototype') {
-            return { found: false, value: undefined };
-        }
-        if (typeof current !== 'object' || current === null) {
-            return { found: false, value: undefined };
-        }
-        const cur = current;
-        if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
-            return { found: false, value: undefined };
-        }
-        current = cur[seg];
-    }
-    return { found: true, value: current };
-}
-// ─── Single-key activation resolver (FIX 1) ───────────────────────────────────
-/**
- * Warn-once set for raw config.json parse errors.
- * Avoids noisy per-call stderr from a single malformed file.
- */
-const _warnedRawConfigPaths = new Set();
-/**
- * Read a raw config.json file and perform a guarded nested-lookup of a single
- * dotted key. Returns { found: false } if the file is missing (ENOENT) or if
- * the key is absent/forbidden. On a genuine JSON parse error: warns once to
- * stderr and returns { found: false } — never throws.
- */
-function _readRawConfigKey(filePath, dotKey) {
-    try {
-        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch {
-            if (!_warnedRawConfigPaths.has(filePath)) {
-                _warnedRawConfigPaths.add(filePath);
-                try {
-                    process.stderr.write(`gsd-tools: warning: failed to parse ${filePath} as JSON — skipping for activation resolution\n`);
-                }
-                catch { /* stderr might be closed */ }
-            }
-            return { found: false, value: undefined };
-        }
-        return _getNestedConfigValue(parsed, dotKey);
-    }
-    catch {
-        // ENOENT (missing file) is expected → skip silently. All other errors → also skip (defensive).
-        return { found: false, value: undefined };
-    }
-}
-/**
- * FIX 1: Resolve the effective value for a hook's `when` key using the
- * four-level precedence:
- *
- * 1. loadConfig result (`config` arg) — guarded nested-lookup of the dotted key.
- *    This is the post-cutover federated path (covers keys that loadConfig now exposes).
- * 2. Raw workstream `.planning/.../config.json` — guarded single-key lookup.
- *    Workstream wins over root (mirrors loadConfig inheritance).
- * 3. Raw root `.planning/config.json` — guarded single-key lookup.
- * 4. `registry.configSchema[when]?.default` — schema default.
- *    A `default: true` hook is active out-of-the-box without any config.
- * 5. Absent → inactive (return false).
- *
- * Never constructs a merged object from raw JSON keys — only reads the single
- * leaf value at the guarded dotted path.  Prototype-pollution sink is eliminated.
- */
-function _resolveActivationValue(dotKey, config, cwd, registry) {
-    // Level 1: loadConfig result
-    const fromConfig = _getNestedConfigValue(config, dotKey);
-    if (fromConfig.found)
-        return Boolean(fromConfig.value);
-    // Level 2 + 3: raw config.json files (only when cwd is available)
-    if (cwd) {
-        // Level 2: workstream config (planningDir respects GSD_WORKSTREAM env)
-        const wsConfigPath = node_path_1.default.join(planningDir(cwd), 'config.json');
-        // Level 3: root config (planningRoot = cwd/.planning always)
-        const rootConfigPath = node_path_1.default.join(planningRoot(cwd), 'config.json');
-        // Workstream wins over root (mirroring loadConfig root→workstream precedence:
-        // workstream overlays root, so workstream value takes precedence).
-        const fromWs = _readRawConfigKey(wsConfigPath, dotKey);
-        if (fromWs.found)
-            return Boolean(fromWs.value);
-        // Only read root if it differs from the workstream path (avoids double-read
-        // when no workstream is active and both paths resolve to the same file).
-        if (wsConfigPath !== rootConfigPath) {
-            const fromRoot = _readRawConfigKey(rootConfigPath, dotKey);
-            if (fromRoot.found)
-                return Boolean(fromRoot.value);
-        }
-    }
-    // Level 4: registry configSchema default
-    const schemaEntry = registry['configSchema']?.[dotKey];
-    if (schemaEntry && typeof schemaEntry === 'object' && schemaEntry !== null) {
-        const def = schemaEntry['default'];
-        if (def !== undefined)
-            return Boolean(def);
-    }
-    // Level 5: absent → inactive
-    return false;
-}
 // ─── Pure resolver ─────────────────────────────────────────────────────────────
 /**
  * Pure resolver: given a point, registry, and config, returns the active hooks.
  *
  * Throws if `point` is not one of the 12 canonical points (caller converts to
- * core.error). Never throws for malformed registry/hook entries — skips and
+ * io.error). Never throws for malformed registry/hook entries — skips and
  * continues.
  *
  * Ordering: steps first, then contributions, then gates. Within each array,
@@ -248,7 +133,7 @@ function resolveLoopHooks(input) {
             return false;
         return _resolveActivationValue(when, config, cwd, registry);
     }
-    function isCapabilityEnabled(capId) {
+    function isCapabilityActive(capId) {
         if (!capabilityStatesById)
             return true;
         const state = capabilityStatesById instanceof Map
@@ -256,7 +141,12 @@ function resolveLoopHooks(input) {
             : capabilityStatesById[capId];
         if (!state)
             return false;
-        return state.enabled !== false;
+        // Fail-closed gate: only render the hook when active is explicitly true.
+        // A capability can be installed and surfaced (enabled=true) but config-disabled
+        // (active=false); in that case the hook must not render.
+        // Phase 4 tri-state alignment: `active` is now required (not optional), so
+        // `=== true` is the correct fail-closed check (not `!== false`).
+        return state.active === true;
     }
     // Helper: safe string array
     function toStringArray(v) {
@@ -294,39 +184,9 @@ function resolveLoopHooks(input) {
                 continue;
             if (typeof dotKey !== 'string')
                 continue;
-            // Level 1: loadConfig result
-            const fromConfig = _getNestedConfigValue(config, dotKey);
-            if (fromConfig.found) {
-                resolved[alias] = fromConfig.value;
-                continue;
-            }
-            // Level 2 + 3: raw config.json files
-            if (cwd) {
-                const wsConfigPath = node_path_1.default.join(planningDir(cwd), 'config.json');
-                const rootConfigPath = node_path_1.default.join(planningRoot(cwd), 'config.json');
-                const fromWs = _readRawConfigKey(wsConfigPath, dotKey);
-                if (fromWs.found) {
-                    resolved[alias] = fromWs.value;
-                    continue;
-                }
-                if (wsConfigPath !== rootConfigPath) {
-                    const fromRoot = _readRawConfigKey(rootConfigPath, dotKey);
-                    if (fromRoot.found) {
-                        resolved[alias] = fromRoot.value;
-                        continue;
-                    }
-                }
-            }
-            // Level 4: registry configSchema default
-            const schemaEntry = registry['configSchema']?.[dotKey];
-            if (schemaEntry && typeof schemaEntry === 'object' && schemaEntry !== null) {
-                const def = schemaEntry['default'];
-                if (def !== undefined) {
-                    resolved[alias] = def;
-                    continue;
-                }
-            }
-            // Level 5: absent → undefined (omit from resolved map)
+            const r = resolveConfigKey(dotKey, { config, cwd, registry });
+            if (r.found)
+                resolved[alias] = r.value;
         }
         return Object.keys(resolved).length > 0 ? resolved : undefined;
     }
@@ -337,7 +197,7 @@ function resolveLoopHooks(input) {
         if (!hook || typeof hook !== 'object')
             continue;
         const capId = typeof hook['capId'] === 'string' ? hook['capId'] : '';
-        if (!isCapabilityEnabled(capId))
+        if (!isCapabilityActive(capId))
             continue;
         if (!isActive(hook))
             continue;
@@ -371,7 +231,7 @@ function resolveLoopHooks(input) {
         if (!hook || typeof hook !== 'object')
             continue;
         const capId = typeof hook['capId'] === 'string' ? hook['capId'] : '';
-        if (!isCapabilityEnabled(capId))
+        if (!isCapabilityActive(capId))
             continue;
         if (!isActive(hook))
             continue;
@@ -406,7 +266,7 @@ function resolveLoopHooks(input) {
         if (!hook || typeof hook !== 'object')
             continue;
         const capId = typeof hook['capId'] === 'string' ? hook['capId'] : '';
-        if (!isCapabilityEnabled(capId))
+        if (!isCapabilityActive(capId))
             continue;
         if (!isActive(hook))
             continue;
@@ -524,7 +384,7 @@ function renderLoopHooks(resolved) {
  * Command entry point: load registry + config, resolve + render, emit envelope.
  *
  * Envelope: { point, activeHooks, rendered }
- * On invalid point, emits core.error instead of throwing.
+ * On invalid point, emits io.error instead of throwing.
  *
  * Config note: FIX 1 replaced _loadMergedConfig (whole-config deep-merge) with a
  * per-hook single-key activation resolver (_resolveActivationValue). The resolver
@@ -555,9 +415,24 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
     const runtimeConfigDir = typeof options['configDir'] === 'string'
         ? options['configDir']
         : undefined;
-    const state = resolveCapabilityRuntimeState(cwd, runtimeConfigDir);
-    const registry = state.registry;
-    const config = state.config || loadConfig(cwd);
+    // Load the config snapshot ONCE and share it with both the capability-state
+    // resolver (via configOverride) and loop-hook resolution, so federated keys
+    // present in loadConfig resolve identically for `active` and for hook when/
+    // configValues — eliminating the previous double loadConfig() call. Note: keys
+    // absent from loadConfig still fall through to raw .planning/config.json reads
+    // (precedence levels 2-3) in each pass; that residual re-read window is
+    // pre-existing (unchanged by this consolidation), not introduced here.
+    let config;
+    try {
+        config = loadConfig(cwd);
+    }
+    catch {
+        config = {};
+    }
+    const state = resolveCapabilityRuntimeState(cwd, runtimeConfigDir, config);
+    // Registry is the static generated module — same object capability-state uses internally.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const registry = require('./capability-registry.cjs');
     const capabilityStatesById = new Map();
     for (const cap of state.capabilities || []) {
         capabilityStatesById.set(cap.id, cap);
@@ -596,6 +471,9 @@ module.exports = {
     _getNestedConfigValue,
     _resolveActivationValue,
     _readRawConfigKey,
+    // Re-exported for identity parity guard (FIX 2: resolveConfigValues in this module
+    // calls resolveConfigKey; exporting it here makes the single-owner contract testable).
+    resolveConfigKey,
     CANONICAL_POINTS_FALLBACK,
     CANONICAL_POINTS,
 };

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

@@ -11,8 +11,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-// eslint-disable-next-line @typescript-eslint/no-require-imports -- core.cjs is an export= CommonJS module
-const core = require("./core.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-workspace.cjs is an export= CommonJS module
 const planningWorkspace = require("./planning-workspace.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- frontmatter.cjs is an export= CommonJS module
@@ -21,7 +19,18 @@ const frontmatterMod = require("./frontmatter.cjs");
 const stateMod = require("./state.cjs");
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
-const { escapeRegex, getMilestonePhaseFilter, extractOneLinerFromBody, normalizePhaseName, phaseTokenMatches, output, error, } = core;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const ioMod = require("./io.cjs");
+const { output, error } = ioMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const phaseIdMod = require("./phase-id.cjs");
+const { escapeRegex, normalizePhaseName, phaseTokenMatches } = phaseIdMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const roadmapParserMod = require("./roadmap-parser.cjs");
+const { getMilestonePhaseFilter, extractCurrentMilestone } = roadmapParserMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const coreUtilsMod = require("./core-utils.cjs");
+const { extractOneLinerFromBody } = coreUtilsMod;
 const { planningPaths } = planningWorkspace;
 const { extractFrontmatter } = frontmatterMod;
 const { writeStateMd, stateReplaceFieldWithFallback } = stateMod;
@@ -109,7 +118,7 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
     // Ensure archive directory exists
     (0, shell_command_projection_cjs_1.platformEnsureDir)(archiveDir);
     // Scope stats and accomplishments to only the phases belonging to the
-    // current milestone's ROADMAP.  Uses the shared filter from core.cjs
+    // current milestone's ROADMAP.  Uses the shared filter from roadmap-parser.cjs
     // (same logic used by cmdPhasesList and other callers).
     const isDirInMilestone = getMilestonePhaseFilter(cwd, version);
     if (isDirInMilestone.missingExplicitVersion) {
@@ -138,7 +147,6 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
                 /* skip */
             }
             if (stateVersion && stateVersion === version) {
-                const { extractCurrentMilestone } = core;
                 const roadmapContent = node_fs_1.default.readFileSync(roadmapPath, 'utf-8');
                 const scopedContent = extractCurrentMilestone(roadmapContent, cwd);
                 const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n]+)/gi;

package/gsd-core/bin/lib/model-resolver.cjs

@@ -7,11 +7,10 @@
  * planning granularity, reasoning effort, and fast-mode for a given agent by
  * reading project config and resolving against the model profiles and catalog.
  * Behaviour is preserved byte-for-behaviour from the prior location; only
- * the module boundary moved. core.cjs re-exports the resolvers for back-compat.
+ * the module boundary moved. The core.cjs re-export spine was retired in
+ * epic #1267; callers import resolvers from model-resolver.cjs directly.
  *
- * New imports should pull resolvers from model-resolver.cjs directly.
- *
- * Dependencies (leaf modules only — no core.cjs):
+ * Dependencies (leaf modules only):
  *   - node:fs / node:path (stdlib, not currently needed — included for future use)
  *   - ./config-loader.cjs    (loadConfig)
  *   - ./configuration.cjs    (CONFIG_DEFAULTS as CANONICAL_CONFIG_DEFAULTS)

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

@@ -5,10 +5,8 @@
  *
  * Extracted from core.cts (ADR-857 rollout phase 2a / issue #865).
  * The hand-written bodies are preserved byte-for-behaviour; only the module
- * boundary moved. core.cts re-exports every symbol here under its own
- * `export =` object so existing consumers are unaffected.
- *
- * New imports should pull phase-id helpers from phase-id.cjs directly.
+ * boundary moved. The core.cjs re-export spine was retired in epic #1267;
+ * callers import phase-id helpers from phase-id.cjs directly.
  *
  * Dependencies: none (pure string/regex, no Node built-ins required).
  */
@@ -175,7 +173,7 @@ function extractPhaseToken(dirName) {
     const tokenSegments = [];
     for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
-        if (/^\d/.test(seg)) {
+        if (/^\d/.test(seg) || (i === 0 && /^[A-Za-z]{1,3}\d/.test(seg))) {
             tokenSegments.push(seg);
         }
         else {

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

@@ -7,13 +7,10 @@
  * (`searchPhaseInDir`, `findPhaseInternal`) and archived-phase-dir
  * enumeration (`getArchivedPhaseDirs`), matching phase ids/tokens against
  * the filesystem. Behaviour is preserved byte-for-behaviour from the prior
- * location; only the module boundary moved. core.cjs re-exports
- * `searchPhaseInDir`, `findPhaseInternal`, and `getArchivedPhaseDirs` for back-compat.
+ * location; only the module boundary moved. The core.cjs re-export spine
+ * was retired in epic #1267; callers import phase-locator helpers directly.
  *
- * New imports should pull phase-locator helpers from phase-locator.cjs
- * directly.
- *
- * Dependencies (leaf modules only — no core.cjs, no loadConfig):
+ * Dependencies (leaf modules only — no loadConfig):
  *   - node:fs / node:path (stdlib)
  *   - ./phase-id.cjs       (normalizePhaseName, phaseTokenMatches, extractPhaseToken)
  *   - ./core-utils.cjs     (readSubdirectories, getPhaseFileStats, extractCanonicalPlanId, toPosixPath)

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

@@ -21,8 +21,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-// eslint-disable-next-line @typescript-eslint/no-require-imports -- core.cjs is an export= CommonJS module
-const core = require("./core.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- io.cjs is an export= CommonJS module
+const ioMod = require("./io.cjs");
+const { output, error, ERROR_REASON } = ioMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- config-loader.cjs is an export= CommonJS module
+const configLoaderMod = require("./config-loader.cjs");
+const { loadConfig } = configLoaderMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- core-utils.cjs is an export= CommonJS module
+const coreUtilsMod = require("./core-utils.cjs");
+const { toPosixPath, generateSlugInternal, readSubdirectories } = coreUtilsMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-id.cjs is an export= CommonJS module
+const phaseIdMod = require("./phase-id.cjs");
+const { escapeRegex, normalizePhaseName, phaseMarkdownRegexSource, comparePhaseNum, phaseTokenMatches } = phaseIdMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-locator.cjs is an export= CommonJS module
+const phaseLocatorMod = require("./phase-locator.cjs");
+const { findPhaseInternal, getArchivedPhaseDirs } = phaseLocatorMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- roadmap-parser.cjs is an export= CommonJS module
+const roadmapParserMod = require("./roadmap-parser.cjs");
+const { stripShippedMilestones, extractCurrentMilestone, getMilestonePhaseFilter } = roadmapParserMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-workspace.cjs is an export= CommonJS module
 const planningWorkspace = require("./planning-workspace.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- frontmatter.cjs is an export= CommonJS module
@@ -36,14 +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;
-const { escapeRegex, loadConfig, normalizePhaseName, phaseMarkdownRegexSource, comparePhaseNum, findPhaseInternal, getArchivedPhaseDirs, generateSlugInternal, getMilestonePhaseFilter, stripShippedMilestones, extractCurrentMilestone, replaceInCurrentMilestone, toPosixPath, output, error, readSubdirectories, phaseTokenMatches, ERROR_REASON, } = core;
 const { planningDir, withPlanningLock } = planningWorkspace;
 const { extractFrontmatter } = frontmatterMod;
 const { readModifyWriteStateMd, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, syncStateFrontmatter, withStateLock, updatePerformanceMetricsSection, } = stateMod;
-// Unused import silences TS — keep for structural parity with .cjs (stripShippedMilestones,
-// replaceInCurrentMilestone are exported from core but only used in phase.cjs as-is).
-void stripShippedMilestones;
-void replaceInCurrentMilestone;
 // #2893 — strict canonical filter: `{padded_phase}-{NN}-PLAN.md` or `PLAN.md`.
 const isCanonicalPlanFile = (f) => f.endsWith('-PLAN.md') || f === 'PLAN.md';
 // Any .md file with PLAN anywhere in the basename — diagnostic net
@@ -1029,6 +1040,22 @@ function writePlanningFileSet(writes) {
         throw err;
     }
 }
+function phaseDisplayNameFromRoadmap(roadmapContent, phaseNum) {
+    if (!roadmapContent || !phaseNum)
+        return null;
+    const phaseEscaped = phaseMarkdownRegexSource(phaseNum);
+    const heading = roadmapContent.match(new RegExp(`^#{2,4}\\s*Phase\\s+${phaseEscaped}\\s*:\\s*([^\\n]+)`, 'im'));
+    if (!heading)
+        return null;
+    const name = heading[1].replace(/\(INSERTED\)/i, '').trim();
+    return name || null;
+}
+function phaseDisplayNameFromSlug(slug) {
+    if (!slug)
+        return null;
+    const name = slug.replace(/-/g, ' ').trim();
+    return name || null;
+}
 function cmdPhaseComplete(cwd, phaseNum, raw) {
     if (!phaseNum) {
         error('phase number required for phase complete');
@@ -1276,6 +1303,8 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                 const originalStateContent = (0, shell_command_projection_cjs_1.platformReadSync)(statePath) || '';
                 let stateContent = originalStateContent;
                 const phaseValue = nextPhaseNum || phaseNum;
+                const nextPhaseDisplayName = phaseDisplayNameFromRoadmap(roadmapContent, nextPhaseNum) ??
+                    phaseDisplayNameFromSlug(nextPhaseName);
                 const existingPhaseField = stateExtractField(stateContent, 'Current Phase') ||
                     stateExtractField(stateContent, 'Phase');
                 let newPhaseValue = String(phaseValue);
@@ -1284,22 +1313,39 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                     const nameMatch = existingPhaseField.match(/\(([^)]+)\)/);
                     if (totalMatch) {
                         const total = totalMatch[1];
-                        const nameStr = nextPhaseName
-                            ? ` (${nextPhaseName.replace(/-/g, ' ')})`
+                        const nameStr = nextPhaseDisplayName
+                            ? ` (${nextPhaseDisplayName})`
                             : nameMatch
                                 ? ` (${nameMatch[1]})`
                                 : '';
                         newPhaseValue = `${phaseValue} of ${total}${nameStr}`;
                     }
+                    else if (nextPhaseDisplayName) {
+                        newPhaseValue = `${phaseValue} — ${nextPhaseDisplayName}`;
+                    }
                 }
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Phase', 'Phase', newPhaseValue);
-                if (nextPhaseName) {
-                    stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Phase Name', null, nextPhaseName.replace(/-/g, ' '));
+                if (nextPhaseDisplayName) {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Current Phase Name', nextPhaseDisplayName) ||
+                            stateContent;
                 }
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Status', null, isLastPhase ? 'Milestone complete' : 'Ready to plan');
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Plan', 'Plan', 'Not started');
-                stateContent = stateReplaceFieldWithFallback(stateContent, 'Last Activity', 'Last activity', today);
-                stateContent = stateReplaceFieldWithFallback(stateContent, 'Last Activity Description', null, `Phase ${phaseNum} complete${nextPhaseNum ? `, transitioned to Phase ${nextPhaseNum}` : ''}`);
+                const lastActivityDescription = `Phase ${phaseNum} complete${nextPhaseNum ? `, transitioned to Phase ${nextPhaseNum}` : ''}`;
+                if (/^Last activity:/m.test(stateContent)) {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Last activity', `${today} — ${lastActivityDescription}`) ||
+                            stateContent;
+                }
+                else {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Last Activity', today) ||
+                            stateContent;
+                }
+                stateContent =
+                    stateReplaceField(stateContent, 'Last Activity Description', lastActivityDescription) ||
+                        stateContent;
                 const completedRaw = stateExtractField(stateContent, 'Completed Phases');
                 if (completedRaw !== null) {
                     let newCompleted = parseInt(completedRaw, 10);

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

@@ -241,6 +241,15 @@ function validateProhibitionResolution(resolution) {
  * and are intentionally NOT projected into the plan block (which is keyed on the must-NOT
  * statement, not the source requirement). A non-array input projects to `[]` (fail-soft on the
  * empty/zero-prohibition case), never a throw.
+ *
+ * An OPTIONAL wired-check descriptor (#1278) projects as the LOCKED flat scalar keys
+ * `check_kind`/`check_target`/`check_rule` (NEVER a nested `check:{}` object; `failFirst` is never
+ * projected). These ride the EXISTING continuation-KV path of `parseMustHavesBlock`
+ * (src/frontmatter.cts:344) with NO shared-parser rewrite (IMPL-SCOPING §3 Option 1). The keys are
+ * emitted ONLY for a well-formed descriptor (valid `check_kind` + non-empty `check_target`; plus
+ * `check_rule` only for a lint-rule that carries one); a descriptor-less or under-specified item is
+ * byte-identical to today (CHK-07), so an under-specified descriptor projects absent and fails closed
+ * at the producer downstream (CHK-06), never as a partial-but-locatable green.
  */
 function projectProhibitions(items) {
     if (!Array.isArray(items))
@@ -259,6 +268,27 @@ function projectProhibitions(items) {
             entry.verification = String(p.verification);
         if (p.reason != null && String(p.reason).trim())
             entry.reason = String(p.reason);
+        // Optional wired-check descriptor (#1278): emit flat scalars ONLY when well-formed. A valid kind
+        // plus a non-empty target is the minimum; under that bar nothing is emitted (CHK-07 byte-identity,
+        // and the producer fails closed on the absent descriptor — CHK-06).
+        const kind = p.check_kind;
+        const targetOk = typeof p.check_target === 'string' && p.check_target.trim() !== '';
+        if ((kind === 'node-test' || kind === 'lint-rule') && targetOk) {
+            entry.check_kind = kind;
+            entry.check_target = String(p.check_target);
+            // `check_rule` rides only the lint-rule path (node-test never carries one); a lint-rule missing
+            // its rule leaves check_rule absent so the producer's fail-closed locate rejects it (CHK-06).
+            if (kind === 'lint-rule' && typeof p.check_rule === 'string' && p.check_rule.trim() !== '') {
+                entry.check_rule = String(p.check_rule);
+            }
+            // `check_violation_fixture` (#1346) rides BOTH kinds — it's what the #1279 prover machine-proves
+            // fail-first against. Emit ONLY a non-empty fixture (a blank one projects absent so green still
+            // hard-gates downstream — never a partial green); meaningless without the descriptor, so it lives
+            // inside this well-formed-descriptor branch.
+            if (typeof p.check_violation_fixture === 'string' && p.check_violation_fixture.trim() !== '') {
+                entry.check_violation_fixture = String(p.check_violation_fixture);
+            }
+        }
         out.push(entry);
     }
     return out;
@@ -270,11 +300,10 @@ function projectProhibitions(items) {
  * This is the cheap safety guarantee: a well-formed prohibition that reaches verify-phase with NO
  * wired enforcement evidence can NEVER be a silent pass. It is `{ status: 'unverified', flagged:
  * true }` — never `green` — exactly like an unresolved judgment item. The HEAVY half (a real
- * fail-first negative-test enforcement mechanism that, given evidence, would flip a test-tier item
- * to green) is OUT of #644 scope and defers to a follow-up PR: #644's corpus is entirely
- * judgment-tier, so wiring a contrived test-tier consumer here would be the delete-bad-tests /
- * gold-plating failure mode. Until that follow-up lands, ANY prohibition without enforcement
- * evidence — test- or judgment-tier — disposes as flagged-unverified.
+ * negative-test enforcement mechanism that, given evidence, flips a test-tier item to green) was OUT
+ * of #644 scope and LANDED in #1259 as the `prohibition-enforcement` producer (it builds the
+ * `enforcementEvidence` this helper reads). This helper's policy is unchanged: ANY prohibition
+ * without enforcement evidence — test- or judgment-tier — disposes as flagged-unverified.
  *
  * The function is pure: same input always yields the same disposition (no LLM judgment, ADR-550
  * D5). The LLM-judge soft-gate for judgment-tier items is a verify-phase PROSE concern (the
@@ -287,23 +316,23 @@ function dispositionForProhibition(prohibition, context = {}) {
     const evidence = Array.isArray(context.enforcementEvidence) ? context.enforcementEvidence : [];
     const hasEnforcement = evidence.length > 0;
     // FAIL CLOSED: no wired enforcement evidence -> flagged unverified, never green. This holds for
-    // every tier today (the real enforcement mechanism that could flip a test-tier item to green is
-    // deferred to a follow-up PR). The guard the safety assertion proves: an unwired item can never
-    // be silently skipped.
+    // every tier (the producer that builds enforcement evidence for a test-tier item — the
+    // `prohibition-enforcement` module — landed in #1259). The guard the safety assertion proves: an
+    // unwired item can never be silently skipped.
     if (!hasEnforcement) {
         return {
             status: 'unverified',
             flagged: true,
             tier,
             reason: tier === 'test'
-                ? 'test-tier prohibition has no wired enforcement evidence — flagged unverified (fail-closed; real negative-test enforcement deferred to a follow-up PR, ADR-550 D5d)'
+                ? 'test-tier prohibition has no passing wired enforcement check — flagged unverified (fail-closed; never a silent pass, ADR-550 D5d)'
                 : 'prohibition has no enforcement evidence — flagged unverified (fail-closed; never a silent pass, ADR-550 D5d)',
         };
     }
     // D4 GUARD: a judgment-tier (or unknown-tier) prohibition is NEVER a silent green from this
     // deterministic helper — it always routes to human/LLM judgment review (ADR-550 D4; verify-phase.md).
-    // Only a test-tier item with wired enforcement evidence may go green, and even that is the deferred
-    // heavy half until the real negative-test enforcement mechanism lands (no #644 caller passes evidence).
+    // Only a test-tier item with wired enforcement evidence may go green; the producer that supplies
+    // that evidence (`prohibition-enforcement`, #1259) runs the wired check and requires a genuine pass.
     if (tier === 'test') {
         return {
             status: 'green',

package/gsd-core/bin/lib/profile-output.cjs

@@ -20,8 +20,11 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const core = require("./core.cjs");
-const { output, error, loadConfig } = core;
+const io = require("./io.cjs");
+const { output, error } = io;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const configLoader = require("./config-loader.cjs");
+const { loadConfig } = configLoader;
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
 const runtime_homes_cjs_1 = require("./runtime-homes.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");