@opengsd/gsd-core 1.7.0-rc.6 → 1.7.0

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

@@ -3,60 +3,29 @@
 /**
  * Standalone golden-fixture generator for tests/golden-install-parity.
  *
- * This is a BUILD-TIME generation script — NOT a test run. It replicates the
- * buildParityManifest logic from 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`.
+ * 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 crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
 
 const ROOT = path.resolve(__dirname, '..');
-const { walk, runMinimalInstall, RUNTIME_META } = require(path.join(ROOT, 'tests', 'helpers', 'install-shared.cjs'));
-const PKG_VERSION = require(path.join(ROOT, 'package.json')).version;
+// 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');
 
-const VOLATILE_FILES = new Set([
-  'gsd-file-manifest.json',
-  'gsd-install-state.json',
-  '.gsd-source',
-  'gsd-core/CHANGELOG.md',
-]);
-// Must match tests/golden-install-parity.test.cjs exactly — settings.local.json
-// (Claude LOCAL hook surface, #338/#2086) embeds the same platform-varying
-// node-runner command and is excluded there; omitting it here mis-generated the
-// claude-local fixture (#2100).
-const HOOK_CONFIG_FILES = new Set(['settings.json', 'settings.local.json', 'hooks.json']);
-// Kimi's native config.toml (#2095) — see tests/golden-install-parity.test.cjs'
-// HOOK_CONFIG_RELATIVE_PATHS comment for why this is an exact relative-path
-// exclusion rather than a HOOK_CONFIG_FILES basename entry (a basename entry
-// would also blind Codex's stable, platform-independent config.toml fixture).
-const HOOK_CONFIG_RELATIVE_PATHS = new Set(['.kimi/config.toml']);
-const EXCLUDED_PREFIXES = ['gsd-core/bin/lib/'];
-
-function buildParityManifest(configDir, root) {
-  const allFiles = walk(configDir);
-  const unsorted = {};
-  for (const full of allFiles) {
-    const rel = path.relative(configDir, full).split(path.sep).join('/');
-    if (VOLATILE_FILES.has(rel)) continue;
-    if (HOOK_CONFIG_FILES.has(path.basename(rel))) continue;
-    if (HOOK_CONFIG_RELATIVE_PATHS.has(rel)) continue;
-    if (EXCLUDED_PREFIXES.some((p) => rel.startsWith(p))) continue;
-    const content = fs.readFileSync(full);
-    const normalized = content.toString('utf8').split(root).join('<HOME>').split(PKG_VERSION).join('<VERSION>');
-    const hash = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 16);
-    unsorted[rel] = hash;
-  }
-  const sorted = {};
-  for (const key of Object.keys(unsorted).sort()) sorted[key] = unsorted[key];
-  return sorted;
-}
-
 function cleanup(root) {
   try { fs.rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ }
 }
@@ -69,6 +38,13 @@ function cleanup(root) {
 // 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`);
@@ -85,3 +61,17 @@ for (const runtime of targets) {
   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/gen-install-tree-fixtures.cjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Standalone golden-fixture generator for tests/golden-install-tree (#2267 Phase 2).
+ *
+ * This is a BUILD-TIME generation script — NOT a test run. It imports the
+ * canonical buildInstallTree builder from tests/helpers/install-shared.cjs,
+ * which in turn reuses buildParityManifest's exact exclusion set (issue
+ * #2266) so the file-set fixtures here and the golden-install-parity content
+ * fixtures never diverge on which files they cover. The authoritative test
+ * gate remains `gsd-test run`, never a local `node --test`.
+ *
+ * Usage: node scripts/gen-install-tree-fixtures.cjs [runtime ...]
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+// buildInstallTree (and the exclusion constants it reuses from
+// buildParityManifest) is the canonical single source of truth in
+// tests/helpers/install-shared.cjs (issue #2266/#2267) — this generator does
+// not keep its own inline copy of the walk/exclusion logic.
+const { runMinimalInstall, RUNTIME_META, buildInstallTree, BUILD_SCRIPT } = require(path.join(ROOT, 'tests', 'helpers', 'install-shared.cjs'));
+const FIXTURE_DIR = path.join(ROOT, 'tests', 'fixtures', 'install-tree');
+
+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 path appears in every runtime's manifest, so all
+// fixtures must be recaptured together. Usage:
+//   node scripts/gen-install-tree-fixtures.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 = buildInstallTree(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 ${actual.length} paths -> ${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 snapshot assertion in the test harness.
+const { configDir: localConfigDir, root: localRoot } = runMinimalInstall({ runtime: 'claude', scope: 'local' });
+let localActual;
+try {
+  localActual = buildInstallTree(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 ${localActual.length} paths -> ${localFixturePath}\n`);

package/scripts/lint-allow-test-rule-refs.allowlist.json

@@ -99,7 +99,6 @@
   "tests/mcp-tool-inheritance.test.cjs :: source-text-is-the-product",
   "tests/milestone-summary.test.cjs :: source-text-is-the-product",
   "tests/milestone.test.cjs :: source-text-is-the-product",
-  "tests/milestone.test.cjs :: structural-regression-guard",
   "tests/model-catalog-runtime-defaults.test.cjs :: source-text-is-the-product",
   "tests/next-safety-gates.test.cjs :: source-text-is-the-product",
   "tests/next-up-clear-order.test.cjs :: source-text-is-the-product",

package/scripts/lint-table-schema-drift.cjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Table-schema drift lint (ADR-2143 §3 Generative-Fix-Divergence guard, §7
+ * "prohibition with teeth", epic #2143).
+ *
+ * `TABLE_SCHEMAS` (`src/markdown-table.cts`, compiled to
+ * `gsd-core/bin/lib/markdown-table.cjs`) is the single-source registry naming
+ * every canonical GSD pipe-table's column-header shape. Each registered
+ * variant's exact `| col | col |` header string MUST appear verbatim in the
+ * ONE template/workflow file that emits that table — otherwise the writer and
+ * the registry have silently drifted apart, the exact bug class this ADR
+ * closes (#2137 — reader hard-codes a shape the writer doesn't emit; #2133 —
+ * the `quick.md` writer and its shell guard disagree on column count; #2119 —
+ * dual SECURITY.md writers with conflicting shapes).
+ *
+ * Modeled on scripts/lint-phase-id-drift.cjs / scripts/lint-package-identity-drift.cjs:
+ * a standalone node script (not a node:test), wired into `lint:ci`, exit 0 clean /
+ * exit 1 + message on drift.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Schema id -> the ONE canonical template/workflow file that must emit every
+// variant's header verbatim (ADR-2143 §3).
+const SCHEMA_SOURCE_FILES = {
+  RoadmapProgress: path.join('gsd-core', 'templates', 'roadmap.md'),
+  RequirementsTraceability: path.join('gsd-core', 'templates', 'requirements.md'),
+  QuickTasks: path.join('gsd-core', 'workflows', 'quick.md'),
+  Security: path.join('gsd-core', 'templates', 'SECURITY.md'),
+};
+
+/** Build the exact `| a | b | c |` header line for one schema variant. */
+function buildHeader(variant) {
+  return `| ${variant.columns.join(' | ')} |`;
+}
+
+/** Normalize whitespace around pipes so template formatting quirks (extra
+ * spaces added by an editor, etc.) don't produce a false drift report. */
+function normalize(line) {
+  return line.replace(/[ \t]*\|[ \t]*/g, '|').trim();
+}
+
+/**
+ * Pure: given `schemas` (a `TABLE_SCHEMAS`-shaped object) and a
+ * `readFile(relPath) -> string|null` accessor, find every variant whose exact
+ * header does not appear verbatim (pipe-whitespace normalized) in its
+ * schema's registered source file. Returns
+ * `[{ schemaId, label, header, file, reason }]`; empty when clean.
+ */
+function findTableSchemaDrift(schemas, readFile, sourceFiles = SCHEMA_SOURCE_FILES) {
+  const violations = [];
+  for (const [schemaId, variants] of Object.entries(schemas)) {
+    const relPath = sourceFiles[schemaId];
+    if (!relPath) {
+      violations.push({
+        schemaId,
+        label: null,
+        header: null,
+        file: null,
+        reason: 'no canonical source file registered for this schema id in SCHEMA_SOURCE_FILES',
+      });
+      continue;
+    }
+
+    const content = readFile(relPath);
+    if (content == null) {
+      for (const variant of variants) {
+        violations.push({
+          schemaId,
+          label: variant.label,
+          header: buildHeader(variant),
+          file: relPath,
+          reason: 'source file not found or unreadable',
+        });
+      }
+      continue;
+    }
+
+    const normalizedLines = content.split(/\r?\n/).map(normalize);
+    for (const variant of variants) {
+      const expected = normalize(buildHeader(variant));
+      if (!normalizedLines.includes(expected)) {
+        violations.push({
+          schemaId,
+          label: variant.label,
+          header: buildHeader(variant),
+          file: relPath,
+          reason: 'header not found verbatim in source file',
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+/**
+ * Load the built seam and scan the real repo tree. Returns the same shape as
+ * `findTableSchemaDrift`. If the seam hasn't been built yet (`npm run
+ * build:lib`), reports a single actionable violation rather than throwing.
+ */
+function scanRepo(root) {
+  const seamPath = path.join(root, 'gsd-core', 'bin', 'lib', 'markdown-table.cjs');
+  let seam;
+  try {
+    seam = require(seamPath);
+  } catch (e) {
+    return [{
+      schemaId: null,
+      label: null,
+      header: null,
+      file: null,
+      reason: `cannot load the markdown-table seam at ${path.relative(root, seamPath)} — run 'npm run build:lib' first (${e.message})`,
+    }];
+  }
+
+  const readFile = (relPath) => {
+    try {
+      return fs.readFileSync(path.join(root, relPath), 'utf8');
+    } catch {
+      return null;
+    }
+  };
+
+  return findTableSchemaDrift(seam.TABLE_SCHEMAS, readFile);
+}
+
+function main() {
+  const root = path.join(__dirname, '..');
+  const violations = scanRepo(root);
+  if (violations.length === 0) {
+    process.stdout.write(
+      'ok table-schema-drift: every TABLE_SCHEMAS variant header appears verbatim in its canonical template/workflow\n',
+    );
+    return;
+  }
+  process.stderr.write(
+    'table-schema-drift: TABLE_SCHEMAS variant(s) whose header is absent from their canonical source file (ADR-2143 §3).\n',
+  );
+  process.stderr.write(
+    'Either update the template/workflow to emit the registered header verbatim, or update\n' +
+      'TABLE_SCHEMAS in src/markdown-table.cts to match — the two must never drift.\n',
+  );
+  for (const v of violations) {
+    const id = v.label ? `${v.schemaId}.${v.label}` : (v.schemaId ?? '?');
+    const loc = v.file ? ` (${v.file})` : '';
+    const expected = v.header ? ` — expected ${JSON.stringify(v.header)}` : '';
+    process.stderr.write(`  ${id}${loc}: ${v.reason}${expected}\n`);
+  }
+  process.exitCode = 1;
+}
+
+if (require.main === module) main();
+
+module.exports = { findTableSchemaDrift, scanRepo, buildHeader, normalize, SCHEMA_SOURCE_FILES };

package/skills/gsd-mempalace-capture/SKILL.md

@@ -55,7 +55,33 @@ This step is `onError: skip` at `discuss:post` / `plan:post` / `verify:post` --
 On any error or timeout, stop and let the phase continue -- capture is best-effort.
 
 1. **Dedup first.** Interactive: `mempalace_check_duplicate` on the artifact's deterministic drawer id. Headless: rely on `mempalace mine`'s content-hash idempotency.
-2. **Add the drawer (verbatim).** File the exact artifact text into `room: <room>` of `wing: <wing>` with provenance (`source_file`, phase id). Interactive: `mempalace_add_drawer`. Headless: `mempalace mine <path> --wing <wing> --room <room>`.
+2. **Add the drawer (verbatim).** File the exact artifact text into `room: <room>` of `wing: <wing>` with provenance (`source_file`, phase id). Interactive: `mempalace_add_drawer`. Headless: see below.
+
+   **`mempalace mine` has no `--room` flag** — only `search` accepts `--room` ([CLI reference: https://mempalaceofficial.com/reference/cli.html](https://mempalaceofficial.com/reference/cli.html)). Room assignment is driven by `detect_room()` matching folder-path segments against the `rooms:` list in `mempalace.yaml` ([mining guide: https://mempalaceofficial.com/guide/mining.html](https://mempalaceofficial.com/guide/mining.html) — "Rooms are auto-detected from your folder structure"; [config reference: https://mempalaceofficial.com/guide/configuration.html](https://mempalaceofficial.com/guide/configuration.html)). Stage the artifact under a room-named folder so `detect_room()` assigns it correctly:
+
+   ```bash
+   STAGE=".planning/.mempalace-stage"
+   # One-time: declare the GSD room taxonomy so detect_room() recognizes these folders
+   mkdir -p "$STAGE"
+   [ -f "$STAGE/mempalace.yaml" ] || cat > "$STAGE/mempalace.yaml" <<'YAML'
+   rooms:
+     - decisions
+     - planning
+     - milestones
+     - problems
+     - general
+   YAML
+   # Suppress MemPalace cache artifacts written into the scanned tree
+   [ -f "$STAGE/.gitignore" ] || echo "mempalace_embedder.json" > "$STAGE/.gitignore"
+   # Stage under <room>/<phase-id>/<basename> — stable path so mine's content-hash
+   # idempotency (file_already_mined keys on absolute source_file + mtime) deduplicates
+   # instead of creating duplicate drawers on re-runs.
+   ROOM_DIR="$STAGE/<room>/<phase-id>"
+   mkdir -p "$ROOM_DIR"
+   cp "<artifact-path>" "$ROOM_DIR/<basename>"
+   # Mine with --wing only — no --room flag; detect_room() assigns from the folder path
+   mempalace mine "$STAGE" --wing <wing>
+   ```
 3. **Mirror KG facts** when `config.mempalace.mirror_kg` is true: extract decision/delivery facts and `mempalace_kg_add` them with `valid_from` = the phase date (e.g. `(<project>, decided, <decision>)` from CONTEXT; `(<phase>, delivered, <capability>)` from SUMMARY). Under `augment` these are an *additive* mirror of GSD's native `.planning/graphs/`. Under `kg_backend`/`replace` the palace KG is the *authoritative* fact store — GSD still produces `.planning/graphs/` through its normal graphify, so an unreachable palace never loses a fact.
 4. Re-running a phase MUST NOT create duplicate drawers (deterministic ids + `check_duplicate`).
 

package/skills/gsd-surface/SKILL.md

@@ -37,9 +37,9 @@ Parse the first token of $ARGUMENTS:
 ## list / status
 
 Load the capability registry and call `listSurface(runtimeConfigDir, manifest, CLUSTERS, registry)` from
-`gsd-core/bin/lib/surface.cjs`. The registry is loaded via:
+the engine module at `${runtimeConfigDir}/gsd-core/bin/lib/surface.cjs`. The registry is loaded via:
 ```js
-const registry = require('gsd-core/bin/lib/capability-registry.cjs');
+const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
 ```
 Display:
 
@@ -71,7 +71,7 @@ Install profile: standard  (from .gsd-profile)
 3. `writeSurface(runtimeConfigDir, surfaceState)`.
 4. Resolve and re-apply:
    ```js
-   const registry = require('gsd-core/bin/lib/capability-registry.cjs');
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
    const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
    applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry);
    ```
@@ -89,7 +89,7 @@ Valid cluster names: `core_loop`, `audit_review`, `milestone`, `research_ideate`
 3. Add cluster to `surfaceState.disabledClusters` (deduplicate).
 4. `writeSurface` → resolve layout → `applySurface`:
    ```js
-   const registry = require('gsd-core/bin/lib/capability-registry.cjs');
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
    const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
    applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry);
    ```
@@ -103,7 +103,7 @@ Valid cluster names: `core_loop`, `audit_review`, `milestone`, `research_ideate`
 2. Remove cluster from `surfaceState.disabledClusters`.
 3. `writeSurface` → resolve layout → `applySurface`:
    ```js
-   const registry = require('gsd-core/bin/lib/capability-registry.cjs');
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
    const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
    applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry);
    ```
@@ -151,7 +151,7 @@ All paths can be overridden by reading the `CLAUDE_CONFIG_DIR` env var if set.
 
 - Unknown cluster name → list valid cluster names, exit without writing.
 - Unknown profile name → list known profiles (`core`, `standard`, `full`), exit.
-- Missing `surface.cjs` → prompt: "Run `npm i -g gsd-core` to reinstall GSD."
+- Missing `surface.cjs` → prompt: "Run `npm i -g @opengsd/gsd-core` to reinstall GSD."
 
 <execution_context>
 Surface state file: `~/.claude/.gsd-surface.json`

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.7.0-rc.6",
+  "version": "1.7.0",
   "publisher": "opengsd",
   "engines": {
     "vscode": "^1.105.0"