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

package/gsd-core/bin/lib/runtime-name-policy.cjs

@@ -28,11 +28,12 @@ const FALLBACK_ALIASES = {
     copilot: ['copilot', 'copilot-cli', 'github-copilot'],
     antigravity: ['antigravity', 'antigravity-cli', 'antigravity-agent'],
     cursor: ['cursor', 'cursor-cli', 'cursor-nightly'],
-    windsurf: ['windsurf', 'windsurf-cli', 'windsurf-next'],
+    windsurf: ['windsurf', 'windsurf-cli', 'windsurf-next', 'devin-desktop'],
     augment: ['augment', 'augment-code', 'augment-cli'],
     trae: ['trae', 'trae-cli'],
     qwen: ['qwen', 'qwen-code', 'qwen-cli'],
     hermes: ['hermes', 'hermes-agent', 'hermes-cli'],
+    kimi: ['kimi'],
     codebuddy: ['codebuddy', 'codebuddy-cli'],
     cline: ['cline', 'cline-cli'],
 };

package/gsd-core/bin/lib/runtime-slash.cjs

@@ -61,8 +61,13 @@ function formatGsdSlash(commandName, runtime) {
     const tail = wsMatch && wsMatch[2] ? wsMatch[2] : '';
     const runtimeText = (typeof runtime === 'string' && runtime ? runtime : 'claude').toLowerCase();
     const rt = (0, runtime_name_policy_cjs_1.canonicalizeRuntimeName)(runtimeText) || runtimeText;
-    if (rt === 'codex') {
-        // Codex skills are invoked as $gsd-<cmd> (shell-var syntax). The command
+    // Descriptor-driven: look up commandStyle from the capability registry.
+    // Mirrors the lazy-require pattern from runtime-homes.cts §getGlobalConfigDir.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { runtimes } = require('./capability-registry.cjs');
+    const style = runtimes[rt]?.runtime?.commandStyle;
+    if (style === 'shell-var') {
+        // shell-var runtimes (currently: codex) use $gsd-<cmd> syntax. The command
         // token is lowercased because shell-var identifiers are conventionally
         // lowercase; matches the convertCodexSlash() projection in bin/install.js.
         return `$gsd-${token.toLowerCase()}${tail}`;

package/gsd-core/bin/lib/shell-command-projection.cjs

@@ -232,6 +232,19 @@ function isManagedHookCommand(commandText, opts = {}) {
     const managedBasenames = managedHookCommandSurfaceSet(surface, includeLegacyAliases);
     if (!managedBasenames || managedBasenames.size === 0)
         return false;
+    // args-form check: the managed hook filename may appear in args[] rather than
+    // in command when a windowless launcher wraps the Node invocation. (#976)
+    // Only treat as managed when an arg basename matches the managed hook set —
+    // prevents false-positives for non-GSD entries that happen to share a path segment.
+    if (Array.isArray(opts.args) && opts.args.length > 0) {
+        for (const arg of opts.args) {
+            if (typeof arg !== 'string')
+                continue;
+            const argBasename = arg.replace(/\\/g, '/').split('/').pop() || '';
+            if (isManagedHookBasename(argBasename, { surface }))
+                return true;
+        }
+    }
     const normalizedCommand = commandText.replace(/\\/g, '/');
     if (typeof opts.configDir === 'string' && opts.configDir.length > 0) {
         const normalizedHooksDir = `${node_path_1.default.join(opts.configDir, 'hooks').replace(/\\/g, '/')}/`;

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

@@ -176,6 +176,14 @@ exports.KNOWN_STATUS_PATTERNS = [
     /^Phase\s+\d+\s+complete/i,
     /^Verifying Phase\s+\d+/i,
     /^Phase complete/i,
+    // #1070: LLM executors (e.g. OpenCode) may write "Complete ✓" or bare "Complete"
+    // when finishing a phase.  Only bare terminal markers yield to the next phase's
+    // "Ready to execute" during planned-phase.  The pattern is anchored at both ends
+    // so that statuses with trailing prose (e.g. "Complete but needs manual QA",
+    // "Complete — ready for verification") are NOT matched and are preserved as
+    // executor-authored values.  Only exact forms like "Complete", "Complete ✓",
+    // "Complete✓", or "Complete ☑ " (trailing whitespace) match.
+    /^Complete\s*[✓✔✅☑]?\s*$/i,
 ];
 /**
  * Returns true when the given value is a known template default for the field,

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

@@ -607,6 +607,7 @@ function cmdStateRecordSession(cwd, options, raw) {
     }
     const now = clock_cjs_1.realClock.nowIso();
     const updated = [];
+    let sessionCreated = false;
     readModifyWriteStateMd(statePath, (content) => {
         // Update Last session / Last Date
         let result = (0, state_document_cjs_1.stateReplaceField)(content, 'Last session', now);
@@ -661,10 +662,80 @@ function cmdStateRecordSession(cwd, options, raw) {
                 }
             }
         }
+        // Bug #944: DWIM normalize/auto-create — when the caller supplied --stopped-at or
+        // --resume-file but the body lacks the canonical labels (in-place replace
+        // returned a miss), persist the values durably. Mirrors the DWIM pattern used
+        // by add-decision, add-blocker, and record-metric. Never silently drop
+        // caller-supplied values.
+        //
+        // Guard: only act when the caller actually supplied a value. When no
+        // --stopped-at / --resume-file are given and the body already had no session
+        // labels (nothing was updated), we return recorded:false — the existing
+        // behaviour for a no-op call that didn't supply any values.
+        //
+        // Correctness invariant: both buildStateFrontmatter and cmdStateSnapshot read
+        // only the FIRST `## Session` block (via a /##\s*Session\s*\n…/i regex).
+        // If we blindly append a second `## Session` block when one already exists, the
+        // newly-written Stopped at / Resume file end up in the second (invisible) block.
+        // Fix: when a `## Session` heading already exists, normalize THAT block in place
+        // (insert / replace canonical bold-label lines within the existing section).
+        // Only append a brand-new section when NO `## Session` heading exists at all.
+        const callerSuppliedValues = !!(options.stopped_at || (options.resume_file !== undefined && options.resume_file !== null));
+        const needsStoppedAt = options.stopped_at && !updated.includes('Stopped At');
+        const needsResumeFile = options.resume_file !== undefined && options.resume_file !== null && !updated.includes('Resume File');
+        const needsLastSession = !updated.includes('Last session') && !updated.includes('Last Date');
+        if (callerSuppliedValues && (needsStoppedAt || needsResumeFile || needsLastSession)) {
+            const resumeValue = (options.resume_file !== undefined && options.resume_file !== null)
+                ? options.resume_file
+                : 'None';
+            const stoppedAtValue = options.stopped_at || 'None';
+            // Determine whether a ## Session heading already exists in the body.
+            const existingSessionHeading = /^## Session\s*$/im.test(content);
+            if (existingSessionHeading) {
+                // Normalize in place: replace the ENTIRE BODY of the existing ## Session
+                // section (heading + all content up to the next ## heading or EOF) with
+                // canonical bold-label lines. The negative-lookahead per-line pattern
+                // `(?!^## )[\s\S]` consumes every line that doesn't start with "## ",
+                // which correctly stops at the next section boundary without consuming it.
+                // A trailing blank line is added so the next ## heading keeps its spacing.
+                content = content.replace(/^(## Session[ \t]*\n(?:(?!^## )[\s\S])*)/m, [
+                    '## Session',
+                    '',
+                    `**Last session:** ${now}`,
+                    `**Stopped at:** ${stoppedAtValue}`,
+                    `**Resume file:** ${resumeValue}`,
+                    '',
+                    '',
+                ].join('\n'));
+            }
+            else {
+                // No ## Session heading exists at all — append a new canonical section.
+                const scaffold = [
+                    '',
+                    '## Session',
+                    '',
+                    `**Last session:** ${now}`,
+                    `**Stopped at:** ${stoppedAtValue}`,
+                    `**Resume file:** ${resumeValue}`,
+                    '',
+                ].join('\n');
+                content = content.trimEnd() + '\n' + scaffold;
+            }
+            sessionCreated = true;
+            if (needsLastSession)
+                updated.push('Last session');
+            if (needsStoppedAt)
+                updated.push('Stopped At');
+            if (needsResumeFile)
+                updated.push('Resume File');
+        }
         return content;
     }, cwd);
     if (updated.length > 0) {
-        output({ recorded: true, updated }, raw, 'true');
+        const result = { recorded: true, updated };
+        if (sessionCreated)
+            result['created'] = true;
+        output(result, raw, 'true');
     }
     else {
         output({ recorded: false, reason: 'No session fields found in STATE.md' }, raw, 'false');
@@ -748,8 +819,12 @@ function cmdStateSnapshot(cwd, raw) {
     const sessionMatch = body.match(/##\s*Session\s*\n([\s\S]*?)(?=\n##|$)/i);
     if (sessionMatch) {
         const sessionSection = sessionMatch[1];
+        // Accept both `**Last Date:**` (canonical template form) and `**Last session:**`
+        // (the form written by the DWIM auto-create / normalize path added for #944).
         const lastDateMatch = sessionSection.match(/\*\*Last Date:\*\*\s*(.+)/i)
-            || sessionSection.match(/^Last Date:\s*(.+)/im);
+            || sessionSection.match(/^Last Date:\s*(.+)/im)
+            || sessionSection.match(/\*\*Last session:\*\*\s*(.+)/i)
+            || sessionSection.match(/^Last session:\s*(.+)/im);
         const stoppedAtMatch = sessionSection.match(/\*\*Stopped At:\*\*\s*(.+)/i)
             || sessionSection.match(/^Stopped At:\s*(.+)/im);
         const resumeFileMatch = sessionSection.match(/\*\*Resume File:\*\*\s*(.+)/i)
@@ -974,12 +1049,39 @@ function syncStateFrontmatter(content, cwd) {
     if (derivedFm['status'] === 'unknown' && existingFm['status'] && existingFm['status'] !== 'unknown') {
         derivedFm['status'] = existingFm['status'];
     }
+    // Bug #948: preserve `milestone_name` / `milestone` when the derived value
+    // is the template placeholder 'milestone'. getMilestoneInfo returns the
+    // literal string 'milestone' when it cannot match the version from the roadmap
+    // (e.g. no ROADMAP.md, roadmap lacks the heading for the stored version, or the
+    // milestone version read from STATE.md itself triggers the lookup before the
+    // file is fully written). A placeholder must never overwrite a real name that the
+    // existing frontmatter already holds; only an empty derived value falls through
+    // to this guard (the primary #905 preserve path below handles that).
+    const MILESTONE_NAME_PLACEHOLDER = 'milestone';
+    if (derivedFm['milestone_name'] === MILESTONE_NAME_PLACEHOLDER &&
+        existingFm['milestone_name'] &&
+        existingFm['milestone_name'] !== MILESTONE_NAME_PLACEHOLDER) {
+        derivedFm['milestone_name'] = existingFm['milestone_name'];
+        // Keep the stored milestone version consistent with the preserved name.
+        if (existingFm['milestone']) {
+            derivedFm['milestone'] = existingFm['milestone'];
+        }
+    }
     // Bug #905: preserve scalar fields that buildStateFrontmatter can only derive
     // from body annotations (Current Phase:, Current Plan:, etc.). When those
     // annotations are absent — e.g. after an agent or tool rewrites the body —
     // buildStateFrontmatter returns no value for those keys. Mirror the same
     // fallback pattern used in cmdStateJson so the existing frontmatter values
     // survive every writeStateMd call.
+    //
+    // For stopped_at / paused_at: the original #905 "fall back when derived is
+    // absent" rule is preserved here. The stale-body-overwrites-frontmatter
+    // scenario from #948 is prevented by the no-op guard in
+    // readModifyWriteStateMd: when the transform produces no change the file is
+    // never written, so syncStateFrontmatter never even runs. Attempting to
+    // "always prefer frontmatter" here breaks legitimate callers like phase.complete
+    // that intentionally write a new stopped_at value to the body and expect
+    // syncStateFrontmatter to pick it up.
     if (!derivedFm['stopped_at'] && existingFm['stopped_at']) {
         derivedFm['stopped_at'] = existingFm['stopped_at'];
     }
@@ -1155,6 +1257,16 @@ function readModifyWriteStateMd(statePath, transformFn, cwd, options, clock) {
         // restore it when resync is false.
         const preFm = resync ? null : extractFrontmatter(content);
         const modified = transformFn(content);
+        // Bug #948: no-op guard — if the transform produced no change, do NOT write
+        // the file. An unconditional write would bump `last_updated`, reset
+        // `milestone_name` to the template placeholder, and resurrect stale
+        // body-derived `stopped_at` values via syncStateFrontmatter. Skipping the
+        // write when content is unchanged is safe because every caller that mutates
+        // content already returns the mutated string, and callers that detect a
+        // no-op explicitly return the original content unchanged.
+        if (modified === content) {
+            return;
+        }
         let synced = syncStateFrontmatter(modified, cwd);
         if (!resync && preFm && preFm['progress']) {
             // Re-apply the curated progress block that syncStateFrontmatter just

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

@@ -12,11 +12,18 @@
  * Exports:
  *   readSurface(runtimeConfigDir)
  *   writeSurface(runtimeConfigDir, surfaceState)
- *   resolveSurface(runtimeConfigDir, manifest, clusterMap)
- *   applySurface(runtimeConfigDir, layout, manifest, clusterMap)
- *   listSurface(runtimeConfigDir, manifest, clusterMap)
+ *   resolveSurface(runtimeConfigDir, manifest, clusterMap?, registry?)
+ *   applySurface(runtimeConfigDir, layout, manifest, clusterMap?, registry?)
+ *   listSurface(runtimeConfigDir, manifest, clusterMap?, registry?)
  *   pruneSkillDirs(skillsDir, retainedNames, prefix, manifest)
  *
+ * The optional `registry` param (ADR-857 phase 4c) accepts the capability-registry
+ * object.  When present, capability clusters are merged into the effective cluster
+ * map and the registry is threaded into resolveProfile so capability-contributed
+ * skills participate in the base set and disable-ability.  Absent or undefined
+ * leaves behaviour identical to the pre-registry path (no-op for current registry
+ * where UI=full and the full profile returns '*' regardless).
+ *
  * ADR-457 build-at-publish: the hand-written bin/lib/surface.cjs collapsed
  * to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
  * from the prior hand-written .cjs; only types are added.
@@ -86,10 +93,11 @@ function clustersToSkills(clusterNames, clusterMap) {
     const result = new Set();
     for (const name of clusterNames) {
         const members = clusterMap[name];
-        if (members) {
-            for (const s of members)
-                result.add(s);
-        }
+        // FIX 5: guard against non-iterable members — malformed registry must never throw
+        if (!Array.isArray(members))
+            continue;
+        for (const s of members)
+            result.add(s);
     }
     return result;
 }
@@ -132,19 +140,63 @@ function normalizeSkillManifest(runtimeConfigDir, manifest) {
  * 2. Remove skills in disabled clusters
  * 3. Add explicitAdds (and their transitive closure)
  * 4. Remove explicitRemoves (only the stem itself, no cascade)
+ *
+ * ADR-857 phase 4c: optional registry param.  When present:
+ *   - capability clusters are merged into the effective cluster map so
+ *     capability-owned skill groups are disable-able.
+ *   - registry is threaded into resolveProfile so capability skills
+ *     participate in the base skill set and their requires: chains expand.
  */
-function resolveSurface(runtimeConfigDir, manifest, clusterMap) {
-    const cm = clusterMap || clusters_cjs_1.CLUSTERS;
+function resolveSurface(runtimeConfigDir, manifest, clusterMap, registry) {
+    // Merge capability clusters into the cluster map when registry is provided.
+    // The ADR-857 phase 4a HARD gate guarantees that when a capId matches a CLUSTERS
+    // key, the values are EQUAL — so the spread is idempotent for matching names.
+    // Defense-in-depth: if a capId collides with a hand-authored CLUSTERS key AND
+    // the values DIFFER (future drift bypassing the gate), prefer the hand-authored
+    // value so disable behavior is never silently changed by a stale registry entry.
+    // Also guard: skip entries whose value is not a string[] (malformed registry).
+    let cm = clusterMap || clusters_cjs_1.CLUSTERS;
+    if (registry && registry.capabilityClusters && typeof registry.capabilityClusters === 'object') {
+        const baseCm = cm;
+        const capClusters = registry.capabilityClusters;
+        const merged = { ...baseCm };
+        for (const capId of Object.keys(capClusters)) {
+            const val = capClusters[capId];
+            // FIX 5: skip malformed (non-array) entries — never throw on bad registry
+            if (!Array.isArray(val))
+                continue;
+            // FIX 4: if the capId matches an existing cluster key, only override when
+            // the values are identical (guaranteed by 4a gate).  If they differ, the
+            // hand-authored value wins — prefer known-correct disable behavior over
+            // a potentially stale registry entry.
+            if (Object.prototype.hasOwnProperty.call(baseCm, capId)) {
+                const existing = baseCm[capId];
+                if (!Array.isArray(existing)) {
+                    merged[capId] = val;
+                    continue;
+                }
+                // Values differ → hand-authored wins (skip the override)
+                if (existing.length !== val.length || existing.some((v, i) => v !== val[i]))
+                    continue;
+            }
+            // Prototype-pollution guard (parity with _capabilitySkillsForMode in install-profiles.cts)
+            if (capId === '__proto__' || capId === 'constructor' || capId === 'prototype')
+                continue;
+            merged[capId] = val;
+        }
+        cm = merged;
+    }
     const skillManifest = normalizeSkillManifest(runtimeConfigDir, manifest);
     const surface = readSurface(runtimeConfigDir);
     // Determine base profile name: from surface state or from .gsd-profile marker
     const baseProfileName = (surface && surface.baseProfile)
         ? surface.baseProfile
         : (readActiveProfile(runtimeConfigDir) || 'full');
-    // Resolve base profile
+    // Resolve base profile — thread registry so capability skills are included.
     const baseResolved = resolveProfile({
         modes: baseProfileName.split(',').map((s) => s.trim()),
         manifest: skillManifest,
+        registry,
     });
     // If full, we need to enumerate all skills from the manifest
     let skills;
@@ -205,12 +257,12 @@ function resolveSurface(runtimeConfigDir, manifest, clusterMap) {
  * Re-stage the active surface using the resolved layout.
  * Iterates layout.kinds and syncs each artifact kind to its destination.
  */
-function applySurface(runtimeConfigDir, layout, manifest, clusterMap) {
+function applySurface(runtimeConfigDir, layout, manifest, clusterMap, registry) {
     if (node_path_1.default.resolve(runtimeConfigDir) !== node_path_1.default.resolve(layout.configDir)) {
         throw new TypeError('applySurface runtimeConfigDir must match layout.configDir');
     }
     const skillManifest = normalizeSkillManifest(layout.configDir, manifest);
-    const resolved = resolveSurface(layout.configDir, skillManifest, clusterMap);
+    const resolved = resolveSurface(layout.configDir, skillManifest, clusterMap, registry);
     // Mirror installRuntimeArtifacts: skills kinds get per-runtime path rewrites
     // so SKILL.md bodies reference the install target (pathPrefix), not the
     // converter's default ~/.claude paths (#813). Computed lazily so command-only
@@ -409,9 +461,9 @@ function _syncGsdDir(stagedDir, destDir, kind, manifest) {
  * Token cost = sum of description lengths ÷ 4 (mirrors audit script).
  * Descriptions are read from the install source (findInstallSourceRoot).
  */
-function listSurface(runtimeConfigDir, manifest, clusterMap) {
+function listSurface(runtimeConfigDir, manifest, clusterMap, registry) {
     const skillManifest = normalizeSkillManifest(runtimeConfigDir, manifest);
-    const resolved = resolveSurface(runtimeConfigDir, skillManifest, clusterMap);
+    const resolved = resolveSurface(runtimeConfigDir, skillManifest, clusterMap, registry);
     // All known stems from manifest (exclude _calls_agents_ meta keys)
     const allStems = [];
     for (const [key] of skillManifest) {