@opengsd/gsd-core 1.3.0-rc.1 → 1.3.0

package/scripts/check-alias-drift.cjs

@@ -4,7 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const ROOT = path.resolve(__dirname, '..');
-const aliasesPath = path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'command-aliases.cjs');
+const aliasesPath = path.join(ROOT, 'gsd-core', 'bin', 'lib', 'command-aliases.cjs');
 
 function fail(message) {
   process.stderr.write(`${message}\n`);
@@ -37,37 +37,37 @@ const families = [
   {
     commandAliases: 'STATE_COMMAND_ALIASES',
     subcommands: 'STATE_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'state-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'state-command-router.cjs'),
   },
   {
     commandAliases: 'VERIFY_COMMAND_ALIASES',
     subcommands: 'VERIFY_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'verify-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'verify-command-router.cjs'),
   },
   {
     commandAliases: 'INIT_COMMAND_ALIASES',
     subcommands: 'INIT_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'init-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'init-command-router.cjs'),
   },
   {
     commandAliases: 'PHASE_COMMAND_ALIASES',
     subcommands: 'PHASE_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'phase-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'phase-command-router.cjs'),
   },
   {
     commandAliases: 'PHASES_COMMAND_ALIASES',
     subcommands: 'PHASES_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'phases-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'phases-command-router.cjs'),
   },
   {
     commandAliases: 'VALIDATE_COMMAND_ALIASES',
     subcommands: 'VALIDATE_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'validate-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'validate-command-router.cjs'),
   },
   {
     commandAliases: 'ROADMAP_COMMAND_ALIASES',
     subcommands: 'ROADMAP_SUBCOMMANDS',
-    routerPath: path.join(ROOT, 'get-shit-done', 'bin', 'lib', 'roadmap-command-router.cjs'),
+    routerPath: path.join(ROOT, 'gsd-core', 'bin', 'lib', 'roadmap-command-router.cjs'),
   },
 ];
 

package/scripts/check-env.cjs

@@ -212,7 +212,11 @@ if (fs.existsSync(LOCKFILE)) {
 // ---------------------------------------------------------------------------
 if (fs.existsSync(LOCKFILE)) {
   try {
-    const res = spawnSync(npmCmd, ['ci', '--dry-run'], {
+    // --ignore-scripts: this is a lockfile-vs-package.json sync check, not a
+    // build. Without it, npm would run the `prepare` lifecycle (build:lib via
+    // tsc) — which fails when check:env runs before deps are installed (tsc
+    // absent), misreporting an out-of-sync lockfile. ADR-457 build-at-publish.
+    const res = spawnSync(npmCmd, ['ci', '--dry-run', '--ignore-scripts'], {
       cwd: PROJECT_ROOT,
       encoding: 'utf8',
       shell: process.platform === 'win32',

package/scripts/ci-test-scope.cjs

@@ -44,7 +44,7 @@ const RULES = [
   },
   {
     name: 'TS runtime sources (ADR-457 build-at-publish)',
-    // src/*.cts compiles into get-shit-done/bin/lib/*.cjs; a source-only edit must
+    // src/*.cts compiles into gsd-core/bin/lib/*.cjs; a source-only edit must
     // still trigger the migrated module's tests (otherwise CI silently skips them).
     match: path => path.startsWith('src/') || path === 'tsconfig.build.json',
     tests: [
@@ -55,7 +55,7 @@ const RULES = [
   {
     name: 'installer and package layout',
     match: path => path.startsWith('bin/') ||
-      path.startsWith('get-shit-done/bin/') ||
+      path.startsWith('gsd-core/bin/') ||
       path.includes('install') ||
       path.includes('release-tarball-smoke'),
     fullMatrix: true,
@@ -122,7 +122,7 @@ const RULES = [
   },
   {
     name: 'workflow prompts',
-    match: path => path.startsWith('get-shit-done/workflows/'),
+    match: path => path.startsWith('gsd-core/workflows/'),
     tests: [
       'tests/workflow-compat.test.cjs',
       'tests/workflow-size-budget.test.cjs',
@@ -153,7 +153,7 @@ const RULES = [
   },
   {
     name: 'configuration',
-    match: path => /config|configuration|model-catalog|model-profile/.test(path),
+    match: path => ['config', 'configuration', 'model-catalog', 'model-profile'].some(k => path.includes(k)),
     tests: [
       'tests/config.test.cjs',
       'tests/config-get-default.test.cjs',
@@ -208,7 +208,19 @@ function parseArgs(argv) {
 
 function splitFiles(value) {
   if (!value) return [];
-  return value.split(/[,\s]+/).map(v => v.trim()).filter(Boolean);
+  const SEPARATORS = new Set([',', ' ', '\t', '\n', '\r', '\f', '\v']);
+  const tokens = [];
+  let current = '';
+  for (const ch of value) {
+    if (SEPARATORS.has(ch)) {
+      if (current) tokens.push(current);
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens.map(v => v.trim()).filter(Boolean);
 }
 
 function changedFiles(args) {
@@ -231,6 +243,9 @@ function addAll(set, values) {
   for (const value of values) set.add(value);
 }
 
+const WINDOWS_HINTS = ['windows', 'path', 'shell', 'workflow', 'install', 'hook'];
+const isWindowsHint = s => WINDOWS_HINTS.some(k => s.toLowerCase().includes(k));
+
 function classify(files) {
   const targeted = new Set();
   const windows = new Set();
@@ -239,9 +254,9 @@ function classify(files) {
   let fullMatrix = false;
 
   for (const file of files) {
-    if (/^(bin|get-shit-done|agents|commands|docs|hooks|tests|scripts)\//.test(file) ||
-      /^package(-lock)?\.json$/.test(file) ||
-      /^tsconfig.*\.json$/.test(file) ||
+    if (['bin/', 'gsd-core/', 'agents/', 'commands/', 'docs/', 'hooks/', 'tests/', 'scripts/'].some(p => file.startsWith(p)) ||
+      file === 'package.json' || file === 'package-lock.json' ||
+      (file.startsWith('tsconfig') && file.endsWith('.json')) ||
       file.startsWith('.github/workflows/') ||
       file.startsWith('.github/rulesets/')) {
       codeChanged = true;
@@ -250,7 +265,7 @@ function classify(files) {
     if (file.startsWith('tests/') && file.endsWith('.test.cjs')) {
       targeted.add(file);
       fullMatrix = true;
-      if (/windows|path|shell|workflow|install|hook/i.test(file)) {
+      if (isWindowsHint(file)) {
         windows.add(file);
       }
     }
@@ -272,7 +287,7 @@ function classify(files) {
     targetedTests.push('unit');
   }
 
-  const windowsTests = existingTests([...new Set([...windows, ...targetedTests.filter(t => /windows|path|shell|workflow|install|hook/i.test(t))])].sort());
+  const windowsTests = existingTests([...new Set([...windows, ...targetedTests.filter(isWindowsHint)])].sort());
 
   return {
     code_changed: codeChanged,

package/scripts/command-contract-helpers.cjs

@@ -54,7 +54,7 @@ function executionContextRefs(content) {
       const trailingProse = line.length > token.length;
       const normalized = token
         .replace(/^@(?:~|\$HOME)\//, '')
-        .replace(/^(?:\.claude\/)?(?:get-shit-done\/)?/, '');
+        .replace(/^(?:\.claude\/)?(?:gsd-core\/)?/, '');
       refs.push({ token, normalized, trailingProse });
     }
   }

package/scripts/fix-slash-commands.cjs

@@ -20,11 +20,11 @@ const path = require('node:path');
 
 const COMMANDS_DIR = path.join(__dirname, '..', 'commands', 'gsd');
 const SEARCH_DIRS = [
-  path.join(__dirname, '..', 'get-shit-done', 'bin', 'lib'),
-  path.join(__dirname, '..', 'get-shit-done', 'workflows'),
-  path.join(__dirname, '..', 'get-shit-done', 'references'),
-  path.join(__dirname, '..', 'get-shit-done', 'templates'),
-  path.join(__dirname, '..', 'get-shit-done', 'contexts'),
+  path.join(__dirname, '..', 'gsd-core', 'bin', 'lib'),
+  path.join(__dirname, '..', 'gsd-core', 'workflows'),
+  path.join(__dirname, '..', 'gsd-core', 'references'),
+  path.join(__dirname, '..', 'gsd-core', 'templates'),
+  path.join(__dirname, '..', 'gsd-core', 'contexts'),
   path.join(__dirname, '..', 'commands', 'gsd'),
   path.join(__dirname, '..', 'agents'),
   path.join(__dirname, '..', 'hooks'),

package/scripts/gen-inventory-manifest.cjs

@@ -34,19 +34,19 @@ const FAMILIES = [
   },
   {
     name: 'workflows',
-    dir: path.join(ROOT, 'get-shit-done', 'workflows'),
+    dir: path.join(ROOT, 'gsd-core', 'workflows'),
     filter: (f) => f.endsWith('.md'),
     toName: (f) => f,
   },
   {
     name: 'references',
-    dir: path.join(ROOT, 'get-shit-done', 'references'),
+    dir: path.join(ROOT, 'gsd-core', 'references'),
     filter: (f) => f.endsWith('.md'),
     toName: (f) => f,
   },
   {
     name: 'cli_modules',
-    dir: path.join(ROOT, 'get-shit-done', 'bin', 'lib'),
+    dir: path.join(ROOT, 'gsd-core', 'bin', 'lib'),
     filter: (f) => f.endsWith('.cjs'),
     toName: (f) => f,
   },

package/scripts/generate-package-identity.cjs

@@ -6,7 +6,7 @@
  *
  * `deriveIdentity(pkg)` is the pure core: it turns a parsed package.json into
  * the coordinate record every consumer needs. The generated runtime module
- * `get-shit-done/bin/lib/package-identity.cjs` bakes those values at build
+ * `gsd-core/bin/lib/package-identity.cjs` bakes those values at build
  * time, because the installed tree carries only a synthetic
  * `{"type":"commonjs"}` package.json (no `.name`) — so a runtime
  * `require('package.json').name` resolves to `undefined` (the #378 bug this
@@ -24,6 +24,21 @@ function parseRepoSlug(repository) {
   return m ? m[1] : '';
 }
 
+/**
+ * Pure: turn an npm package name into a filesystem-safe slug for cache filenames.
+ * Strips a leading `@`, replaces `/` with `-`, then collapses any run of
+ * characters that are NOT `[a-z0-9]` to a single `-`, and trims leading/trailing `-`.
+ */
+function slugifyPackageName(name) {
+  if (!name) return '';
+  return name
+    .replace(/^@/, '')
+    .replace(/\//g, '-')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
 /**
  * Pure: package.json object -> the package identity coordinates.
  */
@@ -35,7 +50,9 @@ function deriveIdentity(pkg = {}) {
   const changelogRawUrl = repoSlug
     ? `https://raw.githubusercontent.com/${repoSlug}/main/CHANGELOG.md`
     : '';
-  return { packageName, binName, repoSlug, repoUrl, changelogRawUrl };
+  const cacheSlug = slugifyPackageName(packageName);
+  const updateCacheFileName = cacheSlug ? `gsd-update-check-${cacheSlug}.json` : 'gsd-update-check.json';
+  return { packageName, binName, repoSlug, repoUrl, changelogRawUrl, cacheSlug, updateCacheFileName };
 }
 
 /**
@@ -62,7 +79,7 @@ const GENERATED_HEADER =
  * runtime command builder is byte-identical to the tested source above.
  */
 function render(identity) {
-  const { packageName, binName, repoSlug, repoUrl, changelogRawUrl } = identity;
+  const { packageName, binName, repoSlug, repoUrl, changelogRawUrl, cacheSlug, updateCacheFileName } = identity;
   const j = (v) => JSON.stringify(v);
   return (
     GENERATED_HEADER +
@@ -71,7 +88,9 @@ function render(identity) {
     `const binName = ${j(binName)};\n` +
     `const repoSlug = ${j(repoSlug)};\n` +
     `const repoUrl = ${j(repoUrl)};\n` +
-    `const changelogRawUrl = ${j(changelogRawUrl)};\n\n` +
+    `const changelogRawUrl = ${j(changelogRawUrl)};\n` +
+    `const cacheSlug = ${j(cacheSlug)};\n` +
+    `const updateCacheFileName = ${j(updateCacheFileName)};\n\n` +
     `${formatManualInstall.toString()}\n\n` +
     'function manualInstallCommand(opts = {}) {\n' +
     '  return formatManualInstall({ packageName, binName, scope: opts.scope, runtime: opts.runtime });\n' +
@@ -79,12 +98,14 @@ function render(identity) {
     'module.exports = Object.freeze({\n' +
     '  packageName,\n' +
     '  // PACKAGE_NAME: back-compat alias for #516-era consumers. Baked here, so it\n' +
-    '  // survives the installed tree’s synthetic package.json (fixes the #378 undefined).\n' +
+    "  // survives the installed tree's synthetic package.json (fixes the #378 undefined).\n" +
     '  PACKAGE_NAME: packageName,\n' +
     '  binName,\n' +
     '  repoSlug,\n' +
     '  repoUrl,\n' +
     '  changelogRawUrl,\n' +
+    '  cacheSlug,\n' +
+    '  updateCacheFileName,\n' +
     '  manualInstallCommand,\n' +
     '});\n'
   );
@@ -94,11 +115,11 @@ function main() {
   const fs = require('node:fs');
   const path = require('node:path');
   const pkg = require(path.join(__dirname, '..', 'package.json'));
-  const out = path.join(__dirname, '..', 'get-shit-done', 'bin', 'lib', 'package-identity.cjs');
+  const out = path.join(__dirname, '..', 'gsd-core', 'bin', 'lib', 'package-identity.cjs');
   fs.writeFileSync(out, render(deriveIdentity(pkg)));
   process.stdout.write(`wrote ${path.relative(path.join(__dirname, '..'), out)}\n`);
 }
 
 if (require.main === module) main();
 
-module.exports = { deriveIdentity, parseRepoSlug, formatManualInstall, render, main };
+module.exports = { deriveIdentity, parseRepoSlug, slugifyPackageName, formatManualInstall, render, main };

package/scripts/lib/allowlist-ratchet.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+/**
+ * @file allowlist-ratchet.cjs
+ *
+ * Reusable "better than a count ratchet" primitives for CI guards.
+ *
+ * ## Motivation (issue #597)
+ *
+ * A count ratchet (`assert(offenders.length <= N)`) has a masking blind spot:
+ * fixing one offender and introducing a new one keeps the count constant, so a
+ * novel defect slips through green.  These helpers enforce on IDENTITY instead,
+ * making every individual offender visible and requiring monotonic progress
+ * toward zero.
+ *
+ * ## Design
+ *
+ * Both functions are pure (no I/O, no global state).  The `fail` callback is
+ * injected by the caller so the same logic can be used with `node:assert.fail`,
+ * a custom throw, or a message-collector in unit tests.
+ */
+
+/**
+ * Assert that `current` offenders are all within the known allowlist, and that
+ * every entry in the allowlist still offends (forcing the allowlist to shrink
+ * as defects are fixed).
+ *
+ * Fails when:
+ * - Any id in `current` is NOT in `known` → novel offender introduced.
+ * - Any id in `known` is NOT in `current` → stale allowlist entry must be
+ *   pruned so the guard ratchets toward zero (the ratchet-DOWN direction).
+ *
+ * ## Masking blind spot this prevents (issue #597)
+ *
+ * A count ratchet (`assert(count <= N)`) allows one offender to be silently
+ * replaced by another while the count stays at N.  By asserting on identity
+ * instead, every new offender is caught by name, and every fixed offender
+ * forces the allowlist to shrink.
+ *
+ * @param {object} opts
+ * @param {string}   opts.label      - Human-readable name for the guard (used
+ *                                     in failure messages).
+ * @param {Iterable<string>} opts.current - The offending ids found in the
+ *                                     current run.
+ * @param {Iterable<string>} opts.known   - The allowlisted ids (baseline).
+ * @param {function(string): void} opts.fail - Callback invoked with a
+ *                                     descriptive message on any violation.
+ *                                     Pass `require('node:assert').fail`, a
+ *                                     custom thrower, or a collector.  The
+ *                                     function is NOT imported here so callers
+ *                                     control the failure mode.
+ * @param {string}  [opts.pruneHint] - Optional hint appended to the stale-
+ *                                     entry failure message (e.g. the name of
+ *                                     the allowlist file to edit).
+ * @returns {{ novel: string[], stale: string[] }} Sorted arrays of novel ids
+ *   (in current but not known) and stale ids (in known but not current).
+ */
+function assertWithinAllowlist({ label, current, known, fail, pruneHint }) {
+  const currentSet = new Set(current);
+  const knownSet = new Set(known);
+
+  const novel = [...currentSet].filter((id) => !knownSet.has(id)).sort();
+  const stale = [...knownSet].filter((id) => !currentSet.has(id)).sort();
+
+  if (novel.length > 0) {
+    const list = novel.map((id) => `  - ${id}`).join('\n');
+    fail(
+      `[${label}] ${novel.length} NEW offender(s) introduced — fix at the source; do not just add to the allowlist.\n${list}`
+    );
+  }
+
+  if (stale.length > 0) {
+    const list = stale.map((id) => `  - ${id}`).join('\n');
+    const hint = pruneHint ? `\n(${pruneHint})` : '';
+    fail(
+      `[${label}] ${stale.length} allowlisted id(s) no longer offend and MUST be pruned so the guard ratchets toward zero.${hint}\n${list}`
+    );
+  }
+
+  return { novel, stale };
+}
+
+/**
+ * Assert that an artifact's measured maximum stays within a declared ceiling,
+ * and that the ceiling itself does not creep above the high-water mark (budgets
+ * may only decrease, not increase over time).
+ *
+ * Fails when:
+ * - `actualMax > ceiling`           → regression: artifact exceeds budget.
+ * - `ceiling - actualMax > grace`   → ceiling sits too far above the measured
+ *                                     value; tighten it toward `actualMax`.
+ *
+ * ## Masking blind spot this prevents (issue #597)
+ *
+ * A plain `assert(size <= ceiling)` with a ceiling set generously high allows
+ * the artifact to grow unchecked as long as it stays under the ceiling.  The
+ * `grace` band forces the ceiling to stay close to the high-water mark,
+ * ensuring that any upward creep is immediately visible.
+ *
+ * @param {object} opts
+ * @param {string}   opts.label     - Human-readable name for the guard (used
+ *                                    in failure messages).
+ * @param {number}   opts.actualMax - The measured value (e.g. bundle size in
+ *                                    bytes, line count).
+ * @param {number}   opts.ceiling   - The declared budget ceiling.
+ * @param {number}   opts.grace     - Maximum allowed slack (`ceiling -
+ *                                    actualMax`) before the ceiling is
+ *                                    considered too loose.
+ * @param {function(string): void} opts.fail - Callback invoked with a
+ *                                    descriptive message on any violation.
+ * @returns {{ ok: boolean, slack: number }} Whether both checks passed and the
+ *   current slack value.
+ */
+function assertTightCeiling({ label, actualMax, ceiling, grace, fail }) {
+  const slack = ceiling - actualMax;
+  let ok = true;
+
+  if (actualMax > ceiling) {
+    ok = false;
+    fail(
+      `[${label}] Regression: artifact value ${actualMax} exceeds budget ceiling ${ceiling}. ` +
+        `Raise the ceiling to at most ${actualMax} only if the increase is justified.`
+    );
+  } else if (slack > grace) {
+    ok = false;
+    fail(
+      `[${label}] Ceiling ${ceiling} sits too far above the high-water mark ${actualMax} ` +
+        `(slack ${slack} > grace ${grace}). Tighten the ceiling toward ${actualMax}. ` +
+        `Budgets may only decrease.`
+    );
+  }
+
+  return { ok, slack };
+}
+
+module.exports = { assertWithinAllowlist, assertTightCeiling };

package/scripts/lint-command-contract.cjs

@@ -20,7 +20,7 @@ const path = require('path');
 
 const ROOT          = path.join(__dirname, '..');
 const COMMANDS_DIR  = path.join(ROOT, 'commands', 'gsd');
-const GSD_ROOT      = path.join(ROOT, 'get-shit-done');
+const GSD_ROOT      = path.join(ROOT, 'gsd-core');
 
 const {
   CANONICAL_TOOLS,

package/scripts/lint-legacy-dir-name.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * lint-legacy-dir-name.cjs
+ *
+ * Prevents accidental re-introduction of the bare legacy directory token
+ * `get-shit-done` now that the package has been renamed to `gsd-core` (#604).
+ *
+ * The forbidden token is constructed by splitting across the concat operator
+ * so this guard script cannot flag itself:
+ *   const FORBIDDEN = 'get-shit' + '-done';
+ *
+ * Regex: FORBIDDEN + '(?!-\\w)' — allows any hyphenated slug variant
+ *   (get-shit-done-OLD, get-shit-done-classic, get-shit-done-cli, etc.)
+ *   while forbidding the bare word boundary that would indicate a stale
+ *   directory reference. This is the exact pattern that would appear in a
+ *   path like `~/.claude/get-shit-done/` or `'get-shit-done'` in code.
+ *
+ * Allowlist:
+ *   - CHANGELOG.md (historical record; reviewed manually)
+ *   - .changeset/ (ephemeral release-note fragments; consumed into CHANGELOG on
+ *     release — like CHANGELOG, not swept by rename PRs)
+ *   - Translated READMEs: README.ja-JP.md, README.ko-KR.md, README.pt-BR.md, README.zh-CN.md
+ *   - Locale-specific docs dirs: docs/ja-JP/, docs/ko-KR/, docs/pt-BR/, docs/zh-CN/
+ *   - Lines containing the marker `gsd-allow-legacy-name` (intentional uses)
+ *   - Binary files (detected by NUL byte scan)
+ *   - This guard script itself (by path)
+ *
+ * Exit 0 if no violations; exit 1 if any are found (with stderr diagnostics).
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Constructed with split to avoid self-match when this script is scanned.
+const FORBIDDEN = 'get-shit' + '-done';
+const FORBIDDEN_RE = new RegExp(FORBIDDEN + '(?!-\\w)', 'gi');
+
+const ALLOW_MARKER = 'gsd-allow-legacy-name';
+const SELF_PATH = path.resolve(__filename);
+// GSD_LINT_LEGACY_REPO_ROOT is used by tests to redirect the guard to a
+// temporary fixture git repo without touching the real working tree.
+const REPO_ROOT = process.env.GSD_LINT_LEGACY_REPO_ROOT
+  ? path.resolve(process.env.GSD_LINT_LEGACY_REPO_ROOT)
+  : path.resolve(__dirname, '..');
+
+const ALLOWLIST_FILES = new Set([
+  'CHANGELOG.md',
+  'README.ja-JP.md',
+  'README.ko-KR.md',
+  'README.pt-BR.md',
+  'README.zh-CN.md',
+]);
+
+const ALLOWLIST_DIR_PREFIXES = [
+  // Pending changeset fragments are ephemeral release-note stubs consumed into
+  // CHANGELOG on release — like CHANGELOG itself, they should not be swept by
+  // rename PRs and may legitimately contain the legacy token in historical prose.
+  '.changeset/',
+  'docs/ja-JP/',
+  'docs/ko-KR/',
+  'docs/pt-BR/',
+  'docs/zh-CN/',
+];
+
+function isAllowlisted(relPath) {
+  if (ALLOWLIST_FILES.has(relPath)) return true;
+  for (const prefix of ALLOWLIST_DIR_PREFIXES) {
+    if (relPath.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+function isBinary(fullPath) {
+  // Read a small chunk and check for NUL bytes.
+  let fd;
+  try {
+    fd = fs.openSync(fullPath, 'r');
+    const buf = Buffer.allocUnsafe(512);
+    const bytesRead = fs.readSync(fd, buf, 0, 512, 0);
+    return buf.subarray(0, bytesRead).includes(0);
+  } catch {
+    return false;
+  } finally {
+    if (fd != null) {
+      try { fs.closeSync(fd); } catch { /* best-effort */ }
+    }
+  }
+}
+
+// Enumerate tracked files via git ls-files so only committed/staged source is checked.
+let trackedFiles;
+try {
+  trackedFiles = execFileSync('git', ['ls-files'], { cwd: REPO_ROOT, encoding: 'utf8' })
+    .split('\n')
+    .map((f) => f.trim())
+    .filter(Boolean);
+} catch (err) {
+  process.stderr.write('ERROR lint-legacy-dir-name: git ls-files failed: ' + err.message + '\n');
+  process.exit(1);
+}
+
+const violations = [];
+
+for (const relPath of trackedFiles) {
+  if (isAllowlisted(relPath)) continue;
+
+  const fullPath = path.join(REPO_ROOT, relPath);
+
+  // Skip this guard script itself.
+  if (path.resolve(fullPath) === SELF_PATH) continue;
+
+  if (isBinary(fullPath)) continue;
+
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, 'utf8');
+  } catch {
+    // Unreadable files (permissions, etc.) — skip silently.
+    continue;
+  }
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Skip lines that carry the explicit allow marker.
+    if (line.includes(ALLOW_MARKER)) continue;
+
+    FORBIDDEN_RE.lastIndex = 0;
+    let match;
+    while ((match = FORBIDDEN_RE.exec(line)) !== null) {
+      violations.push({
+        file: relPath,
+        line: i + 1,
+        col: match.index + 1,
+        text: match[0],
+      });
+    }
+  }
+}
+
+if (violations.length === 0) {
+  process.stdout.write('ok lint-legacy-dir-name: ' + trackedFiles.length + ' tracked file(s) checked, 0 violations\n');
+  process.exit(0);
+}
+
+process.stderr.write('\nERROR lint-legacy-dir-name: ' + violations.length + ' violation(s) found\n\n');
+for (const v of violations) {
+  process.stderr.write('  ' + v.file + ':' + v.line + ':' + v.col + ' — ' + JSON.stringify(v.text) + '\n');
+}
+process.stderr.write('\n');
+process.stderr.write('Fix: rename to gsd-core, or add `gsd-allow-legacy-name` marker on the line if the\n');
+process.stderr.write('      use is intentional (migration modules, tests, guard, changeset).\n\n');
+process.exit(1);

package/scripts/lint-package-identity-drift.cjs

@@ -4,7 +4,7 @@
 /**
  * Drift-guard lint for the Package Identity seam (issue #498).
  *
- * The seam (`get-shit-done/bin/lib/package-identity.cjs`, derived from
+ * The seam (`get-shit-done/bin/lib/package-identity.cjs`, derived from // gsd-allow-legacy-name
  * package.json) is the single source of GSD's published coordinates. Many
  * runtime surfaces still carry a literal copy of those coordinates because
  * they cannot `require()` the seam at runtime: the bash launcher snippet (and
@@ -19,7 +19,7 @@
  * literal is reported until updated. That is what turns a repoint into a
  * one-line change with mechanical enforcement.
  *
- * Scope: the runtime/code surface (bin/, hooks/, scripts/, get-shit-done/).
+ * Scope: the runtime/code surface (bin/, hooks/, scripts/, get-shit-done/). // gsd-allow-legacy-name
  * Pure-prose docs and localized READMEs are intentionally out of scope.
  */
 
@@ -27,11 +27,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 // A GSD package coordinate: a scoped npm name whose package part contains
-// "get-shit-done" (so @opengsd/gsd-sdk and unrelated scopes never match).
-const PACKAGE_RE = /@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]*get-shit-done[A-Za-z0-9._-]*/g;
+// "get-shit-done" (so @opengsd/gsd-sdk and unrelated scopes never match). // gsd-allow-legacy-name
+const PACKAGE_RE = /@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]*get-shit-done[A-Za-z0-9._-]*/g; // gsd-allow-legacy-name
 // A GSD repo slug, only inside a GitHub URL context so it never overlaps the
 // scoped package literal above. The `.git` suffix is trimmed before compare.
-const SLUG_RE = /(?:github\.com[/:]|raw\.githubusercontent\.com\/)([A-Za-z0-9._-]+\/[A-Za-z0-9._-]*get-shit-done[A-Za-z0-9._-]*)/g;
+const SLUG_RE = /(?:github\.com[/:]|raw\.githubusercontent\.com\/)([A-Za-z0-9._-]+\/[A-Za-z0-9._-]*get-shit-done[A-Za-z0-9._-]*)/g; // gsd-allow-legacy-name
 
 function lineOf(text, index) {
   let line = 1;
@@ -62,14 +62,14 @@ function findCoordinateDrift(text, { packageName, repoSlug }) {
 }
 
 // Directories scanned, relative to repo root.
-const SCAN_DIRS = ['bin', 'hooks', 'scripts', 'get-shit-done'];
+const SCAN_DIRS = ['bin', 'hooks', 'scripts', 'gsd-core'];
 const SCAN_EXT = new Set(['.js', '.cjs', '.sh', '.md']);
 // Files exempt because they ARE the source of truth / the tooling that defines
 // the coordinate patterns. The generated seam holds the correct value by
 // construction; the generator and this lint carry regex/templates, not stray
 // literals.
 const EXEMPT = new Set([
-  path.join('get-shit-done', 'bin', 'lib', 'package-identity.cjs'),
+  path.join('gsd-core', 'bin', 'lib', 'package-identity.cjs'),
   path.join('scripts', 'generate-package-identity.cjs'),
   path.join('scripts', 'lint-package-identity-drift.cjs'),
 ]);
@@ -98,7 +98,7 @@ function walk(dir, acc) {
  * annotated with the repo-relative file path.
  */
 function scanRepo(root) {
-  const seam = require(path.join(root, 'get-shit-done', 'bin', 'lib', 'package-identity.cjs'));
+  const seam = require(path.join(root, 'gsd-core', 'bin', 'lib', 'package-identity.cjs'));
   const expected = { packageName: seam.packageName, repoSlug: seam.repoSlug };
   const violations = [];
   for (const dir of SCAN_DIRS) {