@opengsd/gsd-core 1.8.0 → 1.9.0

package/scripts/registry-schema.cjs

@@ -36,6 +36,11 @@
  *     (`{ namedDispatch, nested, maxDepth, background, subagentToolkit }`) —
  *     this registry accepts a free-form human summary string instead, so it
  *     carries the `AXES_FREE_STRING` sentinel rather than an enum array.
+ *     `OPTIONAL_AXES` adds one further, OPTIONAL key on top of those eight:
+ *     `effortSurface` (ADR-1239 amendment #2481). An entry may omit it
+ *     (every entry published before the amendment stays valid) or declare
+ *     it as `argv` | `none`, mirroring `HOST_INTEGRATION_AXES.effortSurface`
+ *     in `src/host-integration.cts`.
  *   - `CAPABILITY_REQUIRED` / `EOS_REQUIRED` mirror the required top-level
  *     fields for each entry type, including `enginesGsd` (ADR-1244 D1
  *     "Versioned capability manifest" — the `engines.gsd` semver-range gate,
@@ -90,6 +95,18 @@ const AXES = Object.freeze({
   runtime: Object.freeze(['node', 'bun', 'sandboxed-web', 'python', 'go', 'rust', 'electron', 'other']),
 });
 
+// ─── ADR-1239 amendment #2481 — one additional, OPTIONAL negotiated axis ─────
+// `effortSurface` was added to the runtime-descriptor vocabulary AFTER the
+// original eight (`HOST_INTEGRATION_AXES.effortSurface` in
+// `src/host-integration.cts`). It is kept OPTIONAL here — not folded into
+// `AXES` — because registry entries mirror their upstream
+// `registry/eos-entry.json` byte-for-byte, and requiring it would
+// retroactively invalidate every entry published before the amendment.
+// Values must match `HOST_INTEGRATION_AXES.effortSurface` exactly.
+const OPTIONAL_AXES = Object.freeze({
+  effortSurface: Object.freeze(['argv', 'none']),
+});
+
 // ─── Required top-level fields ───────────────────────────────────────────────
 const CAPABILITY_REQUIRED = Object.freeze([
   'id',
@@ -246,15 +263,39 @@ function validateEosInteractions(interactions, addError) {
     if (typeof axes !== 'object' || axes === null || Array.isArray(axes)) {
       addError('interactions.axes', 'axes must be an object');
     } else {
-      const expectedKeys = Object.keys(AXES);
+      const requiredKeys = Object.keys(AXES);
+      const optionalKeys = Object.keys(OPTIONAL_AXES);
       const actualKeys = Object.keys(axes);
       const actualKeySet = new Set(actualKeys);
-      const keysMatch = expectedKeys.length === actualKeys.length && expectedKeys.every((k) => actualKeySet.has(k));
-      if (!keysMatch) {
-        addError('interactions.axes', 'axes key set must exactly match the eight negotiated axes');
-      } else {
-        for (const key of expectedKeys) {
-          const allowedValues = AXES[key];
+
+      // Every AXES key is mandatory; an extra key is tolerated ONLY when it is
+      // a recognized OPTIONAL_AXES key (currently just `effortSurface`) — any
+      // other extra key is still rejected as unknown.
+      const missingRequiredKeys = requiredKeys.filter((k) => !actualKeySet.has(k));
+      const unknownKeys = actualKeys.filter((k) => !requiredKeys.includes(k) && !optionalKeys.includes(k));
+
+      if (missingRequiredKeys.length > 0) {
+        addError('interactions.axes', `axes is missing required key(s): ${missingRequiredKeys.join(', ')}`);
+      }
+      if (unknownKeys.length > 0) {
+        addError('interactions.axes', `axes has unknown key(s): ${unknownKeys.join(', ')}`);
+      }
+
+      // Only validate individual values once the key set itself is sound —
+      // mirrors the original gate (values were never checked against a
+      // malformed key set either).
+      if (missingRequiredKeys.length === 0 && unknownKeys.length === 0) {
+        for (const key of actualKeys) {
+          // Inline literal guards — CodeQL barrier pattern. Reaching here already
+          // implies `key` is one of the nine literal axis names (the unknown-key
+          // gate above rejected everything else), so this is unreachable in
+          // practice; it is written inline anyway because CodeQL cannot follow
+          // that gate across the `.includes()` filter and would otherwise flag
+          // the bracket reads below as prototype-pollution sinks.
+          if (key === '__proto__') continue;
+          if (key === 'constructor') continue;
+          if (key === 'prototype') continue;
+          const allowedValues = Object.hasOwn(AXES, key) ? AXES[key] : OPTIONAL_AXES[key];
           const v = axes[key];
           if (allowedValues === AXES_FREE_STRING) {
             if (typeof v !== 'string' || v.trim() === '') {
@@ -496,7 +537,14 @@ function renderMarkdown(entries, opts) {
     lines.push(`- **Author:** ${mdInline(entry.author)}`);
 
     if (isEos) {
-      const axesSummary = Object.keys(AXES)
+      // Required AXES keys always render, in their fixed order; an OPTIONAL_AXES
+      // key (e.g. `effortSurface`) renders ONLY when the entry actually carries
+      // it — an entry that omits it must render byte-identical to before
+      // OPTIONAL_AXES existed (no `effortSurface=undefined` noise).
+      const presentOptionalKeys = Object.keys(OPTIONAL_AXES).filter(
+        (key) => interactions.axes && Object.hasOwn(interactions.axes, key),
+      );
+      const axesSummary = [...Object.keys(AXES), ...presentOptionalKeys]
         .map((key) => `${key}=${interactions.axes ? interactions.axes[key] : undefined}`)
         .join(', ');
       const summary =
@@ -556,6 +604,7 @@ module.exports = {
   INTERFACE_POINTS,
   PROFILES,
   AXES,
+  OPTIONAL_AXES,
   AXES_FREE_STRING,
   CAPABILITY_REQUIRED,
   EOS_REQUIRED,

package/scripts/release-notes/conventional-title.cjs

@@ -30,18 +30,36 @@ const HEADER_RE = /^([a-z]+)(\([^)]*\))?(!)?:/i;
 // An issue reference inside a scope: `(#123)`, `(#123, core)`, etc.
 const ISSUE_REF_IN_SCOPE_RE = /#\d+/;
 
+// #2716: recognized non-user-facing conventional-commit types. A title whose
+// START-anchored type prefix is one of these is internal work (tests, chores,
+// CI, docs, refactors, perf, reverts) and must NOT render under the user-facing
+// "Enhancement" heading in release notes. Only a CLEAN prefix match qualifies —
+// untyped or anchor-defeated titles fall through to the visible Enhancement
+// fallback (a safety net so possibly-user-facing content is never hidden).
+const NON_USER_FACING_TYPES = new Set([
+  'docs', 'refactor', 'test', 'ci', 'chore', 'perf', 'revert',
+]);
+
 /**
  * Classify a clean conventional title into a changelog bucket.
  * Callers that hold a full changelog bullet line (with a `* ` marker and a
  * ` by @author` suffix) must strip those first; this operates on the title.
  *
  * @param {string} title
- * @returns {'Feature'|'Fix'|'Enhancement'}
+ * @returns {'Feature'|'Fix'|'Enhancement'|'Internal'}
  */
 function classifyBucket(title) {
   const t = String(title == null ? '' : title).trim();
   if (FEATURE_RE.test(t)) return 'Feature';
   if (FIX_RE.test(t)) return 'Fix';
+  // #2716: a clean non-user-facing type prefix → Internal (omitted from user-facing
+  // release-note sections). The HEADER_RE anchor ensures a leading tag/prefix
+  // (e.g. `[security] fix(...)`) does NOT match here — those keep falling through
+  // to the visible Enhancement fallback.
+  const headerMatch = HEADER_RE.exec(t);
+  if (headerMatch && NON_USER_FACING_TYPES.has(headerMatch[1].toLowerCase())) {
+    return 'Internal';
+  }
   return 'Enhancement';
 }
 

package/scripts/release-notes/format-github-release-notes.cjs

@@ -8,9 +8,9 @@ const { runMain, ExitError } = require('../lib/cli-exit.cjs');
 const { classifyBucket } = require('./conventional-title.cjs');
 
 /**
- * Classify a What's-Changed bullet line into 'Feature', 'Fix', or 'Enhancement'.
+ * Classify a What's-Changed bullet line into 'Feature', 'Fix', 'Enhancement', or 'Internal'.
  * @param {string} bulletLine - Full bullet line including the leading `* ` or `- ` marker.
- * @returns {'Feature'|'Fix'|'Enhancement'}
+ * @returns {'Feature'|'Fix'|'Enhancement'|'Internal'}
  */
 function classifyTitle(bulletLine) {
   // Strip leading `* ` or `- ` marker
@@ -83,7 +83,11 @@ function formatReleaseNotes({ generatedBody, version, prerelease, packageName })
       const category = classifyTitle(trimmed);
       if (category === 'Feature') featureBullets.push(trimmed);
       else if (category === 'Fix') fixBullets.push(trimmed);
-      else enhancementBullets.push(trimmed);
+      else if (category === 'Internal') {
+        // #2716: non-user-facing work (test/chore/ci/docs/refactor/perf/revert)
+        // is omitted from the user-facing "What's Changed" section entirely.
+        continue;
+      } else enhancementBullets.push(trimmed);
       continue;
     }
 

package/scripts/workflow-size.cjs

@@ -5,10 +5,13 @@
  *
  * Single source of truth for measuring workflow `.md` file sizes in bytes.
  *
- * Shared by `tests/workflow-size-budget.test.cjs` (the CI guard) and
- * `scripts/update-size-baseline.cjs` (the baseline generator) so the two can
- * never disagree on HOW a file is measured.  A divergence between the generator
- * and the guard would silently mis-record the baseline (issue #1074).
+ * Shared by `tests/workflow-size-budget.test.cjs` / `tests/agent-size-budget.test.cjs`
+ * (the tier hard-cap guards), `tests/helpers/emitted-runtime.cjs`'s `currentSizes()`
+ * (the differential attribution check's size ratchet, ADR-2719 Phase 4), and
+ * `scripts/gen-emitted-baseline.cjs` (the baseline publisher) so none of them can
+ * disagree on HOW a file is measured (issue #1074). `scripts/update-size-baseline.cjs`,
+ * the original third consumer, was removed by #2724 along with the per-file baseline
+ * it generated.
  */
 
 const fs = require('fs');
@@ -19,11 +22,16 @@ const WORKFLOWS_DIR = path.join(__dirname, '..', 'gsd-core', 'workflows');
 /**
  * Byte size of a file, counted as on an LF (Unix) checkout.
  *
- * The size budget is calibrated against `wc -c` on a Unix (LF) checkout, but
- * these `.md` files have no `eol=lf` in `.gitattributes`, so Windows checks
- * them out as CRLF.  Counting raw on-disk bytes there adds one byte per line,
- * a Windows-only false positive that diverges from the LF calibration basis
+ * The size budget is calibrated against `wc -c` on a Unix (LF) checkout.
+ * Counting raw on-disk bytes on a CRLF checkout adds one byte per line, a
+ * Windows-only false positive that diverges from the LF calibration basis
  * (issue #683).  Stripping CR yields the same LF byte count on every platform.
+ *
+ * `.gitattributes:2` (`* text=auto eol=lf`, added in #1088) now normalizes these
+ * files to LF on checkout everywhere, so the CRLF case should not arise from a
+ * normal clone — but this stays unconditional because it also covers a working
+ * tree produced some other way (an unpacked archive, an editor that rewrites
+ * line endings, a checkout predating that attribute).
  * This is still a raw byte count (not a trailing-newline-stripping line count).
  *
  * @param {string} filePath - Absolute or relative path to the file.

package/skills/gsd-plan-review-convergence/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: gsd-plan-review-convergence
 description: "Cross-AI plan convergence - replan until review concerns are resolved."
-argument-hint: "<phase> [--codex] [--gemini] [--claude] [--opencode] [--ollama] [--lm-studio] [--llama-cpp] [--agy] [--text] [--ws <name>] [--all] [--max-cycles N]"
+argument-hint: "<phase> [--gemini] [--claude] [--codex] [--coderabbit] [--opencode] [--qwen] [--cursor] [--antigravity] [--agy] [--ollama] [--lm-studio] [--llama-cpp] [--kimi-code] [--text] [--ws <name>] [--all] [--max-cycles N]"
 allowed-tools:
   - Read
   - Write
@@ -44,10 +44,14 @@ Phase number: extracted from $ARGUMENTS (required)
 - `--gemini` — Use Gemini CLI as reviewer
 - `--agy` / `--antigravity` — Use Antigravity CLI as reviewer (successor to the discontinued Gemini CLI)
 - `--claude` — Use Claude CLI as reviewer (separate session)
+- `--coderabbit` — Use CodeRabbit as reviewer (reviews the working-tree diff, not the source tree)
 - `--opencode` — Use OpenCode as reviewer
+- `--qwen` — Use Qwen Code CLI as reviewer (Alibaba Qwen models)
+- `--cursor` — Use Cursor agent as reviewer
 - `--ollama` — Use local Ollama server as reviewer (OpenAI-compatible, default host `http://localhost:11434`; configure model via `review.models.ollama`)
 - `--lm-studio` — Use local LM Studio server as reviewer (OpenAI-compatible, default host `http://localhost:1234`; configure model via `review.models.lm_studio`)
 - `--llama-cpp` — Use local llama.cpp server as reviewer (OpenAI-compatible, default host `http://localhost:8080`; configure model via `review.models.llama_cpp`)
+- `--kimi-code` — Use Kimi Code CLI as reviewer (Moonshot AI)
 - `--all` — Use all available CLIs and running local model servers
 - `--max-cycles N` — Maximum replan→review cycles (default: 3)
 

package/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "gsd-core-vscode",
   "displayName": "GSD Core",
   "description": "GSD orchestration engine embedded in VS Code (ADR-1239 IDE profile).",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "publisher": "opengsd",
   "engines": {
     "vscode": "^1.105.0"

package/scripts/gen-golden-install-parity-zcode.cjs

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Standalone golden-fixture generator for tests/golden-install-parity.
- *
- * This is a BUILD-TIME generation script — NOT a test run. It imports the
- * canonical buildParityManifest builder from tests/helpers/install-shared.cjs
- * (issue #2266 — single source of truth shared with
- * tests/golden-install-parity.test.cjs) and captures the zcode fixture so the
- * parity test (which the gsd-test gate runs) has a committed artifact to
- * compare against. The authoritative test gate remains `gsd-test run`, never
- * a local `node --test`.
- *
- * Usage: node scripts/gen-golden-install-parity-zcode.cjs
- */
-const fs = require('node:fs');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-
-const ROOT = path.resolve(__dirname, '..');
-// buildParityManifest (and its exclusion constants) is the canonical single
-// source of truth in tests/helpers/install-shared.cjs (issue #2266) — the
-// generator no longer keeps its own inline copy, which had drifted from the
-// test harness's copy (missing the realpath/`<HOME>` normalization) and
-// mis-generated the claude-local fixture (#2100).
-const { runMinimalInstall, RUNTIME_META, buildParityManifest, BUILD_SCRIPT } = require(path.join(ROOT, 'tests', 'helpers', 'install-shared.cjs'));
-const FIXTURE_DIR = path.join(ROOT, 'tests', 'fixtures', 'golden-install-parity');
-
-function cleanup(root) {
-  try { fs.rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ }
-}
-
-// Regenerate the fixture for every runtime in RUNTIME_META. Needed when a
-// SHARED gsd-core payload file (e.g. model-catalog.json, capability-registry)
-// changes content — its hash appears in every runtime's manifest, so all
-// fixtures must be recaptured together. Usage:
-//   node scripts/gen-golden-install-parity-zcode.cjs [runtime ...]
-// With no args, regenerates ALL runtimes. With args, only the named runtimes.
-const targets = process.argv.slice(2).length > 0 ? process.argv.slice(2) : Object.keys(RUNTIME_META);
-fs.mkdirSync(FIXTURE_DIR, { recursive: true });
-
-// Build hooks/dist before capturing so fixtures are complete even in a clean
-// checkout (hooks/dist is gitignored + built; DEFECT.HOOKS-DIST-SCOPED-CI). The
-// test harness's before() hook does the same; without it a fresh checkout omits
-// every hooks/* path and this generator silently writes short fixtures.
-execFileSync(process.execPath, [BUILD_SCRIPT], { stdio: 'pipe' });
-
-for (const runtime of targets) {
-  if (!Object.prototype.hasOwnProperty.call(RUNTIME_META, runtime)) {
-    process.stderr.write(`[gen] unknown runtime '${runtime}' (not in RUNTIME_META) — skipping\n`);
-    continue;
-  }
-  const { configDir, root } = runMinimalInstall({ runtime, scope: 'global' });
-  let actual;
-  try {
-    actual = buildParityManifest(configDir, root);
-  } finally {
-    cleanup(root);
-  }
-  const fixturePath = path.join(FIXTURE_DIR, `${runtime}.json`);
-  fs.writeFileSync(fixturePath, JSON.stringify(actual, null, 2) + '\n', 'utf8');
-  process.stdout.write(`[gen] ${runtime}: wrote ${Object.keys(actual).length} file hashes -> ${fixturePath}\n`);
-}
-
-// Also regenerate the claude LOCAL legacy-layout fixture (claude-local.json).
-// This layout is distinct from the global install (commands/gsd-*.md +
-// agents/gsd-*.md) and has its own parity assertion in the test harness.
-const { configDir: localConfigDir, root: localRoot } = runMinimalInstall({ runtime: 'claude', scope: 'local' });
-let localActual;
-try {
-  localActual = buildParityManifest(localConfigDir, localRoot);
-} finally {
-  cleanup(localRoot);
-}
-const localFixturePath = path.join(FIXTURE_DIR, 'claude-local.json');
-fs.writeFileSync(localFixturePath, JSON.stringify(localActual, null, 2) + '\n', 'utf8');
-process.stdout.write(`[gen] claude-local: wrote ${Object.keys(localActual).length} file hashes -> ${localFixturePath}\n`);

package/scripts/update-size-baseline.cjs

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * @file update-size-baseline.cjs
- *
- * Regenerates the committed per-file workflow size baseline
- * (`tests/workflow-size-baseline.json`) from the current workflow files.
- *
- * Run via `npm run size:baseline` whenever a workflow file legitimately grows
- * or shrinks.  Growth must still be justified in the PR; this script only
- * records the new reality so the CI guard (issue #1074) can diff against it.
- *
- * Idempotent: running it twice with no file changes produces no diff.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { measureMdFiles, WORKFLOWS_DIR } = require('./workflow-size.cjs');
-
-const BASELINE_PATH = path.join(__dirname, '..', 'tests', 'workflow-size-baseline.json');
-const AGENTS_DIR = path.join(__dirname, '..', 'agents');
-const AGENT_BASELINE_PATH = path.join(__dirname, '..', 'tests', 'agent-size-baseline.json');
-const isGsdAgent = (f) => f.startsWith('gsd-');
-
-/**
- * Serialize a size map to the on-disk baseline format: keys sorted, 2-space
- * indent, trailing newline (so the file is a stable, minimal-diff artifact).
- *
- * @param {Object<string, number>} sizes
- * @returns {string}
- */
-function serializeBaseline(sizes) {
-  const sorted = {};
-  for (const key of Object.keys(sizes).sort()) sorted[key] = sizes[key];
-  return JSON.stringify(sorted, null, 2) + '\n';
-}
-
-/**
- * Write a baseline file from the measured `.md` sizes in a directory.
- *
- * @param {object} [opts]
- * @param {string} [opts.dir]       - Directory to measure (default: workflows).
- * @param {string} [opts.outPath]   - Baseline file to write (default: workflow).
- * @param {function(string): boolean} [opts.predicate] - Filename filter.
- * @returns {{ outPath: string, count: number, content: string }}
- */
-function generateBaseline({ dir = WORKFLOWS_DIR, outPath = BASELINE_PATH, predicate } = {}) {
-  const sizes = measureMdFiles(dir, predicate);
-  const content = serializeBaseline(sizes);
-  fs.writeFileSync(outPath, content);
-  return { outPath, count: Object.keys(sizes).length, content };
-}
-
-if (require.main === module) {
-  const targets = [
-    { label: 'workflow', dir: WORKFLOWS_DIR, outPath: BASELINE_PATH },
-    { label: 'agent', dir: AGENTS_DIR, outPath: AGENT_BASELINE_PATH, predicate: isGsdAgent },
-  ];
-  for (const t of targets) {
-    const { outPath, count } = generateBaseline(t);
-    process.stdout.write(
-      `Wrote ${count} ${t.label} sizes to ${path.relative(process.cwd(), outPath)}\n`
-    );
-  }
-}
-
-module.exports = { generateBaseline, serializeBaseline, BASELINE_PATH, AGENT_BASELINE_PATH };