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

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

@@ -582,6 +582,27 @@ function validateFeatureBody(cap) {
               'absolute path, or ".." segment) — it contains unsafe characters: ' + JSON.stringify(h.script),
             );
           }
+          // #1634: optional tool-scoping `matcher` (a settings.json concept — exact tool name,
+          // pipe-separated list, wildcard, or regex; e.g. "Write|Edit"). When present it must be a
+          // non-empty string without control characters; absent => match-all (omitted at projection
+          // so existing shipped capabilities are unchanged).
+          if (h.matcher !== undefined) {
+            if (typeof h.matcher !== 'string' || h.matcher.length === 0) {
+              errors.push('hooks[' + i + '].matcher must be a non-empty string when present');
+            } else {
+              // Reject ASCII control characters (0x00-0x1f and 0x7f DEL) via char codes — a literal
+              // control-char range regex trips ESLint's no-control-regex rule, and char codes are
+              // equally precise.
+              let hasControl = false;
+              for (let c = 0; c < h.matcher.length; c++) {
+                const code = h.matcher.charCodeAt(c);
+                if (code < 0x20 || code === 0x7f) { hasControl = true; break; }
+              }
+              if (hasControl) {
+                errors.push('hooks[' + i + '].matcher must not contain control characters');
+              }
+            }
+          }
         }
       }
     }
@@ -665,6 +686,7 @@ const VALID_CONVERTER_NAMES = new Set([
   'convertClaudeCommandToOpencodeSkill',
   'convertClaudeCommandToTraeSkill',
   'convertClaudeCommandToWindsurfSkill',
+  'convertClaudeCommandToWindsurfWorkflow',
   // agent converters (#1173 — descriptor-driven agent conversion wiring)
   'convertClaudeAgentToCopilotAgent',
   'convertClaudeAgentToAntigravityAgent',

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

@@ -13,6 +13,12 @@
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const commandRoutingHub = require("./command-routing-hub.cjs");
 const { createHub, ERROR_KINDS } = commandRoutingHub;
+// Phase 2 (#1646): import ERROR_REASON so the UnknownCommand translation can
+// pass `sdk_unknown_command` as the second arg to error(), preserving the
+// JSON-error envelope contract that capability routers' tests assert on.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const io = require("./io.cjs");
+const { ERROR_REASON } = io;
 // ─── Implementation ───────────────────────────────────────────────────────────
 function routeCjsCommandFamily({ args, subcommands, handlers, defaultSubcommand, unsupported = {}, unknownMessage, error, cwd, raw, }) {
     routeHubCommandFamily({
@@ -44,6 +50,18 @@ function routeHubCommandFamily({ family, args, subcommands, handlers, defaultSub
     const available = subcommands.filter((s) => !unsupported[s]);
     const registryHandlers = Object.fromEntries(Object.entries(handlers).map(([name, handler]) => [
         name,
+        // Honestified via amendment #1642 (#1644 Phase 1): the runtime check
+        // `'ok' in result` already passes any `{ok:*}` object through, so the
+        // historical `{ok:true, data}` return type was a lie whenever the
+        // handler returned an err Result. The lying cast below is preserved
+        // because the Hub's `export =` syntax doesn't expose `HubResult` for
+        // import; the Hub's `_validateErrResult` runtime-validates the actual
+        // shape, so structural compatibility is sufficient. The wrapper's
+        // 0-arg signature is assignable to the Hub's `(ctx) => HubResult`
+        // Handler type via TypeScript parameter bivariance; the Hub's per-call
+        // ctx is intentionally ignored (host-router handlers don't use it;
+        // capability-router handlers in Phase 2 will return HubResults that
+        // already carry context).
         () => {
             const result = handler();
             if (result && typeof result === 'object' && Object.prototype.hasOwnProperty.call(result, 'ok')) {
@@ -66,10 +84,30 @@ function routeHubCommandFamily({ family, args, subcommands, handlers, defaultSub
     if (result.ok)
         return;
     if (result.kind === ERROR_KINDS.UnknownCommand) {
-        error(unknownMessage(subcommand ?? '', available));
+        // Phase 2 (#1646): pass SDK_UNKNOWN_COMMAND as the second arg so the
+        // JSON-error envelope (GSD_JSON_ERRORS=1) preserves the typed reason
+        // for downstream consumers. Additive for host routers (their existing
+        // one-arg `error` callbacks ignore the second arg); required for
+        // capability routers whose tests assert on `reason === 'sdk_unknown_command'`.
+        error(unknownMessage(subcommand ?? '', available), ERROR_REASON.SDK_UNKNOWN_COMMAND);
+        return;
+    }
+    if (result.kind === ERROR_KINDS.InvalidArgs) {
+        // Amendment #1642 (#1644): when the handler provided exitReason, pass it
+        // as the second arg to error() so the JSON-error envelope
+        // (GSD_JSON_ERRORS=1) preserves the typed ERROR_REASON value for
+        // downstream consumers. When exitReason is absent, call error(msg) with
+        // exactly one arg — byte-identical with prior behavior.
+        const invalidArgs = result;
+        if (invalidArgs.exitReason) {
+            error(invalidArgs.reason, invalidArgs.exitReason);
+        }
+        else {
+            error(invalidArgs.reason);
+        }
         return;
     }
-    if (result.kind === ERROR_KINDS.InvalidArgs || result.kind === ERROR_KINDS.HandlerRefusal) {
+    if (result.kind === ERROR_KINDS.HandlerRefusal) {
         error(result.reason);
         return;
     }

package/gsd-core/bin/lib/command-routing-hub.cjs

@@ -73,8 +73,14 @@ function _safeJson(value) {
 function makeUnknownCommand(command) {
     return Object.freeze({ ok: false, kind: ERROR_KINDS.UnknownCommand, command });
 }
-function makeInvalidArgs(arg, reason) {
-    return Object.freeze({ ok: false, kind: ERROR_KINDS.InvalidArgs, arg, reason });
+function makeInvalidArgs(arg, reason, exitReason) {
+    const obj = { ok: false, kind: ERROR_KINDS.InvalidArgs, arg, reason };
+    // Conditionally add exitReason only when truthy — preserves strict-keys
+    // invariant (2-arg callers must continue to produce a 4-key frozen result).
+    if (exitReason) {
+        obj.exitReason = exitReason;
+    }
+    return Object.freeze(obj);
 }
 function makeHandlerRefusal(reason) {
     return Object.freeze({ ok: false, kind: ERROR_KINDS.HandlerRefusal, reason });
@@ -113,7 +119,8 @@ const _VARIANT_SCHEMA = {
     },
     InvalidArgs: {
         required: ['arg', 'reason'],
-        allowed: new Set(['ok', 'kind', 'arg', 'reason']),
+        // Amendment #1642: exitReason? is allowed but not required.
+        allowed: new Set(['ok', 'kind', 'arg', 'reason', 'exitReason']),
     },
     HandlerRefusal: {
         required: ['reason'],

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

@@ -74,4 +74,5 @@ module.exports = {
     isCapabilityConfigKey,
     isCentralConfigKey,
     isValidConfigKey,
+    getCapabilityConfigSchema: _capabilityConfigSchema,
 };

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

@@ -27,7 +27,7 @@ const modelProfiles = require("./model-profiles.cjs");
 const { VALID_PROFILES, getAgentToModelMapForProfile, formatAgentToModelMapAsTable } = modelProfiles;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const configSchema = require("./config-schema.cjs");
-const { VALID_CONFIG_KEYS, isValidConfigKey } = configSchema;
+const { VALID_CONFIG_KEYS, isValidConfigKey, getCapabilityConfigSchema } = configSchema;
 const secrets_cjs_1 = require("./secrets.cjs");
 const review_reviewer_selection_cjs_1 = require("./review-reviewer-selection.cjs");
 const configuration_cjs_1 = require("./configuration.cjs");
@@ -480,6 +480,22 @@ function setConfigValues(cwd, entries) {
         }
     });
 }
+/**
+ * Type-safe enum guard for config-set string-enum keys.
+ *
+ * Rejects any parsedValue that is not a plain string AND a member of `allowed`.
+ * This closes the JSON-array coercion bypass: String(["val"]) === "val" satisfies
+ * a bare .includes(String(parsedValue)) check, but typeof parsedValue !== 'string'
+ * catches the array before the includes test.
+ *
+ * The `label` parameter is used verbatim in the error message so callers can
+ * preserve existing message text byte-for-byte.
+ */
+function assertEnumValue(parsedValue, rawVal, allowed, label) {
+    if (typeof parsedValue !== 'string' || !allowed.includes(parsedValue)) {
+        error(`Invalid ${label} '${rawVal}'. Valid values: ${allowed.join(', ')}`);
+    }
+}
 /**
  * Command to set a value in the config file, allowing nested values via dot notation (e.g.,
  * "workflow.research").
@@ -524,14 +540,12 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
         catch { /* keep as string */ }
     }
     const VALID_CONTEXT_VALUES = ['dev', 'research', 'review'];
-    if (kp === 'context' && !VALID_CONTEXT_VALUES.includes(String(parsedValue))) {
-        error(`Invalid context value '${val}'. Valid values: ${VALID_CONTEXT_VALUES.join(', ')}`);
-    }
+    if (kp === 'context')
+        assertEnumValue(parsedValue, val, VALID_CONTEXT_VALUES, 'context value');
     // Codebase drift detector (#2003)
     const VALID_DRIFT_ACTIONS = ['warn', 'auto-remap'];
-    if (kp === 'workflow.drift_action' && !VALID_DRIFT_ACTIONS.includes(String(parsedValue))) {
-        error(`Invalid workflow.drift_action '${val}'. Valid values: ${VALID_DRIFT_ACTIONS.join(', ')}`);
-    }
+    if (kp === 'workflow.drift_action')
+        assertEnumValue(parsedValue, val, VALID_DRIFT_ACTIONS, 'workflow.drift_action');
     if (kp === 'workflow.drift_threshold') {
         if (typeof parsedValue !== 'number' || !Number.isInteger(parsedValue) || parsedValue < 1) {
             error(`Invalid workflow.drift_threshold '${val}'. Must be a positive integer.`);
@@ -554,28 +568,23 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
     }
     // Human verification checkpoint mode (#3309)
     const VALID_HUMAN_VERIFY_MODES = ['mid-flight', 'end-of-phase'];
-    if (kp === 'workflow.human_verify_mode' && !VALID_HUMAN_VERIFY_MODES.includes(String(parsedValue))) {
-        error(`Invalid workflow.human_verify_mode '${val}'. Valid values: ${VALID_HUMAN_VERIFY_MODES.join(', ')}`);
-    }
+    if (kp === 'workflow.human_verify_mode')
+        assertEnumValue(parsedValue, val, VALID_HUMAN_VERIFY_MODES, 'workflow.human_verify_mode');
     // Context exhaustion guard mode (#1452)
     const VALID_CONTEXT_GUARD_MODES = ['auto', 'warn', 'off'];
-    if (kp === 'workflow.context_guard_mode' && !VALID_CONTEXT_GUARD_MODES.includes(String(parsedValue))) {
-        error(`Invalid workflow.context_guard_mode '${val}'. Valid values: ${VALID_CONTEXT_GUARD_MODES.join(', ')}`);
-    }
+    if (kp === 'workflow.context_guard_mode')
+        assertEnumValue(parsedValue, val, VALID_CONTEXT_GUARD_MODES, 'workflow.context_guard_mode');
     // Context position enum validation (#2937)
     const VALID_CONTEXT_POSITIONS = ['front', 'end'];
-    if (kp === 'statusline.context_position' && !VALID_CONTEXT_POSITIONS.includes(String(parsedValue))) {
-        error(`Invalid statusline.context_position '${val}'. Valid values: ${VALID_CONTEXT_POSITIONS.join(', ')}`);
-    }
+    if (kp === 'statusline.context_position')
+        assertEnumValue(parsedValue, val, VALID_CONTEXT_POSITIONS, 'statusline.context_position');
     // Fallow scope + profile enum validation (#3424)
     const VALID_FALLOW_SCOPES = ['phase', 'repo'];
-    if (kp === 'code_quality.fallow.scope' && !VALID_FALLOW_SCOPES.includes(String(parsedValue))) {
-        error(`Invalid code_quality.fallow.scope '${val}'. Valid values: ${VALID_FALLOW_SCOPES.join(', ')}`);
-    }
+    if (kp === 'code_quality.fallow.scope')
+        assertEnumValue(parsedValue, val, VALID_FALLOW_SCOPES, 'code_quality.fallow.scope');
     const VALID_FALLOW_PROFILES = ['minimal', 'standard', 'strict'];
-    if (kp === 'code_quality.fallow.profile' && !VALID_FALLOW_PROFILES.includes(String(parsedValue))) {
-        error(`Invalid code_quality.fallow.profile '${val}'. Valid values: ${VALID_FALLOW_PROFILES.join(', ')}`);
-    }
+    if (kp === 'code_quality.fallow.profile')
+        assertEnumValue(parsedValue, val, VALID_FALLOW_PROFILES, 'code_quality.fallow.profile');
     // plan_review.source_grounding (#22) — boolean only
     if (kp === 'plan_review.source_grounding') {
         if (typeof parsedValue !== 'boolean') {
@@ -584,8 +593,42 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
     }
     // plan_review.source_grounding_authority (#22) — enum
     const VALID_SOURCE_GROUNDING_AUTHORITIES = ['grep', 'intel', 'treesitter', 'lsp', 'scip'];
-    if (kp === 'plan_review.source_grounding_authority' && !VALID_SOURCE_GROUNDING_AUTHORITIES.includes(String(parsedValue))) {
-        error(`Invalid plan_review.source_grounding_authority '${val}'. Valid values: ${VALID_SOURCE_GROUNDING_AUTHORITIES.join(', ')}`);
+    if (kp === 'plan_review.source_grounding_authority')
+        assertEnumValue(parsedValue, val, VALID_SOURCE_GROUNDING_AUTHORITIES, 'plan_review.source_grounding_authority');
+    // Generic capability-registry validation (#1628). Capability-owned keys declare
+    // their type/values in the registry but most lack a hardcoded guard, so out-of-
+    // domain values (including JSON array/object coercion) were stored silently.
+    const capDef = getCapabilityConfigSchema(cwd)[kp];
+    if (capDef && typeof capDef.type === 'string') {
+        switch (capDef.type) {
+            case 'enum':
+                if (Array.isArray(capDef.values)) {
+                    assertEnumValue(parsedValue, val, capDef.values.map((v) => String(v)), kp);
+                }
+                break;
+            case 'boolean':
+                if (typeof parsedValue !== 'boolean') {
+                    error(`Invalid ${kp} '${val}'. Must be a boolean (true or false).`);
+                }
+                break;
+            case 'number':
+                if (typeof parsedValue !== 'number' || !Number.isFinite(parsedValue)) {
+                    error(`Invalid ${kp} '${val}'. Must be a number.`);
+                }
+                break;
+            case 'string':
+                if (typeof parsedValue !== 'string') {
+                    error(`Invalid ${kp} '${val}'. Must be a string.`);
+                }
+                break;
+        }
+    }
+    // Security — ASVS level range (#1628)
+    // Must be an integer in {1, 2, 3} (OWASP ASVS levels).
+    if (kp === 'workflow.security_asvs_level') {
+        if (typeof parsedValue !== 'number' || !Number.isInteger(parsedValue) || parsedValue < 1 || parsedValue > 3) {
+            error(`Invalid workflow.security_asvs_level '${val}'. Must be an integer 1, 2, or 3.`);
+        }
     }
     if (kp === 'review.default_reviewers') {
         const normalized = (0, review_reviewer_selection_cjs_1.normalizeConfiguredDefaultReviewers)(parsedValue);