@opengsd/gsd-core 1.5.0 → 1.6.0-rc.1

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

@@ -17,6 +17,7 @@ const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs")
 const io = require("./io.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- config-loader.cjs is an export= CommonJS module
 const configLoader = require("./config-loader.cjs");
+const project_root_cjs_1 = require("./project-root.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- model-resolver.cjs is an export= CommonJS module
 const modelResolver = require("./model-resolver.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-locator.cjs is an export= CommonJS module
@@ -48,8 +49,9 @@ const { checkAgentsInstalled } = agentInstallCheck;
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- git-base-branch.cjs is an export= CommonJS module
 const gitBaseBranch = require("./git-base-branch.cjs");
 const { gitWorktreeInfoInternal } = gitBaseBranch;
+const resolution_cjs_1 = require("./resolution.cjs");
 const { output, error } = io;
-const { loadConfig } = configLoader;
+const { loadConfig, loadConfigResolved } = configLoader;
 const { resolveModelInternal, resolveGranularityInternal, assertValidGranularityOverride } = modelResolver;
 const { findPhaseInternal } = phaseLocator;
 const { getRoadmapPhaseInternal, getMilestoneInfo, getMilestonePhaseFilter, stripShippedMilestones, extractCurrentMilestone, } = roadmapParser;
@@ -1542,7 +1544,12 @@ function cmdInitRemoveWorkspace(cwd, name, raw) {
     };
     output(result, raw);
 }
-function buildAgentSkillsBlock(config, agentType, projectRoot) {
+function buildAgentSkillsBlock(config, agentType, projectRoot, diagnostics) {
+    const warn = (message) => {
+        process.stderr.write(message);
+        if (diagnostics)
+            diagnostics.warnings.push(message.replace(/\n+$/, ''));
+    };
     const runtime = (config && config['runtime']) || 'claude';
     const globalSkillsBase = (0, runtime_homes_cjs_1.getGlobalSkillsBase)(runtime);
     if (!config || !config['agent_skills'] || !agentType)
@@ -1552,7 +1559,11 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
         return '';
     if (typeof skillPaths === 'string')
         skillPaths = [skillPaths];
-    if (!Array.isArray(skillPaths) || skillPaths.length === 0)
+    if (!Array.isArray(skillPaths)) {
+        warn(`[agent-skills] WARNING: Agent "${agentType}" has a malformed agent_skills value (expected string or array, got ${typeof skillPaths}) — ignoring\n`);
+        return '';
+    }
+    if (skillPaths.length === 0)
         return '';
     // Hoist trusted roots computation before the loop: loadTrustedGlobalRoots does
     // realpathSync I/O and should run at most once per call, not once per failing skill.
@@ -1563,18 +1574,20 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
     // Skill-tool directive ({ kind: 'directive', name }) for plugin-provided namespaced skills.
     const validEntries = [];
     for (const skillPath of skillPaths) {
-        if (typeof skillPath !== 'string')
+        if (typeof skillPath !== 'string') {
+            warn(`[agent-skills] WARNING: Ignoring non-string skill entry (${typeof skillPath}) — skipping\n`);
             continue;
+        }
         if (skillPath.startsWith('global:')) {
             const skillName = skillPath.slice(7);
             if (!skillName) {
-                process.stderr.write(`[agent-skills] WARNING: "global:" prefix with empty skill name — skipping\n`);
+                warn(`[agent-skills] WARNING: "global:" prefix with empty skill name — skipping\n`);
                 continue;
             }
             // Accept: one or more [A-Za-z0-9_-]+ segments joined by single colons.
             // Rejects: empty segments (::), leading/trailing colon, dots, slashes, backslashes.
             if (!/^[A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)*$/.test(skillName)) {
-                process.stderr.write(`[agent-skills] WARNING: Invalid global skill name "${skillName}" — skipping\n`);
+                warn(`[agent-skills] WARNING: Invalid global skill name "${skillName}" — skipping\n`);
                 continue;
             }
             const isNamespaced = skillName.includes(':');
@@ -1585,20 +1598,20 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
                     validEntries.push({ kind: 'directive', name: skillName });
                 }
                 else {
-                    process.stderr.write(`[agent-skills] WARNING: Plugin-namespaced skill "global:${skillName}" requires a Skill-tool-capable runtime (claude) — skipping on runtime "${runtime}"\n`);
+                    warn(`[agent-skills] WARNING: Plugin-namespaced skill "global:${skillName}" requires a Skill-tool-capable runtime (claude) — skipping on runtime "${runtime}"\n`);
                 }
                 continue;
             }
             // Non-namespaced bare name: attempt filesystem resolution as before.
             if (globalSkillsBase === null) {
-                process.stderr.write(`[agent-skills] WARNING: Runtime "${runtime}" does not use a skills directory — "global:${skillName}" is not supported on this runtime\n`);
+                warn(`[agent-skills] WARNING: Runtime "${runtime}" does not use a skills directory — "global:${skillName}" is not supported on this runtime\n`);
                 continue;
             }
             const globalSkillDir = (0, runtime_homes_cjs_1.getGlobalSkillDir)(runtime, skillName);
             const globalSkillMd = node_path_1.default.join(globalSkillDir, 'SKILL.md');
             const displayPath = (0, runtime_homes_cjs_1.getGlobalSkillDisplayPath)(runtime, skillName);
             if (!node_fs_1.default.existsSync(globalSkillMd)) {
-                process.stderr.write(`[agent-skills] WARNING: Global skill not found at "${displayPath}/SKILL.md" — skipping\n`);
+                warn(`[agent-skills] WARNING: Global skill not found at "${displayPath}/SKILL.md" — skipping\n`);
                 continue;
             }
             const pathCheck = (0, security_cjs_1.validatePath)(globalSkillMd, globalSkillsBase, { allowAbsolute: true });
@@ -1608,9 +1621,11 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
                     return Boolean(rootCheck['safe']);
                 });
                 if (!acceptedViaTrustedRoot) {
-                    process.stderr.write(`[agent-skills] WARNING: Global skill "${skillName}" failed path check (symlink escape?) — skipping\n`);
+                    warn(`[agent-skills] WARNING: Global skill "${skillName}" failed path check (symlink escape?) — skipping\n`);
                     continue;
                 }
+                // Intentionally a direct stderr write, NOT warn(): this is an acceptance
+                // trace, not a skip, so it must not land in the diagnostics warnings[].
                 process.stderr.write(`[agent-skills] NOTE: Global skill "${skillName}" accepted via trusted_global_roots (resolves outside the default skills dir)\n`);
             }
             validEntries.push({ kind: 'include', ref: `${globalSkillDir}/SKILL.md`, display: displayPath });
@@ -1618,18 +1633,20 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
         }
         const pathCheck = (0, security_cjs_1.validatePath)(skillPath, projectRoot);
         if (!pathCheck['safe']) {
-            process.stderr.write(`[agent-skills] WARNING: Skipping unsafe path "${skillPath}": ${pathCheck['error']}\n`);
+            warn(`[agent-skills] WARNING: Skipping unsafe path "${skillPath}": ${pathCheck['error']}\n`);
             continue;
         }
         const skillMdPath = node_path_1.default.join(projectRoot, skillPath, 'SKILL.md');
         if (!node_fs_1.default.existsSync(skillMdPath)) {
-            process.stderr.write(`[agent-skills] WARNING: Skill not found at "${skillPath}/SKILL.md" — skipping\n`);
+            warn(`[agent-skills] WARNING: Skill not found at "${skillPath}/SKILL.md" — skipping\n`);
             continue;
         }
         validEntries.push({ kind: 'include', ref: `${skillPath}/SKILL.md`, display: skillPath });
     }
-    if (validEntries.length === 0)
+    if (validEntries.length === 0) {
+        warn(`[agent-skills] WARNING: Agent "${agentType}" has ${skillPaths.length} configured skill path(s) but none resolved to a valid skill — all were skipped (see warnings above)\n`);
         return '';
+    }
     const lines = validEntries.map((entry) => {
         if (entry.kind === 'directive') {
             return `- Load the \`${entry.name}\` skill via the Skill tool before proceeding (plugin-provided).`;
@@ -1643,16 +1660,68 @@ function cmdAgentSkills(cwd, agentType, raw, jsonMode) {
         output('', raw, '');
         return;
     }
-    const config = loadConfig(cwd);
-    const block = buildAgentSkillsBlock(config, agentType, cwd);
+    // Anchor to project root before loading config (#1415/#1366 cwd-drift fix).
+    const projectRoot = (0, project_root_cjs_1.findProjectRoot)(cwd);
+    const { config, source, degraded } = loadConfigResolved(projectRoot);
+    const diagnostics = { warnings: [] };
+    const block = buildAgentSkillsBlock(config, agentType, projectRoot, diagnostics);
+    // Compute configured + reason for diagnostic output.
+    const agentSkillsMap = (config && config['agent_skills'] && typeof config['agent_skills'] === 'object')
+        ? config['agent_skills']
+        : {};
+    const configured = Object.prototype.hasOwnProperty.call(agentSkillsMap, agentType);
+    let reason;
+    let skillPaths = configured ? agentSkillsMap[agentType] : [];
+    if (!configured) {
+        reason = 'not_configured';
+        skillPaths = [];
+    }
+    else {
+        // Normalize paths to array
+        if (typeof skillPaths === 'string')
+            skillPaths = [skillPaths];
+        if (!Array.isArray(skillPaths))
+            skillPaths = [];
+        const pathsArr = skillPaths;
+        // Fix 3: treat "" (empty string) as configured_empty — all-blank entries = no meaningful paths.
+        // An array of all empty/blank strings has length > 0 but zero meaningful paths.
+        const nonBlankPaths = pathsArr.filter(p => typeof p === 'string' && p.trim().length > 0);
+        if (pathsArr.length === 0 || nonBlankPaths.length === 0) {
+            // configured with empty array / "" / all-blank entries
+            reason = 'configured_empty';
+            // Reflect zero meaningful paths in the normalized array used for skills_count
+            skillPaths = [];
+            try {
+                process.stderr.write(`[agent-skills] WARNING: Agent "${agentType}" is configured in agent_skills but has no skill paths — skills_count will be 0\n`);
+            }
+            catch { /* stderr might be closed */ }
+        }
+        else if (!block) {
+            // configured with paths but all failed to resolve (warnings already emitted by buildAgentSkillsBlock)
+            reason = 'configured_unresolved';
+        }
+        else {
+            reason = 'resolved';
+        }
+    }
+    const normalizedPaths = Array.isArray(skillPaths) ? skillPaths : [];
     if (jsonMode) {
-        const skillPaths = (config && config.agent_skills && config.agent_skills[agentType]) || [];
-        const normalizedPaths = Array.isArray(skillPaths)
-            ? skillPaths
-            : skillPaths
-                ? [skillPaths]
-                : [];
-        output({ agent_type: agentType, block: block || '', skills_count: normalizedPaths.length }, raw);
+        // Build the Resolution<AgentSkillsValue> envelope and embed .value additively.
+        // Flat fields are retained unchanged for back-compat; value formalises the
+        // Resolution convention (ADR-1411 P3, #1416). source/degraded remain
+        // config-provenance extras, outside the Resolution<T> envelope.
+        const resolution = (0, resolution_cjs_1.makeResolution)({ block: block || '', skills_count: normalizedPaths.length }, { configured, reason, warnings: diagnostics.warnings });
+        output({
+            agent_type: agentType,
+            block: block || '',
+            skills_count: normalizedPaths.length,
+            warnings: diagnostics.warnings,
+            configured,
+            reason,
+            source,
+            degraded,
+            value: resolution.value,
+        }, raw);
         return;
     }
     if (block) {

package/gsd-core/bin/lib/legacy-cleanup.cjs

@@ -37,6 +37,33 @@ const OLD_PACKAGE_SIGNAL = 'gsd-core' + '-cc';
  */
 const GSD_MANAGED_SUBTREES = ['hooks', 'commands'];
 
+/**
+ * Substring that identifies a skill file as referencing the pre-rename GSD
+ * runtime config subdirectory. Assembled from parts to avoid self-flagging.
+ *
+ * Old installs wrote skill bodies that embed the path to the GSD runtime
+ * directory — e.g. `@$HOME/.codex/get-shit-done/workflows/plan.md`. After // gsd-allow-legacy-name
+ * the rename to `gsd-core/` (#604), those embedded paths are stale and the
+ * skill file must be removed so the runtime does not pick up the wrong copy.
+ *
+ * Issue: #1453
+ */
+const LEGACY_SKILL_PATH_SIGNAL = 'get-shit-done'; // gsd-allow-legacy-name
+
+/**
+ * Prefix that identifies a skill directory as GSD-managed.
+ * Only `gsd-*` subdirectories under the `skills/` subtree are scanned; user
+ * skill directories with other prefixes are never touched.
+ */
+const GSD_SKILL_DIR_PREFIX = 'gsd-';
+
+/**
+ * File extensions eligible for the stale-skill-path scan.
+ * SKILL.md is the only file in a codex/cursor/kilo/etc skill directory that
+ * embeds an @-import path to the GSD runtime config tree.
+ */
+const SKILL_MD_EXTENSIONS = new Set(['.md']);
+
 /**
  * Extensions eligible for the content-reference scan.
  *
@@ -113,6 +140,24 @@ function fileContainsOldPackageSignal(absPath, fsMod) {
   }
 }
 
+/**
+ * Return true if the file at `absPath` contains the legacy skill path signal
+ * (`get-shit-done` as a path component inside an @-import or similar reference). // gsd-allow-legacy-name
+ * Skips unreadable files (returns false on any error).
+ *
+ * @param {string} absPath
+ * @param {object} fsMod
+ * @returns {boolean}
+ */
+function fileContainsLegacySkillPathSignal(absPath, fsMod) {
+  try {
+    const content = fsMod.readFileSync(absPath, 'utf8');
+    return content.includes('/' + LEGACY_SKILL_PATH_SIGNAL + '/'); // gsd-allow-legacy-name
+  } catch {
+    return false;
+  }
+}
+
 // ─── Public API ──────────────────────────────────────────────────────────────
 
 /**
@@ -122,6 +167,9 @@ function fileContainsOldPackageSignal(absPath, fsMod) {
  * Possible reasons in returned entries:
  *   - 'content-references-old-package': a code file whose content contains
  *     the old package name signal (hooks/ and commands/ subtrees only).
+ *   - 'stale-get-shit-done-path': a skill markdown file whose content contains
+ *     a path reference to the pre-rename `get-shit-done/` runtime directory // gsd-allow-legacy-name
+ *     (skills/ subtree, gsd-* directories only). Issue #1453.
  *   - 'legacy-shared-cache': the old package's shared update-check cache file.
  *
  * @param {string[]} configDirs - absolute paths to runtime config dirs to scan
@@ -164,6 +212,54 @@ function planLegacyCleanup(configDirs, opts = {}) {
         }
       }
     }
+
+    // #1453: Scan skills/gsd-* directories for stale get-shit-done path references. // gsd-allow-legacy-name
+    //
+    // Background: older GSD installs wrote SKILL.md files that embedded a path to
+    // the GSD runtime config directory, e.g.:
+    //   @$HOME/.codex/get-shit-done/workflows/docs-update.md // gsd-allow-legacy-name
+    //
+    // After the rename to gsd-core/ (#604), the correct path is:
+    //   @$HOME/.codex/gsd-core/workflows/docs-update.md
+    //
+    // When Codex upgrades to gsd-core 1.5.0 it writes fresh skill files to
+    // ~/.codex/skills/ but does NOT remove stale copies that an older install
+    // may have placed under OTHER discoverable skill roots (e.g. ~/.agents/skills/,
+    // ~/.config/agents/skills/). Codex can pick up either copy and the stale one
+    // breaks the session (#1453).
+    //
+    // This scan removes GSD-managed skill files (under gsd-* subdirs) that still
+    // reference the old path. Only .md files are scanned (SKILL.md is the sole
+    // embedded-path carrier in a skill dir). The skills/ dir itself is not deleted;
+    // user-owned non-gsd-* skill dirs are never touched.
+    const skillsDir = path.join(configDir, 'skills');
+    let skillDirEntries;
+    try {
+      skillDirEntries = fsMod.readdirSync(skillsDir, { withFileTypes: true });
+    } catch {
+      skillDirEntries = null;
+    }
+    if (skillDirEntries) {
+      for (const entry of skillDirEntries) {
+        // Only process gsd-* subdirectories (GSD-managed skill dirs).
+        if (!entry.isDirectory()) continue;
+        if (!entry.name.startsWith(GSD_SKILL_DIR_PREFIX)) continue;
+
+        const skillDir = path.join(skillsDir, entry.name);
+        const files = collectFilesUnder(skillDir, fsMod);
+
+        for (const absPath of files) {
+          // Never flag user-authored dev-preferences artifacts
+          if (isDevPreferencesPath(absPath)) continue;
+
+          // Only scan .md files for the stale path signal.
+          const ext = path.extname(absPath).toLowerCase();
+          if (SKILL_MD_EXTENSIONS.has(ext) && fileContainsLegacySkillPathSignal(absPath, fsMod)) {
+            addCandidate(absPath, 'stale-get-shit-done-path'); // gsd-allow-legacy-name
+          }
+        }
+      }
+    }
   }
 
   // Legacy shared cache (fixed name from the old package)

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

@@ -430,9 +430,13 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
         config = {};
     }
     const state = resolveCapabilityRuntimeState(cwd, runtimeConfigDir, config);
-    // Registry is the static generated module — same object capability-state uses internally.
+    // Load overlay-aware registry (ADR-1244 D2 wiring) so installed third-party
+    // capabilities are visible to loop rendering exactly like first-party ones.
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const registry = require('./capability-registry.cjs');
+    const { loadRegistry } = require('./capability-loader.cjs');
+    // #1459 IC-04: thread the consent home (process.env.GSD_HOME) EXPLICITLY so a consented project cap's
+    // loop surfaces (steps/gates/contributions) render here at the SAME home that gated its activation.
+    const registry = loadRegistry({ includeInstalled: true, cwd, gsdHome: process.env['GSD_HOME'] });
     const capabilityStatesById = new Map();
     for (const cap of state.capabilities || []) {
         capabilityStatesById.set(cap.id, cap);
@@ -446,6 +450,26 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
         coreError(msg);
         return;
     }
+    // ── ADR-1244 D2 fail-closed gate injection ────────────────────────────────────
+    // For every skipped overlay capability that declared a gate at this point,
+    // inject a synthetic BLOCKING gate into the resolved output so the loop HALTS
+    // rather than silently proceeding as if the gate had passed. step/contribution
+    // overlays that were skipped are left open (skip-open is correct for them).
+    const overlayMeta = registry['_overlay'];
+    if (overlayMeta && Array.isArray(overlayMeta.blockedGates)) {
+        for (const blocked of overlayMeta.blockedGates) {
+            if (blocked.point === point) {
+                const syntheticGate = {
+                    capId: blocked.capId,
+                    kind: 'gate',
+                    blocking: true,
+                    onError: 'halt',
+                    check: `capability "${blocked.capId}" was skipped at load (${blocked.reason}); its gate at ${point} cannot be evaluated — failing closed`,
+                };
+                resolved.activeHooks.push(syntheticGate);
+            }
+        }
+    }
     // --active-cap mode: print exactly 'true' or 'false' with no envelope
     if (activeCapId !== undefined) {
         const isActive = resolved.activeHooks.some((h) => h.capId === activeCapId);