@opengsd/gsd-core 1.15.0 → 1.16.0

package/scripts/lib/vendor-bundle.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { isBuiltin } = require('node:module');
+const { buildSync } = require('esbuild');
+
+/** Rebuild locked upstream code without edits; installed trees need no node_modules. */
+function buildVendorBundle(root, entry) {
+  const result = buildSync({
+    absWorkingDir: root,
+    entryPoints: [entry],
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    target: 'node24',
+    write: false,
+    metafile: true,
+    legalComments: 'inline',
+    banner: { js: '// Generated from locked npm dependencies by lint-vendored-deps.cjs --fix. Do not edit.' },
+  });
+  for (const output of Object.values(result.metafile.outputs)) {
+    for (const imported of output.imports) {
+      if (imported.external && !isBuiltin(imported.path)) {
+        throw new Error(`Vendor bundle has an external dependency: ${imported.path}`);
+      }
+    }
+  }
+  const packages = new Map();
+  for (const input of Object.keys(result.metafile.inputs)) {
+    let dir = path.dirname(path.resolve(root, input));
+    while (dir !== root && dir !== path.dirname(dir)) {
+      const manifest = path.join(dir, 'package.json');
+      if (fs.existsSync(manifest)) {
+        const pkg = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+        if (pkg.name && pkg.version) {
+          const licenses = fs.readdirSync(dir).filter((name) => /^(licen[sc]e|copying|notice)(\.|$)/i.test(name)).sort();
+          // saxes 6.0.0 omits its LICENSE from npm; preserve the exact tagged
+          // upstream file (https://github.com/lddubeau/saxes/blob/v6.0.0/LICENSE).
+          const supplemental = path.join(__dirname, 'vendor-licenses', `${pkg.name}-${pkg.version}.txt`);
+          if (licenses.length === 0 && !fs.existsSync(supplemental)) throw new Error(`Missing upstream license: ${pkg.name}`);
+          packages.set(`${pkg.name}@${pkg.version}`, [
+            `${pkg.name}@${pkg.version} (package metadata: ${pkg.license})`,
+            ...licenses.map((name) => `${name}:\n${fs.readFileSync(path.join(dir, name), 'utf8')}`),
+            ...(licenses.length === 0 ? [fs.readFileSync(supplemental, 'utf8')] : []),
+          ].join('\n\n'));
+          break;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+  }
+  return {
+    code: result.outputFiles[0].contents,
+    notices: Buffer.from([...packages.keys()].sort().map((name) => packages.get(name)).join('\n\n---\n\n') + '\n'),
+  };
+}
+
+module.exports = { buildVendorBundle };

package/scripts/lib/vendor-licenses/saxes-6.0.0.txt

@@ -0,0 +1,64 @@
+The ISC License
+
+Copyright (c) Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+====
+
+The following license is the one that governed sax, from which saxes
+was forked. Isaac Schlueter is not *directly* involved with saxes so
+don't go bugging him for saxes issues.
+
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+====
+
+`String.fromCodePoint` by Mathias Bynens is no longer used, but it can
+still be found in old commits. It was once used according to terms of
+MIT License, as follows:
+
+    Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/scripts/lint-allow-test-rule-refs.effective-ceiling.json

@@ -1,4 +1,4 @@
 {
-  "maxSites": 84,
+  "maxSites": 64,
   "grace": 2
 }

package/scripts/lint-allow-test-rule-refs.unverified-ceiling.json

@@ -1,3 +1,3 @@
 {
-  "maxFiles": 283
+  "maxFiles": 284
 }

package/scripts/lint-completion-predicate-drift.cjs

@@ -805,17 +805,17 @@ const OWNER_FILE = path.join('src', 'verification.cts');
 //     one (the owner consumes plan counts, never the reverse). Left as its
 //     own, differently-scoped answer, per design's "Rejected" list item 1.
 //
-//   - `buildWorkstreamInventory` (src/workstream-inventory-builder.cts) — a
-//     PURE, I/O-free projection (see the module's own header) over
-//     PRE-COLLECTED `planCount`/`summaryCount`/`verificationStatus` inputs.
-//     `summariesMeetPlans = summaryCount >= planCount && planCount > 0`
-//     answers "are all plans summarized?" (combined with the caller-supplied
-//     verification verdict for its own `status` projection) — it cannot call
+//   - `buildWorkstreamInventory` (src/workstream-inventory-builder.cts) —
+//     formerly exempted here (a PURE, I/O-free projection that hand-rolled
+//     `summaryCount >= planCount && planCount > 0` locally, unable to call
 //     the I/O-bound `isPhaseComplete` without breaking its "No I/O. No
-//     async." contract, and re-plumbing its callers to pass a pre-computed
-//     `complete` boolean instead of raw counts is a larger architectural
-//     change than this phase's declared 6 call sites. Declared deviation —
-//     see the Phase 4 migration PR for the full reasoning.
+//     async." contract). #5060 (Phase Status Module, epic #5056) gave this
+//     exact "pure function over pre-collected facts" shape a real owner —
+//     `phaseStatusFromFacts` (`src/phase-status.cts`) — which is itself
+//     import-free at load time and does no I/O, so this function now calls
+//     it instead of re-deriving the comparison locally. The local textual
+//     shapes this guard matches are gone; the exemption entry was removed
+//     rather than left dead.
 //
 //   - `buildPhaseCompletionProjection` (src/init.cts) — MIGRATED onto
 //     `isPhaseComplete` for `phase_complete`/`verification_status` (shape
@@ -832,17 +832,17 @@ const OWNER_FILE = path.join('src', 'verification.cts');
 //
 // SHAPE (d) reuses this exact map (`findScanPhasePlansCompletedReadDrift`
 // takes the same `exemptFunctions` set every other shape's finder does). The
-// four entries above were entered for shapes (a)/(b)/(c); of them, only
+// entries above were entered for shapes (a)/(b)/(c); of them, only
 // `scanPhasePlans` (src/plan-scan.cts) also legitimately reads its OWN
 // `completed` field for shape (d)'s purposes (building the return value it
 // itself defines — not a call-then-read of another `scanPhasePlans(`
-// invocation). `isPhaseComplete`, `buildWorkstreamInventory`, and
-// `buildPhaseCompletionProjection` do not read `.completed` off a
-// `scanPhasePlans(` call result at all (verified by direct inspection of
-// each function's body as of this guard's shape-(d) addition — they consume
-// `planCount`/`summaryCount`/`summaryFiles`, never `.completed`), so their
-// presence in this map exempts nothing NEW for shape (d); they are listed
-// here only because the map is shared. As of this addition, a whole-repo
+// invocation). `isPhaseComplete` and `buildPhaseCompletionProjection` do not
+// read `.completed` off a `scanPhasePlans(` call result at all (verified by
+// direct inspection of each function's body as of this guard's shape-(d)
+// addition — they consume `planCount`/`summaryCount`/`summaryFiles`, never
+// `.completed`), so their presence in this map exempts nothing NEW for shape
+// (d); they are listed here only because the map is shared. As of this
+// addition, a whole-repo
 // scan found ZERO live shape-(d) sites needing a fresh exemption entry — the
 // one real instance this shape exists to catch (`cmdStateSync`,
 // src/state.cts) was fixed by routing through `isPhaseComplete` rather than
@@ -852,7 +852,6 @@ const OWNER_FILE = path.join('src', 'verification.cts');
 const FUNCTION_SCOPED_EXEMPTIONS = new Map([
   [OWNER_FILE, new Set(['isPhaseComplete'])],
   [path.join('src', 'plan-scan.cts'), new Set(['scanPhasePlans'])],
-  [path.join('src', 'workstream-inventory-builder.cts'), new Set(['buildWorkstreamInventory'])],
   [path.join('src', 'init.cts'), new Set(['buildPhaseCompletionProjection'])],
 ]);
 

package/scripts/lint-descriptions.cjs

@@ -16,6 +16,9 @@
 const fs = require('fs');
 const path = require('path');
 const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+// The one frontmatter fence owner (src/frontmatter-fence.cts, built by build:lib).
+// This dev-time script runs after the build (`npm run lint:descriptions`, the tests).
+const { locateFrontmatterFence } = require('../gsd-core/bin/lib/frontmatter-fence.cjs');
 
 const MAX_LENGTH = 100;
 const COMMANDS_DIR = path.join(__dirname, '..', 'commands', 'gsd');
@@ -25,9 +28,10 @@ const COMMANDS_DIR = path.join(__dirname, '..', 'commands', 'gsd');
  * Returns null if no description is found.
  */
 function parseDescription(content) {
-  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch) return null;
-  const fm = fmMatch[1];
+  // The block is the one the one fence owner finds (found while implementing #5105).
+  const fence = locateFrontmatterFence(content);
+  if (!fence || !fence.closed) return null;
+  const fm = content.slice(fence.openEnd, fence.bodyEnd);
 
   const quoted = fm.match(/^description:\s+"((?:[^"\\]|\\.)*)"\s*$/m);
   if (quoted) return quoted[1];

package/scripts/lint-docs-guard-registration.exempt-baseline.cjs

@@ -88,6 +88,7 @@ const DOCS_GUARD_EXEMPT_BASELINE = [
   'security-prompt-injection.security.test.cjs',
   'shipped-reference-cites.test.cjs',
   'state.test.cjs',
+  'verification-status.test.cjs',
   'worktree-safety.test.cjs',
 ];
 
@@ -236,6 +237,15 @@ const DOCS_GUARD_EXEMPT_DOCS_PATHS = {
   // #4186: the record-session usage-contract test cites the documented
   // signature in docs/CLI-TOOLS.md in its explanatory comment.
   'state.test.cjs': ['docs/CLI-TOOLS.md', 'docs/CONFIGURATION.md', 'docs/reference/state-md.md'],
+  // #5095: 'docs/VERIFICATION.md' is a tmpdir fixture basename (proving the
+  // report-shaped filter matches basename, not full path); 'docs/planning'
+  // and its two nested PLAN/SUMMARY children are an in-repo `.planning ->
+  // docs/planning` symlink-alias fixture. All are WRITTEN into a throwaway
+  // mkdtemp/createTempGitProject tree; none reads real shipped docs/ content.
+  'verification-status.test.cjs': [
+    'docs/VERIFICATION.md', 'docs/planning', 'docs/planning/phases',
+    'docs/planning/phases/01-foo/01-01-PLAN.md', 'docs/planning/phases/01-foo/01-01-SUMMARY.md',
+  ],
   'worktree-safety.test.cjs': ['docs/SUMMARY.md'],
 };
 

package/scripts/lint-eslint-glob-coverage.allowlist.json

@@ -11,6 +11,14 @@
     "path": "src/vendor/js-yaml.d.cts",
     "reason": "Vendored third-party type declaration (ADR-3473 §8.1, #3881): a .d.cts carries no executable code, so no ESLint rule is meaningful; the vendored js-yaml .cjs it describes is globally ignored as verbatim upstream output (gsd-core/bin/lib/vendor/**). Freshness is enforced by scripts/lint-vendored-deps.cjs, not by lint rules — same precedent as src/vendor/re2js.d.cts above."
   },
+  {
+    "path": "src/vendor/saxes.d.cts",
+    "reason": "Upstream type forwarding for the vendored saxes bundle (#4692): declaration-only export with no executable code. scripts/lint-vendored-deps.cjs enforces the exact forwarding declaration; TypeScript checks consumers against upstream types."
+  },
+  {
+    "path": "src/vendor/tap-parser.d.cts",
+    "reason": "Upstream type forwarding for the vendored tap-parser bundle (#4692): declaration-only export with no executable code. scripts/lint-vendored-deps.cjs enforces the exact forwarding declaration; TypeScript checks consumers against upstream types."
+  },
   {
     "path": "tests/fixtures/brand-typing/bad-calibrated-as-sample-basis.cts",
     "reason": "Deliberate MUST-NOT-COMPILE type-error fixture (#3059): type-aware linting would fail by design; it exists to prove the compiler rejects it."
@@ -34,5 +42,17 @@
   {
     "path": "tests/fixtures/brand-typing/ok-correct-composition.cts",
     "reason": "Positive-control counterpart to the bad-* must-not-compile fixtures (#3059); kept in the same exemption so the pair stays together."
+  },
+  {
+    "path": "tests/fixtures/gate-evidence-typing/bad-pass-from-unreadable.cts",
+    "reason": "Deliberate MUST-NOT-COMPILE type-error fixture (#5170): the unreadable-evidence branding makes a passing outcome from unreadable evidence a compile error, and tests/gate-evidence.test.cjs asserts tsc rejects it; type-aware linting would fail by design."
+  },
+  {
+    "path": "tests/fixtures/gate-evidence-typing/bad-unbranded-unreadable.cts",
+    "reason": "Deliberate MUST-NOT-COMPILE type-error fixture (#5170): the unreadable-evidence branding makes a passing outcome from unreadable evidence a compile error, and tests/gate-evidence.test.cjs asserts tsc rejects it; type-aware linting would fail by design."
+  },
+  {
+    "path": "tests/fixtures/gate-evidence-typing/ok-unreadable-arm.cts",
+    "reason": "Positive-control counterpart to the gate-evidence-typing bad-* must-not-compile fixtures (#5170): tsc compiles it clean; kept in the same exemption so the pair stays together."
   }
 ]

package/scripts/lint-frontmatter-fence-drift.cjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Anti-divergence drift guard for the FRONTMATTER FENCE seam (found while
+ * implementing #5105; ADR-5057 one-owner rule).
+ *
+ * `src/frontmatter-fence.cts`'s `locateFrontmatterFence` is the SINGLE owner of
+ * "where does a document's frontmatter block start and stop" — the BOM, the
+ * byte-0 opening fence, the whole-line closing fence, an adjacent empty block,
+ * the lenient `----` closer. Before it existed that answer was re-derived in
+ * some thirty places across `src/` (regexes like `/^---\r?\n([\s\S]*?)\r?\n---/`,
+ * `indexOf('\n---', 4)`, `lines[0].trim() === '---'`), and the copies disagreed
+ * on a BOM, CRLF, an adjacent empty block, `----`, `--- x`, a `---` inside a
+ * value and leading whitespace. This guard keeps a new copy from appearing.
+ *
+ * Mechanism: the shared `scripts/lib/drift-scan.cjs` tree walk and regex-literal
+ * tokenizer (ADR-3180 Decision 4), scanning the WHOLE `src/` and `hooks/` trees
+ * (the hooks load the built `bin/lib` behind `ensureRuntimeBuild`), the dev-time
+ * `scripts/` and `eslint-rules/` trees (every one of them that runs after
+ * `build:lib` requires the owner from `gsd-core/bin/lib/frontmatter-fence.cjs`),
+ * the two hand-written entry points that load `bin/lib` (`bin/install.js`,
+ * `gsd-core/bin/gsd-tools.cjs`), and the two native plugin adapters
+ * (`.opencode/plugins/gsd-core.js`, `.kilo/plugins/gsd-core.js`), with
+ * FUNCTION-SCOPED exemptions carrying a written reason — never a bare file
+ * allowlist — exactly as `lint-milestone-window-drift.cjs` does.
+ *
+ * KEPT COPIES (found while implementing #5105). A file that must run where the
+ * built owner may not exist keeps a self-contained copy of `locateFrontmatterFence`,
+ * and only that one function is allowlisted: `scripts/changeset/parse.cjs` (the
+ * `changeset-lint` CI job runs it with no `npm ci` and no build) and the two plugin
+ * adapters (a package/git-spec tree may carry no built `bin/lib`). Each copy is
+ * pinned to the owner by tests/frontmatter-fence.test.cjs ("kept frontmatter fence
+ * copies agree with the owner") over a fixture corpus and a property test.
+ *
+ * DETECTORS. Three files carry a regex that recognizes a fence idiom in OTHER
+ * text — this guard itself, `lint-frontmatter-scalar-broad-grep.cjs` (workflow
+ * shell snippets) and the `no-crlf-fragile-split` ESLint rule (regex literals in
+ * source). None of them locates a frontmatter block; each is exempt only for its
+ * exact fragment (`DETECTOR_EXEMPTIONS`), so any other fence code in the same
+ * file is still flagged.
+ *
+ * A line (comment text stripped) is a fence re-derivation when it carries:
+ *   (a) a regex literal whose text contains `---` (`/^---/`, `/\n---/`,
+ *       `/(\r?\n)---$/`), or
+ *   (b) `new RegExp(` together with a string/template literal containing `---`, or
+ *   (c) a fence-shaped string literal — `'---'`, `'\n---'`, `'---\n'`,
+ *       `'---\r\n'`, `'\r\n---'` — that is the direct argument of
+ *       `.startsWith(`/`.endsWith(`/`.indexOf(`/`.lastIndexOf(`/`.split(`, or an
+ *       operand of `===`/`!==`/`==`/`!=`, or (only when it carries a line
+ *       ending) the argument of `.includes(`.
+ * A template literal that BUILDS a block (`` `---\n${yaml}\n---` ``) or an array
+ * of fence lines to join is a writer emitting a fence, not a reader locating
+ * one, and is not flagged.
+ *
+ * KNOWN, ACCEPTED limits of a per-line textual scan (the sibling guards'
+ * tradeoff): a derivation split across lines, or routed through a variable
+ * holding the `---` literal, is left to code review and to the consumer-parity
+ * tests in `tests/frontmatter-fence.test.cjs`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const driftScan = require('./lib/drift-scan.cjs');
+const { readRegexLiteralAt, MAX_REGEX_LITERAL_LEN, sanitizeForReport, scanTree } = driftScan;
+
+// Authored TypeScript source (the generated bin/lib/*.cjs mirror it) and the runtime hooks
+// (`hooks/dist`, their build output, is skipped by the shared walker), plus the two hand-written
+// entry points that load bin/lib and so can — and must — read the owner too.
+const SCAN_TREES = [
+  { dirs: ['src'], ext: new Set(['.cts', '.ts', '.mts']) },
+  { dirs: ['hooks'], ext: new Set(['.js', '.cjs']) },
+  { dirs: ['scripts', 'eslint-rules'], ext: new Set(['.js', '.cjs', '.mjs']) },
+];
+const SCAN_FILES = [
+  path.join('bin', 'install.js'),
+  path.join('gsd-core', 'bin', 'gsd-tools.cjs'),
+  path.join('.opencode', 'plugins', 'gsd-core.js'),
+  path.join('.kilo', 'plugins', 'gsd-core.js'),
+];
+
+const OWNER_FILE = path.join('src', 'frontmatter-fence.cts');
+
+// Code outside any top-level function (a module-scope constant) is keyed as this.
+const TOP_LEVEL = '<top-level>';
+
+// FUNCTION-SCOPED exemptions, each with its reason:
+//   - frontmatter-fence.cts `locateFrontmatterFence`: this IS the owner. Its
+//     module-scope fence constants (`CLOSING_FENCE_LINE`, `LENIENT_CLOSING_FENCE_LINE`)
+//     sit OUTSIDE this function, at TOP_LEVEL, and are exempted by exact fragment
+//     in DETECTOR_EXEMPTIONS below instead — a blanket TOP_LEVEL pass here would
+//     let any new top-level helper in this file go unscanned (#5105 fix).
+//   - phase.cts `phaseEntryInsertOffset`: its `lastIndexOf('\n---')` finds the
+//     ROADMAP's trailing section SEPARATOR (a thematic break closing the phase
+//     list) so a new phase entry is appended before it — it never asks where a
+//     frontmatter block is.
+//   - shell-command-projection.cts `_normalizeMd`: `prevTrimmed !== '---'` is
+//     the Markdown normalizer's "no blank line after a thematic break" rule,
+//     applied line by line to BODY text; that normalizer's frontmatter skip
+//     (`leadingFrontmatterLineCount`) reads the owner.
+//   - scripts/changeset/parse.cjs `locateFrontmatterFence`: a kept copy of the
+//     owner (#5105) — the `changeset-lint` job in changeset-required.yml runs it
+//     with no `npm ci` and no `build:lib`. Pinned to the owner by the parity test
+//     tests/frontmatter-fence.test.cjs "kept frontmatter fence copies agree with the owner".
+//   - .opencode/plugins/gsd-core.js and .kilo/plugins/gsd-core.js
+//     `locateFrontmatterFence`: kept copies of the owner (#5105) — the plugin loads
+//     from a package/git-spec tree that may carry no built bin/lib. Pinned to the
+//     owner by the same parity test.
+const FUNCTION_SCOPED_EXEMPTIONS = new Map([
+  [OWNER_FILE, new Set(['locateFrontmatterFence'])],
+  [path.join('src', 'phase.cts'), new Set(['phaseEntryInsertOffset'])],
+  [path.join('src', 'shell-command-projection.cts'), new Set(['_normalizeMd'])],
+  [path.join('scripts', 'changeset', 'parse.cjs'), new Set(['locateFrontmatterFence'])],
+  [path.join('.opencode', 'plugins', 'gsd-core.js'), new Set(['locateFrontmatterFence'])],
+  [path.join('.kilo', 'plugins', 'gsd-core.js'), new Set(['locateFrontmatterFence'])],
+]);
+
+// FRAGMENT-SCOPED exemptions for DETECTORS (#5105), each pinned to the exact
+// reported fragment (the literal's source text) — a regex that recognizes a fence
+// idiom in other text, never one that locates a frontmatter block:
+//   - this guard's own fence-literal matcher (`FENCE_LITERAL_CONTENT_RE`);
+//   - lint-frontmatter-scalar-broad-grep.cjs `FRONTMATTER_SCOPE_RE`, which finds a
+//     `^---`-scoped extraction in a workflow's shell snippet;
+//   - the no-crlf-fragile-split ESLint rule's `^---` probe, which classifies a
+//     regex literal in linted source as frontmatter-shaped.
+const DETECTOR_EXEMPTIONS = new Map([
+  [path.join('scripts', 'lint-frontmatter-fence-drift.cjs'), new Set(['/^(?:\\\\r)?(?:\\\\n)?---(?:\\\\r)?(?:\\\\n)?$/'])],
+  [path.join('scripts', 'lint-frontmatter-scalar-broad-grep.cjs'), new Set(['/\\^---[\\s\\S]{0,300}?---/'])],
+  [path.join('eslint-rules', 'no-crlf-fragile-split.cjs'), new Set(['/\\^---/'])],
+  // The owner's own module-scope fence-literal constants (#5105 fix): these ARE
+  // the canonical closing-fence patterns, not a re-derivation — exempted by their
+  // exact fragment rather than by a blanket TOP_LEVEL pass, so a NEW top-level
+  // helper in this file (one that merely happens to sit outside a function) is
+  // still caught.
+  [OWNER_FILE, new Set(['/^---[ \\t]*$/', '/^-{4,}[ \\t]*$/'])],
+]);
+
+// Only a column-0 top-level `function` declaration updates the current-function
+// tracker (mirrors lint-milestone-window-drift.cjs); ANY OTHER non-blank,
+// non-`}` column-0 line — a `const`, a `module.exports =`, an `export const`
+// arrow, anything — resets it to TOP_LEVEL. (#5105 fix: the previous version
+// only reset on a fixed keyword list, so a top-level statement it didn't
+// recognize — e.g. `module.exports = { ... }` — silently inherited the LAST
+// exempted function's name and went unscanned.)
+const TOP_LEVEL_FUNCTION_RE = /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)\s*\(/;
+const COLUMN_ZERO_RESET_RE = /^[^\s}]/;
+
+const NEW_REGEXP_RE = /new\s+RegExp\s*\(/;
+
+// A fence-shaped string literal's CONTENT (source text between the quotes):
+// `---`, optionally preceded by `\n`/`\r\n` and optionally followed by `\n`/`\r\n`.
+const FENCE_LITERAL_CONTENT_RE = /^(?:\\r)?(?:\\n)?---(?:\\r)?(?:\\n)?$/;
+
+const SEARCH_CALL_BEFORE_RE = /\.(startsWith|endsWith|indexOf|lastIndexOf|split|includes)\(\s*$/;
+const COMPARE_BEFORE_RE = /[!=]==?\s*$/;
+const COMPARE_AFTER_RE = /^\s*[!=]==?/;
+
+/**
+ * Read the quoted or backtick-delimited string literal starting at `line[start]`.
+ * Returns `{ text, end }` (delimiters included) or null. Same single-pass,
+ * escape-aware, bounded style as the shared `readRegexLiteralAt`.
+ */
+function readStringLiteralAt(line, start) {
+  const quote = line[start];
+  if (quote !== "'" && quote !== '"' && quote !== '`') return null;
+  const limit = Math.min(line.length, start + MAX_REGEX_LITERAL_LEN);
+  for (let i = start + 1; i < limit; i++) {
+    const ch = line[i];
+    if (ch === '\\') {
+      i++;
+      continue;
+    }
+    if (ch === '\r' || ch === '\n') return null;
+    if (ch === quote) return { text: line.slice(start, i + 1), end: i + 1 };
+  }
+  return null;
+}
+
+/**
+ * Strip comment text from a line (whole-line `*`, `/*`, `//`, and a trailing
+ * `//`), as the sibling guards do — prose about a fence is not a fence.
+ */
+function stripComments(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith('*') || trimmed.startsWith('/*') || trimmed.startsWith('//')) return '';
+  const idx = line.indexOf('//');
+  return idx === -1 ? line : line.slice(0, idx);
+}
+
+/** Every regex and string literal on `code`, in order, with its kind and span. */
+function literalsOf(code) {
+  const out = [];
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    let literal = null;
+    let kind = null;
+    if (ch === '/' && code[i + 1] !== '/' && code[i + 1] !== '*') {
+      literal = readRegexLiteralAt(code, i);
+      kind = 'regex';
+    } else if (ch === "'" || ch === '"' || ch === '`') {
+      literal = readStringLiteralAt(code, i);
+      kind = 'string';
+    }
+    if (!literal) continue;
+    out.push({ kind, text: literal.text, start: i, end: literal.end });
+    i = literal.end - 1;
+  }
+  return out;
+}
+
+/** The fence re-derivation fragment on a comment-stripped line, or null. */
+function fenceFragment(code) {
+  const literals = literalsOf(code);
+  const hasNewRegExp = NEW_REGEXP_RE.test(code);
+  for (const lit of literals) {
+    if (lit.kind === 'regex') {
+      if (lit.text.includes('---')) return lit.text;
+      continue;
+    }
+    const content = lit.text.slice(1, -1);
+    if (hasNewRegExp && content.includes('---')) return lit.text;
+    if (!FENCE_LITERAL_CONTENT_RE.test(content)) continue;
+    const before = code.slice(0, lit.start);
+    const after = code.slice(lit.end);
+    const call = SEARCH_CALL_BEFORE_RE.exec(before);
+    if (call && (call[1] !== 'includes' || content.includes('\\n'))) return lit.text;
+    if (COMPARE_BEFORE_RE.test(before) || COMPARE_AFTER_RE.test(after)) return lit.text;
+  }
+  return null;
+}
+
+/**
+ * Pure: every unsanctioned frontmatter-fence re-derivation in `text`.
+ * `relPath` is the repo-relative path, for reporting and the exemptions.
+ * Returns [{ line, fn, found }].
+ */
+function findFrontmatterFenceDrift(text, relPath) {
+  const out = [];
+  const lines = text.split('\n');
+  const exemptFunctions = FUNCTION_SCOPED_EXEMPTIONS.get(relPath) || null;
+  const exemptFragments = DETECTOR_EXEMPTIONS.get(relPath) || null;
+  let currentFunction = TOP_LEVEL;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fnMatch = TOP_LEVEL_FUNCTION_RE.exec(line);
+    if (fnMatch) currentFunction = fnMatch[1];
+    else if (COLUMN_ZERO_RESET_RE.test(line)) currentFunction = TOP_LEVEL;
+
+    const code = stripComments(line);
+    if (!code.includes('---')) continue;
+    const found = fenceFragment(code);
+    if (found === null) continue;
+    if (exemptFunctions && exemptFunctions.has(currentFunction)) continue;
+    if (exemptFragments && exemptFragments.has(found)) continue;
+    out.push({ line: i + 1, fn: currentFunction, found });
+  }
+  return out;
+}
+
+/** Scan the authored source tree and entry points; every violation carries its repo-relative file. */
+function scanRepo(root) {
+  const violations = [];
+  for (const { dirs, ext } of SCAN_TREES) {
+    violations.push(...scanTree({
+      root,
+      scanDirs: dirs,
+      scanExt: ext,
+      onFile(rel, text) {
+        return findFrontmatterFenceDrift(text, rel).map((d) => ({ file: rel, ...d }));
+      },
+    }));
+  }
+  for (const rel of SCAN_FILES) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(root, rel), 'utf8');
+    } catch {
+      continue; // absent in a fixture tree
+    }
+    violations.push(...findFrontmatterFenceDrift(text, rel).map((d) => ({ file: rel, ...d })));
+  }
+  return violations;
+}
+
+function main() {
+  const root = path.join(__dirname, '..');
+  const violations = scanRepo(root);
+  if (violations.length === 0) {
+    process.stdout.write('ok frontmatter-fence-drift: no frontmatter fence re-derivations outside frontmatter-fence.cts\n');
+    return;
+  }
+  process.stderr.write('frontmatter-fence-drift: independent re-derivation(s) of the frontmatter fence found.\n');
+  process.stderr.write('Use `locateFrontmatterFence` (src/frontmatter-fence.cts) for offsets, or `frontmatterBlock` /\n');
+  process.stderr.write('`frontmatterRegion` / `extractFrontmatter` / `stripFrontmatter` (src/frontmatter.cts) for content:\n');
+  for (const d of violations) {
+    process.stderr.write(`  ${sanitizeForReport(d.file)}:${d.line} (${sanitizeForReport(d.fn)})  ${sanitizeForReport(d.found)}\n`);
+  }
+  process.exitCode = 1;
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  findFrontmatterFenceDrift,
+  scanRepo,
+  fenceFragment,
+  stripComments,
+  readStringLiteralAt,
+  OWNER_FILE,
+  TOP_LEVEL,
+  FUNCTION_SCOPED_EXEMPTIONS,
+  DETECTOR_EXEMPTIONS,
+};