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

package/gsd-core/bin/lib/agent-install-check.cjs

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Agent Install Check — moved from core.cts (ADR-857 T0 #1268 phase rehome-core-squatters).
+ *
+ * Owns:
+ *   - getAgentsDir(runtime?): string
+ *   - checkAgentsInstalled(runtime?): AgentsInstalledResult
+ *
+ * The core.cjs re-export spine was retired in epic #1267; callers import
+ * these symbols from agent-install-check.cjs directly.
+ */
+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 modelProfiles = require("./model-profiles.cjs");
+const { MODEL_PROFILES } = modelProfiles;
+const runtime_homes_cjs_1 = require("./runtime-homes.cjs");
+/**
+ * Resolve the agents directory for the given runtime.
+ *
+ * Priority:
+ *   1. GSD_AGENTS_DIR env var (explicit override, any runtime)
+ *   2. For claude runtime: __dirname-relative path (agents/ sibling of gsd-core/)
+ *      This is correct for both repo runs and real installs (the runtime config dir's
+ *      agents/ folder) because gsd-tools.cjs lives inside gsd-core/bin/ in both cases.
+ *   3. For non-claude runtimes: getGlobalConfigDir(runtime)/agents
+ *
+ * @param runtime - the active runtime name; defaults to GSD_RUNTIME env, then 'claude'
+ */
+function getAgentsDir(runtime) {
+    if (process.env['GSD_AGENTS_DIR']) {
+        return process.env['GSD_AGENTS_DIR'];
+    }
+    const resolved = runtime ?? (process.env['GSD_RUNTIME'] || 'claude');
+    if (resolved === 'claude') {
+        return node_path_1.default.join(__dirname, '..', '..', '..', 'agents');
+    }
+    return node_path_1.default.join((0, runtime_homes_cjs_1.getGlobalConfigDir)(resolved), 'agents');
+}
+/**
+ * Check which GSD agents are installed on disk.
+ *
+ * @param runtime - the active runtime name; defaults to GSD_RUNTIME env, then 'claude'
+ */
+function checkAgentsInstalled(runtime) {
+    const resolvedRuntime = runtime ?? (process.env['GSD_RUNTIME'] || 'claude');
+    const agentsDir = getAgentsDir(resolvedRuntime);
+    const expectedAgents = Object.keys(MODEL_PROFILES);
+    const installed = [];
+    const missing = [];
+    if (!node_fs_1.default.existsSync(agentsDir)) {
+        return {
+            agents_installed: false,
+            missing_agents: expectedAgents,
+            installed_agents: [],
+            incomplete_agents: [],
+            agents_dir: agentsDir,
+            agent_runtime: resolvedRuntime,
+        };
+    }
+    for (const agent of expectedAgents) {
+        const agentFile = node_path_1.default.join(agentsDir, `${agent}.md`);
+        const agentFileCopilot = node_path_1.default.join(agentsDir, `${agent}.agent.md`);
+        const agentFileCodex = node_path_1.default.join(agentsDir, `${agent}.toml`);
+        const agentFileKimiYaml = node_path_1.default.join(agentsDir, 'subagents', `${agent}.yaml`);
+        const agentFileKimiPrompt = node_path_1.default.join(agentsDir, 'subagents', `${agent}.md`);
+        const kimiAgentInstalled = resolvedRuntime === 'kimi' &&
+            node_fs_1.default.existsSync(agentFileKimiYaml) &&
+            node_fs_1.default.existsSync(agentFileKimiPrompt);
+        if (node_fs_1.default.existsSync(agentFile) ||
+            node_fs_1.default.existsSync(agentFileCopilot) ||
+            node_fs_1.default.existsSync(agentFileCodex) ||
+            kimiAgentInstalled) {
+            installed.push(agent);
+        }
+        else {
+            missing.push(agent);
+        }
+    }
+    // ── Manifest-backed completeness check ──────────────────────────────────────
+    // If a gsd-file-manifest.json exists alongside the agents dir (parent dir),
+    // verify that every manifest-tracked file for each expected agent is present
+    // on disk. Missing manifest-tracked files indicate an incomplete install even
+    // when the plain presence check above passed (e.g. .md present, .toml absent).
+    // If no manifest is found the check is a no-op (graceful for claude/bundled).
+    const incomplete = [];
+    const manifestPath = node_path_1.default.join(node_path_1.default.dirname(agentsDir), 'gsd-file-manifest.json');
+    let manifestFiles = {};
+    try {
+        const raw = node_fs_1.default.readFileSync(manifestPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed !== null &&
+            typeof parsed === 'object' &&
+            'files' in parsed &&
+            typeof parsed['files'] === 'object' &&
+            parsed['files'] !== null) {
+            manifestFiles = parsed['files'];
+        }
+    }
+    catch {
+        // No manifest or unreadable — completeness check is skipped
+    }
+    if (Object.keys(manifestFiles).length > 0) {
+        for (const agent of expectedAgents) {
+            // Find all manifest keys that belong to this agent:
+            // key must be "agents/<agentName>.<ext>" with no further path segments.
+            const agentPrefix = `agents/${agent}.`;
+            const agentManifestKeys = Object.keys(manifestFiles).filter(key => {
+                if (!key.startsWith(agentPrefix))
+                    return false;
+                const rest = key.slice(agentPrefix.length);
+                // rest must be a bare extension (no slashes, non-empty)
+                return rest.length > 0 && !rest.includes('/');
+            });
+            if (agentManifestKeys.length === 0) {
+                // Agent not tracked in manifest — skip completeness check for this agent
+                continue;
+            }
+            const allPresent = agentManifestKeys.every(key => {
+                const basename = key.slice('agents/'.length);
+                return node_fs_1.default.existsSync(node_path_1.default.join(agentsDir, basename));
+            });
+            if (!allPresent) {
+                incomplete.push(agent);
+            }
+        }
+    }
+    return {
+        agents_installed: installed.length > 0 && missing.length === 0 && incomplete.length === 0,
+        missing_agents: missing,
+        installed_agents: installed,
+        incomplete_agents: incomplete,
+        agents_dir: agentsDir,
+        agent_runtime: resolvedRuntime,
+    };
+}
+module.exports = {
+    getAgentsDir,
+    checkAgentsInstalled,
+};

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

@@ -24,7 +24,7 @@
  * inline case arms which each required only their own module).
  */
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const core = require("./core.cjs");
+const io = require("./io.cjs");
 // ─── routeAuditUat ────────────────────────────────────────────────────────────
 function routeAuditUat({ args, cwd, raw, error, _uat }) {
     // Suppress unused-variable warnings for args/error — this command has no
@@ -42,16 +42,16 @@ function routeAuditOpen({ args, cwd, raw, error, _audit, _core }) {
     void error;
     // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
     const a = _audit ?? require('./audit.cjs');
-    const c = _core ?? core;
+    const c = _core ?? io;
     const wantJson = args.includes('--json');
     const result = a.auditOpenArtifacts(cwd);
     if (wantJson) {
-        // core.output JSON-stringifies its first arg; pass the object directly.
+        // io.output JSON-stringifies its first arg; pass the object directly.
         c.output(result, raw);
     }
     else {
         // Human-readable report must bypass JSON encoding — use the rawValue
-        // form (third arg) which core.output emits verbatim.
+        // form (third arg) which io.output emits verbatim.
         c.output(null, true, a.formatAuditReport(result));
     }
 }

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

@@ -55,32 +55,59 @@ function _readRawConfigKey(filePath, dotKey) {
         return { found: false, value: undefined };
     }
 }
-function _resolveActivationValue(dotKey, config, cwd, registry) {
+/**
+ * Resolve the raw value for a dotted config key using the four-level precedence
+ * walk. Returns { found, value } with the RAW value (not coerced to boolean),
+ * so callers can decide how to interpret the value (boolean gate vs. raw config
+ * value for numeric/string settings like security_asvs_level).
+ *
+ * Precedence (mirrors _resolveActivationValue):
+ *   1. loadConfig result (config arg) — guarded nested-lookup.
+ *   2. Workstream config.json at planningDir(cwd)/config.json.
+ *   3. Root config.json at planningRoot(cwd)/config.json (only if path differs).
+ *   4. registry.configSchema[dotKey].default — schema default.
+ *   5. Absent → { found: false, value: undefined }.
+ */
+function resolveConfigKey(dotKey, opts) {
+    const { config, cwd, registry } = opts;
+    // Level 1: loadConfig result
     const fromConfig = _getNestedConfigValue(config, dotKey);
     if (fromConfig.found)
-        return Boolean(fromConfig.value);
+        return { found: true, value: fromConfig.value };
+    // Level 2 + 3: raw config.json files (only when cwd is available)
     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)
-            return Boolean(fromWs.value);
+            return { found: true, value: fromWs.value };
         if (wsConfigPath !== rootConfigPath) {
             const fromRoot = _readRawConfigKey(rootConfigPath, dotKey);
             if (fromRoot.found)
-                return Boolean(fromRoot.value);
+                return { found: true, value: fromRoot.value };
         }
     }
-    const schemaEntry = registry['configSchema']?.[dotKey];
-    if (schemaEntry && typeof schemaEntry === 'object' && schemaEntry !== null) {
-        const def = schemaEntry['default'];
-        if (def !== undefined)
-            return Boolean(def);
+    // Level 4: registry configSchema default
+    const schemaMap = registry['configSchema'];
+    if (schemaMap && typeof schemaMap === 'object' && !Array.isArray(schemaMap)
+        && Object.prototype.hasOwnProperty.call(schemaMap, dotKey)) {
+        const schemaEntry = schemaMap[dotKey];
+        if (schemaEntry && typeof schemaEntry === 'object' && schemaEntry !== null) {
+            const def = schemaEntry['default'];
+            if (def !== undefined)
+                return { found: true, value: def };
+        }
     }
-    return false;
+    // Level 5: absent
+    return { found: false, value: undefined };
+}
+function _resolveActivationValue(dotKey, config, cwd, registry) {
+    const r = resolveConfigKey(dotKey, { config, cwd, registry });
+    return r.found ? Boolean(r.value) : false;
 }
 module.exports = {
     _getNestedConfigValue,
     _readRawConfigKey,
     _resolveActivationValue,
+    resolveConfigKey,
 };

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

@@ -762,6 +762,7 @@ const capabilities = {
       "graphify"
     ],
     "agents": [],
+    "activationKey": "graphify.enabled",
     "config": {
       "graphify.enabled": {
         "type": "boolean",
@@ -845,6 +846,7 @@ const capabilities = {
     },
     "skills": [],
     "agents": [],
+    "activationKey": "intel.enabled",
     "config": {
       "intel.enabled": {
         "type": "boolean",

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

@@ -18,14 +18,15 @@
  * pure, config-only resolution with no filesystem I/O.
  * cmdCapabilityState is the I/O handler.
  *
- * Dependencies (leaf modules only — no core.cjs circular risk):
+ * Dependencies (leaf modules only — no circular risk):
  *   - node:path
- *   - ./core.cjs               (output, error)
+ *   - ./io.cjs                 (output, error)
  *   - ./capability-activation.cjs (_resolveActivationValue)
  *   - ./install-profiles.cjs   (readActiveProfile, loadSkillsManifest, resolveProfile)
  *   - ./surface.cjs            (resolveSurface)
  *   - ./config-loader.cjs      (loadConfig)
  *   - ./runtime-homes.cjs      (getGlobalConfigDir — for runtimeConfigDir auto-detection)
+ *   - ./runtime-slash.cjs      (resolveRuntime — GSD_RUNTIME > config.runtime > 'claude' precedence)
  *   - capability-registry.cjs  (loaded at call time)
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -34,8 +35,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 // 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 activationMod = require("./capability-activation.cjs");
 const { _resolveActivationValue } = activationMod;
@@ -135,6 +136,19 @@ function resolveCapabilityState(input) {
             surfaced = skills.every((s) => surfacedSkills.has(s));
         }
         const enabled = installed && surfaced;
+        // ── per-capability config activation ──────────────────────────────────────
+        // Resolve the capability's own activationKey (if present). This is the
+        // config-level toggle that gates the whole capability — separate from the
+        // per-hook `when` keys that gate individual hooks. When activationKey is
+        // absent, configActivation defaults to true (no config gate on the cap).
+        // active = enabled && configActivation  (enabled unchanged: installed && surfaced)
+        const activationKey = typeof capObj['activationKey'] === 'string' && capObj['activationKey'].length > 0
+            ? capObj['activationKey']
+            : undefined;
+        const configActivation = activationKey !== undefined
+            ? _resolveActivationValue(activationKey, config, cwd, registry)
+            : true;
+        const active = enabled && configActivation;
         // ── hooks ──────────────────────────────────────────────────────────────────
         // Collect from steps, gates, contributions. Each may have a `when` key.
         // Activation semantics (mirrors loop-resolver.isActive exactly):
@@ -165,7 +179,12 @@ function resolveCapabilityState(input) {
                     // (mirrors loop-resolver.isActive: `typeof when !== 'string' || when.length === 0` → false)
                     configured = false;
                 }
-                hooks.push({ point, kind, when: whenRaw, configured, active: enabled && configured });
+                // Hook active = capability-level active AND hook's own config gate.
+                // The capability's `active` constant (= enabled && configActivation) is
+                // used here so that a config-disabled capability (active=false) cannot
+                // produce active hooks even when the hook's own `when` is unconditional
+                // (configured=true). The capability gate cascades to all its hooks.
+                hooks.push({ point, kind, when: whenRaw, configured, active: active && configured });
             }
         }
         const stepsRaw = capObj['steps'];
@@ -174,7 +193,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, enabled, hooks });
+        results.push({ id: capId, tier, skills, installed, surfaced, enabled, active, 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);
@@ -283,16 +302,20 @@ function _resolveManifest(commandsGsdDir, configDir) {
 }
 /**
  * Command entry point: resolve install profile, surface, and config; compute
- * capability state; emit the envelope via core.output.
+ * capability state; emit the envelope via io.output.
  *
  * Envelope: { runtimeConfigDir, warnings?: string[], capabilities: CapabilityStateEntry[] }
  *
  * runtimeConfigDir resolution (when not provided or empty):
- *   Uses the canonical getGlobalConfigDir from runtime-homes.cjs to detect the
- *   active runtime's config dir — the same resolver used by install.js. This
- *   correctly handles all supported runtimes (claude, codex, cursor, gemini,
- *   opencode, grok, etc.) and their env-var overrides. Defaults to claude
- *   (falls back to ~/.claude) if the resolver throws.
+ *   Detects the active runtime via the canonical precedence:
+ *     process.env.GSD_RUNTIME → config.runtime → 'claude'
+ *   (using resolveRuntime() from runtime-slash.cjs, the same precedence used
+ *   by profile-output.cjs and the rest of the runtime resolution chain).
+ *   Then calls getGlobalConfigDir(detectedRuntime) from runtime-homes.cjs —
+ *   the same resolver used by install.js. This correctly handles all supported
+ *   runtimes (claude, codex, cursor, gemini, opencode, grok, etc.) and their
+ *   env-var overrides (CLAUDE_CONFIG_DIR, CODEX_HOME, CURSOR_CONFIG_DIR, …).
+ *   Defaults to ~/.claude if either resolver throws.
  *
  * Failure surfacing: genuine resolution failures (manifest/profile/surface
  * errors) are reported in the `warnings` array in the envelope. The output
@@ -308,15 +331,18 @@ function _resolveManifest(commandsGsdDir, configDir) {
  *                         Providing a value without a next token (e.g. the flag
  *                         is last in argv with no following value) should be
  *                         caught by the caller before invoking this function.
- * @param raw              Whether to emit raw JSON (core.output raw mode)
+ * @param raw              Whether to emit raw JSON (io.output raw mode)
  * @param _options         Reserved for future use
  */
-function resolveCapabilityRuntimeState(cwd, runtimeConfigDir) {
+function resolveCapabilityRuntimeState(cwd, runtimeConfigDir, configOverride) {
     const warnings = [];
     // Resolve runtimeConfigDir using the canonical runtime-homes resolver.
-    // When not provided, getGlobalConfigDir(runtime) is called with 'claude'
-    // as the default runtime — the same fallback as install.js. The canonical
-    // resolver handles all env-var overrides (CLAUDE_CONFIG_DIR, CODEX_HOME,
+    // When not provided, the active runtime is detected via the canonical
+    // precedence:  process.env.GSD_RUNTIME → config.runtime → 'claude'
+    // (mirrors resolveRuntime() from runtime-slash.cjs and the precedence used
+    // by profile-output.cjs and the rest of the runtime resolution chain).
+    // getGlobalConfigDir(detectedRuntime) is then called, which honours the
+    // runtime-specific env-var override (CLAUDE_CONFIG_DIR, CODEX_HOME,
     // CURSOR_CONFIG_DIR, GROK_AGENTS_HOME, etc.) correctly and without
     // fabricating env vars that don't exist upstream.
     let resolvedConfigDir = runtimeConfigDir || '';
@@ -324,13 +350,13 @@ function resolveCapabilityRuntimeState(cwd, runtimeConfigDir) {
         try {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             const runtimeHomes = require('./runtime-homes.cjs');
-            // Delegate runtime detection entirely to getGlobalConfigDir: calling it
-            // with 'claude' causes it to check CLAUDE_CONFIG_DIR first, falling back
-            // to ~/.claude. The canonical resolver already encodes the correct env-var
-            // precedence for each runtime — we do not re-implement that logic here.
-            // For non-claude runtimes, the caller should pass --config-dir explicitly
-            // (or set the runtime-specific env var, which getGlobalConfigDir honors).
-            resolvedConfigDir = runtimeHomes.getGlobalConfigDir('claude');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const runtimeSlash = require('./runtime-slash.cjs');
+            // Detect the active runtime via GSD_RUNTIME → config.runtime → 'claude'.
+            // resolveRuntime reads config.json directly (no side effects) and returns
+            // a lowercased canonical runtime name.
+            const detectedRuntime = runtimeSlash.resolveRuntime(cwd);
+            resolvedConfigDir = runtimeHomes.getGlobalConfigDir(detectedRuntime);
         }
         catch {
             // Defensive fallback: use ~/.claude if the canonical resolver throws.
@@ -392,12 +418,20 @@ function resolveCapabilityRuntimeState(cwd, runtimeConfigDir) {
         surfacedSkills = new Set();
     }
     // ── Load config ───────────────────────────────────────────────────────────────
+    // When the caller already holds a loadConfig snapshot (e.g. cmdLoopRenderHooks),
+    // accept it via configOverride so capability `active` and hook resolution
+    // share the SAME config object — single snapshot, no TOCTOU window.
     let config;
-    try {
-        config = loadConfig(cwd);
+    if (configOverride !== undefined) {
+        config = configOverride;
     }
-    catch {
-        config = {};
+    else {
+        try {
+            config = loadConfig(cwd);
+        }
+        catch {
+            config = {};
+        }
     }
     // ── Resolve state ────────────────────────────────────────────────────────────
     const result = resolveCapabilityState({
@@ -410,8 +444,6 @@ function resolveCapabilityRuntimeState(cwd, runtimeConfigDir) {
     return {
         runtimeConfigDir: resolvedConfigDir,
         warnings,
-        registry,
-        config,
         capabilities: result.capabilities,
     };
 }
@@ -431,9 +463,27 @@ function cmdCapabilityState(cwd, runtimeConfigDir, raw, _options = {}) {
     }
     coreOutput(envelope, raw);
 }
+/**
+ * Convenience predicate: returns true if the capability identified by `capId`
+ * is active (installed && surfaced && config-enabled) in the current runtime
+ * environment at `cwd`.
+ *
+ * Internally calls `resolveCapabilityRuntimeState(cwd, undefined)` and returns
+ * the `active` field of the matching CapabilityStateEntry.
+ * Returns `false` when the capability is not found in the registry.
+ *
+ * @param capId  Capability identifier (e.g. 'graphify', 'intel')
+ * @param cwd    Project root directory for config resolution
+ */
+function isCapabilityActive(capId, cwd) {
+    const result = resolveCapabilityRuntimeState(cwd, undefined);
+    const entry = result.capabilities.find((c) => c.id === capId);
+    return entry !== undefined ? entry.active : false;
+}
 module.exports = {
     resolveCapabilityState,
     resolveCapabilityRuntimeState,
+    isCapabilityActive,
     cmdCapabilityState,
     // Exported for tests
     _resolveCommandsGsdDir,

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

@@ -14,7 +14,7 @@
  *   - re-resolve: always calls resolveCapabilityRuntimeState for the return value
  *
  * Dependencies (leaf modules only — no circular risk):
- *   - ./core.cjs               (output, error)
+ *   - ./io.cjs                 (output, error)
  *   - ./capability-state.cjs   (resolveCapabilityRuntimeState, _resolveManifest, _resolveCommandsGsdDir)
  *   - ./surface.cjs            (readSurface, writeSurface, applySurface)
  *   - ./install-profiles.cjs   (readActiveProfile)
@@ -23,8 +23,8 @@
  *   - capability-registry.cjs  (loaded at call time)
  */
 // 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 capabilityStateMod = require("./capability-state.cjs");
 const { resolveCapabilityRuntimeState, _resolveManifest, _resolveCommandsGsdDir } = capabilityStateMod;
@@ -71,7 +71,8 @@ function setCapabilityState(cwd, runtimeConfigDir, desired, opts) {
     const before = resolveCapabilityRuntimeState(cwd, runtimeConfigDir);
     const resolvedConfigDir = before.runtimeConfigDir;
     // ── Load registry ─────────────────────────────────────────────────────────
-    const registry = before.registry;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const registry = require('./capability-registry.cjs');
     const capabilitiesMap = (registry['capabilities'] && typeof registry['capabilities'] === 'object' && !Array.isArray(registry['capabilities'])
         ? registry['capabilities']
         : {});