@opengsd/gsd-core 1.15.0 → 1.16.0

package/hooks/gsd-secret-read-guard.js

@@ -61,7 +61,13 @@
 //   segment's operands — `[ -f .env ]` and `ls .env*` are existence checks
 //   GSD's own agents run — while `cp`/`mv`/`ln`/`git` are deliberately NOT
 //   exempt (`cp .env x && cat x` launders the name; `git show HEAD:.env`
-//   reads). A shell interpreter (bash/sh/zsh/dash/ksh/su) has its script scanned
+//   reads). Narrower carve-outs exempt single operand POSITIONS that are
+//   names, never contents, and keep checking the rest of the segment: the
+//   `--env-file` value under a container runtime (#4639), the pathspecs of
+//   `git check-ignore` / `git ls-files` / `git rm --cached`, and the
+//   destination of a one-source `cp`/`mv` (#4856). The #4856 carve-outs
+//   fail closed: an option they do not list withdraws them from the segment.
+//   A shell interpreter (bash/sh/zsh/dash/ksh/su) has its script scanned
 //   whether it arrives via `-c '…'`, a `<( )` file operand, a heredoc /
 //   here-string, or a pipe from a knowable `echo`/`printf` source
 //   (`echo cat .env | bash`); `eval` scans its joined operands; `source`/`.`
@@ -91,7 +97,11 @@
 //   container's own command can print the interpolated environment
 //   (`alpine printenv`, `docker compose config`) — the same exposure class
 //   as the pre-existing volume-mount gap (`-v .env:/s`); the flag's value
-//   itself is a name, never contents.)
+//   itself is a name, never contents. #4856 adds another: the `cp`/`mv`
+//   destination exemption can move a link prepared under a non-secret name
+//   onto a secret name (`ln -s .env.example l && mv l .env`), so a later
+//   edit of `.env` lands in the link target — a write redirection, the
+//   out-of-scope write class, not a read.)
 //
 // Triggers on: Read, Grep, Bash tool calls (Kimi: ReadFile, Grep, Shell)
 // Action: BLOCK (decision: 'block', exit 2) — codes secret-read |
@@ -141,6 +151,57 @@ const NON_READING_COMMANDS = new Set([
 const CONTAINER_RUNTIMES = new Set(['docker', 'docker-compose', 'podman', 'nerdctl']);
 const ENV_FILE_FLAG_RE = /^--env-file(=|$)/;
 
+// #4856: git subcommands that report or drop a path's ignore / tracking
+// status and never print the file, so their pathspec operands are names —
+// the category NON_READING_COMMANDS encodes. Each carries the closed set of
+// its NO-VALUE options (from `git <subcommand> -h`, git 2.49). Any other
+// option withdraws the exemption from the whole segment, so an option value
+// is never mistaken for a pathspec: `-X <file>` reads the file, and
+// `--pathspec-from-file=<file>` echoes its lines in the "did not match"
+// error. `requires` names the option without which the subcommand stays
+// checked (#4856 scopes `git rm` to `--cached`).
+const GIT_PATHSPEC_SUBCOMMANDS = new Map([
+  ['check-ignore', {
+    flags: new Set(['-q', '--quiet', '-v', '--verbose', '--stdin', '-z', '-n', '--non-matching', '--no-index', '--index']),
+  }],
+  ['ls-files', {
+    flags: new Set([
+      '-z', '-t', '-v', '-f', '-c', '--cached', '-d', '--deleted', '-m', '--modified', '-o', '--others',
+      '-i', '--ignored', '-s', '--stage', '-k', '--killed', '-u', '--unmerged', '--directory', '--eol',
+      '--no-empty-directory', '--resolve-undo', '--exclude-standard', '--full-name',
+      '--recurse-submodules', '--error-unmatch', '--abbrev', '--debug', '--deduplicate', '--sparse',
+    ]),
+  }],
+  ['rm', {
+    flags: new Set(['--cached', '-f', '--force', '-n', '--dry-run', '-q', '--quiet', '-r', '--ignore-unmatch', '--sparse']),
+    requires: '--cached',
+  }],
+]);
+
+// git's global options (its own usage line, git 2.49), needed to locate the
+// subcommand. A value option consumes the next word unless written
+// `--opt=value`; an option in neither set fails closed, so a value is never
+// read as the subcommand (`git -C ls-files show HEAD:.env` runs `show`).
+const GIT_GLOBAL_VALUE_OPTIONS = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env']);
+const GIT_GLOBAL_FLAGS = new Set([
+  '-p', '--paginate', '-P', '--no-pager', '--no-replace-objects', '--no-lazy-fetch',
+  '--no-optional-locks', '--no-advice', '--bare',
+]);
+
+// #4856: `cp`/`mv` write their destination and never print it, so a secret
+// name that is ONLY the destination of a one-source copy or move is a name
+// (`cp .env.example .env`). The exemption holds for exactly two operands
+// behind options from this closed set; anything else keeps the whole segment
+// checked — `-t`/`--target-directory` (every operand becomes a source), a
+// backup (`-b`, `--backup`, `-S`: the old secret survives as `.env~`, a name
+// the predicate does not classify), a link (`-l`, `-s`) or `--exchange`
+// (the destination shares or swaps the secret). Options must precede the
+// operands: a trailing one is an option under GNU getopt's permutation but
+// an operand under POSIXLY_CORRECT (`cp a .env -f` then copies `.env` INTO
+// `-f/`), so which word is the destination would hang on an environment
+// the hook cannot see.
+const COPY_NAME_ONLY_FLAGS = new Set(['-f', '--force', '-i', '--interactive', '-n', '--no-clobber', '-v', '--verbose']);
+
 // Shell interpreters that run a script from `-c`, a file operand, or stdin
 // (heredoc / here-string / piped `echo`|`printf`). `su` is here for its `-c`
 // form (`su [user] -c 'cmd'`); a bare `su user` resolves to file mode, which
@@ -714,6 +775,86 @@ function resolveCommand(words) {
   return { base: lastSegment(words[idx].text).toLowerCase(), operands: words.slice(idx + 1) };
 }
 
+// Operand indices the segment's command consumes as a NAME, never as
+// CONTENTS (#4639, #4856). Only these positions skip the operand check;
+// every other operand is still checked, so a carve-out cannot launder a read
+// elsewhere in the segment.
+function nameOnlyOperandIndices(base, operands) {
+  if (CONTAINER_RUNTIMES.has(base)) return envFileValueIndices(operands);
+  if (base === 'git') return gitPathspecIndices(operands);
+  if (base === 'cp' || base === 'mv') return copyDestinationIndices(operands);
+  return new Set();
+}
+
+// #4639: the `--env-file` word, plus the next operand for the bare flag
+// (`--env-file=<value>` is a single word).
+function envFileValueIndices(operands) {
+  const exempt = new Set();
+  for (let k = 0; k < operands.length; k++) {
+    if (!ENV_FILE_FLAG_RE.test(operands[k].text)) continue;
+    exempt.add(k);
+    if (!operands[k].text.includes('=')) exempt.add(++k);
+  }
+  return exempt;
+}
+
+// True when `text` is a listed long option, or a short cluster (`-co`) whose
+// every letter is listed. `--opt=value`, an abbreviation, or a cluster
+// holding a value option (`-ciX`) is not.
+function isListedFlag(text, flags) {
+  if (text.startsWith('--')) return flags.has(text);
+  return /^-[A-Za-z]+$/.test(text) && [...text.slice(1)].every((ch) => flags.has(`-${ch}`));
+}
+
+// Index of git's subcommand past its global options, or -1 when an option
+// outside GIT_GLOBAL_VALUE_OPTIONS / GIT_GLOBAL_FLAGS precedes it.
+function gitSubcommandIndex(operands) {
+  for (let k = 0; k < operands.length; k++) {
+    const t = operands[k].text;
+    if (!t.startsWith('-')) return k;
+    if (GIT_GLOBAL_VALUE_OPTIONS.has(t)) { k++; continue; }
+    if (GIT_GLOBAL_FLAGS.has(t)) continue;
+    const eq = t.indexOf('=');
+    const isLongValueForm = t.startsWith('--') && eq !== -1 && GIT_GLOBAL_VALUE_OPTIONS.has(t.slice(0, eq));
+    if (!isLongValueForm) return -1;
+  }
+  return -1;
+}
+
+// #4856: the pathspec operands of a GIT_PATHSPEC_SUBCOMMANDS invocation. git
+// permutes options, so one may follow a pathspec; after `--` every word is a
+// pathspec. The subcommand is matched case-sensitively, as git looks it up.
+function gitPathspecIndices(operands) {
+  const sub = gitSubcommandIndex(operands);
+  const spec = sub === -1 ? undefined : GIT_PATHSPEC_SUBCOMMANDS.get(operands[sub].text);
+  if (!spec) return new Set();
+  const pathspecs = new Set();
+  let required = spec.requires === undefined;
+  let endOfOptions = false;
+  for (let k = sub + 1; k < operands.length; k++) {
+    const t = operands[k].text;
+    if (endOfOptions || !t.startsWith('-') || t === '-') pathspecs.add(k);
+    else if (t === '--') endOfOptions = true;
+    else if (!isListedFlag(t, spec.flags)) return new Set();
+    else if (t === spec.requires) required = true;
+  }
+  return required ? pathspecs : new Set();
+}
+
+// #4856: the destination of a one-source `cp`/`mv` (see COPY_NAME_ONLY_FLAGS).
+function copyDestinationIndices(operands) {
+  const positional = [];
+  let endOfOptions = false;
+  for (let k = 0; k < operands.length; k++) {
+    const t = operands[k].text;
+    if (endOfOptions || !t.startsWith('-') || t === '-') positional.push(k);
+    else if (positional.length) return new Set(); // an option or `--` after an operand
+    else if (t === '--') endOfOptions = true;
+    else if (!isListedFlag(t, COPY_NAME_ONLY_FLAGS)) return new Set();
+  }
+  return positional.length === 2 ? new Set([positional[1]]) : new Set();
+}
+
 // The statically-knowable stdin a segment writes: `echo`/`printf` operands
 // joined by a space (for `echo`, leading `-neE` flags dropped). Any other
 // source (`cat gen.sh | bash`, `curl … | sh`) is not knowable → null.
@@ -854,20 +995,10 @@ function findSecretRead(command, depth) {
 
     if (NON_READING_COMMANDS.has(base)) continue;
 
-    // #4639: exempt ONLY the value of `--env-file`, and only when the
-    // segment's command word is a container runtime. A bare `--env-file`
-    // consumes the next operand; `--env-file=<value>` is a single word.
-    const envFileExempt = CONTAINER_RUNTIMES.has(base);
-    let skipNext = false;
-    for (const w of operands) {
-      if (envFileExempt) {
-        if (skipNext) { skipNext = false; continue; }
-        if (ENV_FILE_FLAG_RE.test(w.text)) {
-          if (!w.text.includes('=')) skipNext = true; // bare flag consumes the next operand
-          continue;
-        }
-      }
-      if (namesSecret(normalizeOperand(w.text))) return w.text;
+    const nameOnly = nameOnlyOperandIndices(base, operands);
+    for (let k = 0; k < operands.length; k++) {
+      if (nameOnly.has(k)) continue;
+      if (namesSecret(normalizeOperand(operands[k].text))) return operands[k].text;
     }
   }
   return null;

package/hooks/gsd-statusline.js

@@ -3,6 +3,14 @@
 // Claude Code Statusline - GSD Edition
 // Shows: model | current task (or GSD state) | directory | context usage
 
+// #5183: Node's on-disk compile cache, so later runs reuse V8's compiled code
+// for unchanged modules. Only as the entry (a test require() is unaffected),
+// skipped under V8 coverage, optional (Bun stubs it), and never fatal.
+// NODE_DISABLE_COMPILE_CACHE (any value) turns it off.
+if (require.main === module && !process.env.NODE_V8_COVERAGE) {
+  try { require('node:module').enableCompileCache?.(); } catch { /* optimization only */ }
+}
+
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -42,6 +50,7 @@ if (require.main === module) {
 const { isSemverNewer } = require('../gsd-core/bin/lib/semver-compare.cjs');
 const { PACKAGE_NAME, updateCacheFileName } = require('../gsd-core/bin/lib/package-identity.cjs');
 const { normalizeStateStatus } = require('../gsd-core/bin/lib/state-document.cjs');
+const { locateFrontmatterFence } = require('../gsd-core/bin/lib/frontmatter-fence.cjs');
 const {
   renderBracketPhaseDisplay,
   renderBracketMilestoneDisplay,
@@ -250,13 +259,12 @@ function readGsdState(dir, opts = {}) {
 function parseStateMd(content) {
   const state = {};
 
-  // YAML frontmatter between --- markers (anchored at file start).
-  // #2754: \r?\n (not literal \n) so a CRLF STATE.md (Windows-authored) parses
-  // identically to LF — pre-fix the literal-\n fence dropped the ENTIRE block.
-  // Mirrors the CRLF-safe extractFrontmatter in src/frontmatter.cts.
-  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (fmMatch) {
-    const fm = fmMatch[1];
+  // YAML frontmatter: the block the one fence owner finds (`locateFrontmatterFence`), so a
+  // CRLF STATE.md (#2754), a BOM, and a `---` inside a value read exactly as every other
+  // STATE.md reader reads them (found while implementing #5105).
+  const fence = locateFrontmatterFence(content);
+  if (fence && fence.closed) {
+    const fm = content.slice(fence.openEnd, fence.bodyEnd);
     // Top-level scalar key: value
     for (const line of fm.split(/\r?\n/)) {
       const m = line.match(/^(\w+):\s*(.+)/);

package/hooks/gsd-update-banner.js

@@ -12,6 +12,14 @@
 
 'use strict';
 
+// #5183: Node's on-disk compile cache, so later runs reuse V8's compiled code
+// for unchanged modules. Only as the entry (a test require() is unaffected),
+// skipped under V8 coverage, optional (Bun stubs it), and never fatal.
+// NODE_DISABLE_COMPILE_CACHE (any value) turns it off.
+if (require.main === module && !process.env.NODE_V8_COVERAGE) {
+  try { require('node:module').enableCompileCache?.(); } catch { /* optimization only */ }
+}
+
 const fs = require('fs');
 const path = require('path');
 const os = require('os');

package/hooks/gsd-windsurf-pre-write.js

@@ -31,14 +31,23 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { allow, deny } = require('./lib/hook-exit.js');
-const { reportIfUndetermined } = require('./lib/git-probe.js');
+const { reportIfUndetermined, BLOCKING_GUARD_PROBE_TIMEOUT_MS } = require('./lib/git-probe.js');
 
 // #3911 (ADR-3889 Phase 7): the exit(2) call site (block(), below) is
 // migrated to hook-exit.js's deny(undefined, reason) — see
 // gsd-windsurf-pre-command.js's identical note for the fixed defect
 // (terminateNow's fd 1/fd 2 writes now run in independent try/catch blocks).
 
-const SPAWNOPT = { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000, windowsHide: true };
+// Shared blocking-guard probe budget (hooks/lib/git-probe.js, #5180): a timed-out
+// probe fails open, so it is sized for a starved host. Windsurf documents NO
+// hook timeout (docs.devin.ai/desktop/cascade/hooks lists only an aspirational
+// "sub-100ms" target) and this surface's registration entry
+// (buildWindsurfHookEntry in src/runtime-hooks-surface.cts) carries none, so the
+// host budget is UNKNOWN. This guard runs at most 3 sequential probes (15 s
+// worst case); that worst case is NOT claimed to fit any host budget — if
+// Windsurf kills the hook sooner, the host kill fails open exactly as a probe
+// timeout does. The guard keeps its fail-open posture either way.
+const SPAWNOPT = { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: BLOCKING_GUARD_PROBE_TIMEOUT_MS, windowsHide: true };
 
 function git(args, cwd) {
   return spawnSync('git', args, { ...SPAWNOPT, cwd });

package/hooks/gsd-workflow-guard.js

@@ -22,7 +22,7 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { tokenize, skipToSubcommand } = require('./lib/git-cmd.js');
 const { HOOK_ON_CRASH, allow, deny, crash } = require('./lib/hook-exit.js');
-const { reportIfUndetermined } = require('./lib/git-probe.js');
+const { reportIfUndetermined, BLOCKING_GUARD_PROBE_TIMEOUT_MS } = require('./lib/git-probe.js');
 
 // This guard is almost entirely advisory (fail open — a broken advisory must
 // never wedge every tool call), with ONE hard block (#3504 force-add-on-
@@ -87,11 +87,12 @@ function currentBranch(cwd) {
     stdio: ['ignore', 'pipe', 'ignore'],
     windowsHide: true,
     // #3504: bounded — this ran unbounded before, an indefinite hang under a
-    // wedged git would hang every PreToolUse call. Host wiring allows a 5s
-    // budget for the whole hook, so the probe gets 2s of it; a timeout
+    // wedged git would hang every PreToolUse call. The probe gets the shared
+    // blocking-guard budget (hooks/lib/git-probe.js, #5180), well inside the
+    // 120s host budget this guard is registered with (#3981); a timeout
     // returns '' (branch unknown), which both the block decision and the
     // fail-closed re-check treat as "cannot establish agent branch".
-    timeout: 2000,
+    timeout: BLOCKING_GUARD_PROBE_TIMEOUT_MS,
     killSignal: 'SIGTERM',
   });
   // #3911: a timeout/spawn-failure here previously degraded to '' exactly

package/hooks/gsd-worktree-path-guard.js

@@ -18,7 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { HOOK_ON_CRASH, allow, deny, crash } = require('./lib/hook-exit.js');
-const { reportIfUndetermined } = require('./lib/git-probe.js');
+const { reportIfUndetermined, BLOCKING_GUARD_PROBE_TIMEOUT_MS } = require('./lib/git-probe.js');
 
 // This guard's outer catch has always exited 0 (fail open): a path guard that
 // cannot resolve the worktree must not block the user's edit — its whole job
@@ -28,7 +28,11 @@ const { reportIfUndetermined } = require('./lib/git-probe.js');
 // rather than inheriting a default (#3911).
 const ON_CRASH = HOOK_ON_CRASH.ALLOW;
 
-const SPAWNOPT = { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000, windowsHide: true };
+// A timed-out git probe fails OPEN (see ON_CRASH above), so the per-probe
+// budget is the shared blocking-guard value, sized for a starved host rather
+// than git's ~0.1s typical run (rationale and arithmetic in
+// hooks/lib/git-probe.js, #5180). This guard runs at most 3 sequential probes.
+const SPAWNOPT = { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: BLOCKING_GUARD_PROBE_TIMEOUT_MS, windowsHide: true };
 
 function git(args, cwd) {
   return spawnSync('git', args, { ...SPAWNOPT, cwd });

package/hooks/hooks.json

@@ -12,32 +12,32 @@
       {
         "matcher": "Write|Edit",
         "hooks": [
-          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-prompt-guard.js\"", "timeout": 5 },
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-prompt-guard.js\"", "timeout": 120 },
           { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-read-guard.js\"", "timeout": 5 }
         ]
       },
       {
         "matcher": "Write|Edit|MultiEdit",
         "hooks": [
-          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-worktree-path-guard.js\"", "timeout": 5 }
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-worktree-path-guard.js\"", "timeout": 120 }
         ]
       },
       {
         "matcher": "Write",
         "hooks": [
-          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-write-guard.js\"", "timeout": 5 }
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-write-guard.js\"", "timeout": 120 }
         ]
       },
       {
         "matcher": "Read|Grep|Bash",
         "hooks": [
-          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-secret-read-guard.js\"", "timeout": 5 }
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-secret-read-guard.js\"", "timeout": 120 }
         ]
       },
       {
         "matcher": "Agent|Task",
         "hooks": [
-          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-agent-isolation-guard.js\"", "timeout": 5 }
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-agent-isolation-guard.js\"", "timeout": 120 }
         ]
       }
     ],

package/hooks/lib/cli-exit.js

@@ -185,6 +185,17 @@ function setPendingOutcome(v) {
 function getPendingOutcome() {
     return globalThis[PENDING_OUTCOME_KEY];
 }
+/**
+ * Declare the outcome a void-returning `main()` ends with (#5170, ADR-5057 §4): writes the
+ * pending-outcome cell that `runMain` projects. Validates `name` is an outcome
+ * `projectOutcome` accepts (PASS, FAIL or a registered name) and THROWS otherwise, so a typo'd
+ * name fails at the declaration rather than at process exit. Call it AFTER `output()`, which
+ * rewrites the cell on every call. `output()` and this are the only writers of the cell.
+ */
+function declareOutcome(name) {
+    projectOutcome(name, 'v1');
+    setPendingOutcome(name);
+}
 const EXIT_CONTRACT_FLAG_PREFIX = '--exit-contract=';
 /** Scan argv for the FIRST `--exit-contract=<value>` token; undefined if absent. */
 function findExitContractFlag(argv) {
@@ -557,4 +568,5 @@ module.exports = {
     terminateNow,
     setPendingOutcome,
     getPendingOutcome,
+    declareOutcome,
 };

package/hooks/lib/git-probe.js

@@ -81,4 +81,20 @@ function reportIfUndetermined(hookName, probeLabel, result) {
   }
 }
 
-module.exports = { classifyGitProbe, reportIfUndetermined };
+// Per-probe budget for the git probes of BLOCKING guards. A probe that times
+// out fails OPEN (see reportIfUndetermined above), which is the same outcome
+// as the host killing the hook — so a budget sized to git's ~0.1s typical run
+// silently disables the gate on a starved host (a 2000ms budget was exceeded
+// on a loaded Windows runner, #5180). Worst case for a guard that runs up to
+// BLOCKING_GUARD_MAX_SEQUENTIAL_PROBES sequential probes:
+//   3 x 5000ms + ~500ms node start/kill/reap = ~15.5s,
+// inside the 120s host budget blocking guards are registered with (#3981).
+const BLOCKING_GUARD_PROBE_TIMEOUT_MS = 5000;
+const BLOCKING_GUARD_MAX_SEQUENTIAL_PROBES = 3;
+
+module.exports = {
+  classifyGitProbe,
+  reportIfUndetermined,
+  BLOCKING_GUARD_PROBE_TIMEOUT_MS,
+  BLOCKING_GUARD_MAX_SEQUENTIAL_PROBES,
+};

package/hooks/lib/isolation-sentinel.js

@@ -23,8 +23,8 @@
 // explicit fallback for the per-plan submodule-degrade override and shares
 // the exact same atomic-write implementation.
 //
-// Sentinel path: `<cwd>/.gsd/dispatch-isolation-sentinel.json`. `.gsd` is
-// gitignored (root `.gitignore`'s bare `.gsd` entry matches at any depth),
+// Sentinel path: `<cwd>/.gsd/dispatch-isolation-sentinel.json`. The writer
+// seeds `.gsd/.gitignore` so this stays ignored in user projects too,
 // and lives inside the checkout that ran the workflow — concurrent worktrees
 // of the same repo are separate directories on disk, so each gets its own
 // sentinel with no cross-worktree collision, no lock file needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/gsd-core",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
   "main": ".opencode/plugins/gsd-core.js",
   "bin": {
@@ -29,6 +29,12 @@
     "!scripts/run-affected-tests.cjs",
     "!scripts/lint-no-adhoc-regex-escape.cjs",
     "!scripts/lint-allow-test-rule-refs.cjs",
+    "!scripts/lint-verify-lifecycle-writes.cjs",
+    "!scripts/lint-verify-lifecycle-writes.allowlist.json",
+    "!scripts/lint-evaluation-scope-drift.cjs",
+    "!scripts/lint-evaluation-scope-drift.allowlist.json",
+    "!scripts/lint-gate-evidence-drift.cjs",
+    "!scripts/lint-gate-positive-control.cjs",
     "pi",
     "vscode"
   ],
@@ -69,6 +75,7 @@
     "@stryker-mutator/tap-runner": "^9.6.1",
     "@types/node": "^22.19.19",
     "c8": "^11.0.0",
+    "esbuild": "0.28.2",
     "eslint": "^9.39.4",
     "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-no-only-tests": "^3.4.0",
@@ -79,6 +86,8 @@
     "js-yaml": "^4.3.2",
     "mutation-testing-metrics": "^3.7.3",
     "re2js": "^2.8.6",
+    "saxes": "6.0.0",
+    "tap-parser": "18.3.4",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.0"
   },
@@ -121,10 +130,16 @@
     "lint": "eslint . --cache --cache-location node_modules/.cache/eslint/ --max-warnings 0",
     "lint:fix": "eslint . --fix",
     "lint:table-schema-drift": "node scripts/lint-table-schema-drift.cjs",
+    "lint:planning-document-positive-control": "node scripts/lint-planning-document-positive-control.cjs",
     "lint:frontmatter-scalar-broad-grep": "node scripts/lint-frontmatter-scalar-broad-grep.cjs",
     "lint:removed-but-needed": "node scripts/lint-removed-but-needed.cjs",
+    "lint:verify-lifecycle-writes": "node scripts/lint-verify-lifecycle-writes.cjs",
+    "lint:evaluation-scope-drift": "node scripts/lint-evaluation-scope-drift.cjs",
+    "lint:gate-evidence-drift": "node scripts/lint-gate-evidence-drift.cjs",
+    "lint:gate-positive-control": "node scripts/lint-gate-positive-control.cjs",
+    "lint:frontmatter-fence-drift": "node scripts/lint-frontmatter-fence-drift.cjs",
     "lint:response-language": "node scripts/lint-response-language-coverage.cjs",
-    "lint:ci": "npm run lint && npm run lint:skill-deps && npm run lint:generated-sync && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && npm run lint:retired-runtime-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-allow-test-rule-refs.cjs && node scripts/lint-resolution-provenance.cjs && node scripts/lint-portable-timeout.cjs && node scripts/lint-portable-grep.cjs && node scripts/lint-allowed-tools-parity.cjs && node scripts/lint-phase-arg-assignment.cjs && node scripts/validate-registry.cjs && node scripts/lint-table-schema-drift.cjs && node scripts/lint-pr-branch-pattern-drift.cjs && node scripts/lint-fix-has-regression-tests.cjs && node scripts/lint-example-parser-parity.cjs && node scripts/lint-docs-command-form.cjs && node scripts/lint-plan-count-drift.cjs && node scripts/lint-milestone-window-drift.cjs && node scripts/lint-phase-enumeration-drift.cjs && node scripts/lint-planning-prompt-drift.cjs && node scripts/lint-unreachable-guard-drift.cjs && node scripts/lint-completion-ratio-drift.cjs && node scripts/lint-slug-derivation-drift.cjs && node scripts/lint-state-field-drift.cjs && node scripts/lint-state-write-path-drift.cjs && node scripts/lint-completion-predicate-drift.cjs && node scripts/lint-planning-snapshot-bypass-drift.cjs && node scripts/lint-health-diagnostic-rule-table.cjs && node scripts/lint-planning-artifact-writer-drift.cjs && node scripts/lint-frontmatter-scalar-broad-grep.cjs && node scripts/lint-removed-but-needed.cjs && node scripts/lint-no-adhoc-regex-escape.cjs && node scripts/lint-vendored-deps.cjs && node scripts/lint-docs-guard-registration.cjs && node scripts/lint-source-test-name-collision.cjs && npm run lint:hooks-runtime-build-seam && node scripts/check-contract-drift.cjs && node scripts/lint-mutation-test-derivation-drift.cjs && node scripts/lint-seam-enforcement.cjs && node scripts/lint-workflow-shellcheck.cjs && npm run lint:response-language",
+    "lint:ci": "npm run lint && npm run lint:skill-deps && npm run lint:generated-sync && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && npm run lint:retired-runtime-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-allow-test-rule-refs.cjs && node scripts/lint-resolution-provenance.cjs && node scripts/lint-portable-timeout.cjs && node scripts/lint-portable-grep.cjs && node scripts/lint-allowed-tools-parity.cjs && node scripts/lint-phase-arg-assignment.cjs && node scripts/validate-registry.cjs && node scripts/lint-table-schema-drift.cjs && node scripts/lint-planning-document-positive-control.cjs && node scripts/lint-pr-branch-pattern-drift.cjs && node scripts/lint-fix-has-regression-tests.cjs && node scripts/lint-example-parser-parity.cjs && node scripts/lint-docs-command-form.cjs && node scripts/lint-plan-count-drift.cjs && node scripts/lint-milestone-window-drift.cjs && node scripts/lint-phase-enumeration-drift.cjs && node scripts/lint-planning-prompt-drift.cjs && node scripts/lint-unreachable-guard-drift.cjs && node scripts/lint-completion-ratio-drift.cjs && node scripts/lint-slug-derivation-drift.cjs && node scripts/lint-state-field-drift.cjs && node scripts/lint-state-write-path-drift.cjs && node scripts/lint-completion-predicate-drift.cjs && node scripts/lint-planning-snapshot-bypass-drift.cjs && node scripts/lint-health-diagnostic-rule-table.cjs && node scripts/lint-planning-artifact-writer-drift.cjs && node scripts/lint-frontmatter-scalar-broad-grep.cjs && node scripts/lint-removed-but-needed.cjs && node scripts/lint-no-adhoc-regex-escape.cjs && node scripts/lint-vendored-deps.cjs && node scripts/lint-docs-guard-registration.cjs && node scripts/lint-source-test-name-collision.cjs && npm run lint:hooks-runtime-build-seam && node scripts/check-contract-drift.cjs && node scripts/lint-mutation-test-derivation-drift.cjs && node scripts/lint-seam-enforcement.cjs && node scripts/lint-workflow-shellcheck.cjs && npm run lint:response-language && node scripts/lint-verify-lifecycle-writes.cjs && node scripts/lint-frontmatter-fence-drift.cjs && node scripts/lint-evaluation-scope-drift.cjs && node scripts/lint-gate-evidence-drift.cjs && node scripts/lint-gate-positive-control.cjs",
     "lint:allow-test-rule-refs": "node scripts/lint-allow-test-rule-refs.cjs",
     "lint:regression-names": "node scripts/lint-regression-test-names.cjs",
     "lint:descriptions": "node scripts/lint-descriptions.cjs",
@@ -161,9 +176,11 @@
     "test:coverage:all": "npm run test:coverage",
     "test:mutation": "stryker run",
     "gen:features": "node scripts/gen-features.cjs",
-    "gen:state-md-docs": "node scripts/gen-state-md-docs.cjs"
+    "gen:state-md-docs": "node scripts/gen-state-md-docs.cjs",
+    "lint:vendored-deps": "node scripts/lint-vendored-deps.cjs"
   },
   "allowScripts": {
-    "fallow@2.70.0": true
+    "fallow@2.70.0": true,
+    "esbuild@0.28.2": true
   }
 }

package/scripts/changeset/parse.cjs

@@ -86,10 +86,58 @@ function extractDocsExempt(body) {
   return { docsExempt: reason, body: cleaned };
 }
 
+/**
+ * A self-contained copy of `locateFrontmatterFence` (src/frontmatter-fence.cts, the one
+ * frontmatter fence owner). Kept here, not required from the built
+ * `gsd-core/bin/lib/frontmatter-fence.cjs`, because this module runs before any build: the
+ * `changeset-lint` job in .github/workflows/changeset-required.yml checks out and runs
+ * `node scripts/changeset/lint.cjs` with no `npm ci` and no `build:lib`. Found while
+ * implementing #5105: tests/frontmatter-fence.test.cjs ("kept frontmatter fence copies agree
+ * with the owner") pins this copy to the owner over a fixture corpus and a property test, and
+ * scripts/lint-frontmatter-fence-drift.cjs allowlists exactly this function.
+ */
+function locateFrontmatterFence(text) {
+  if (typeof text !== 'string') {
+    throw new TypeError(`locateFrontmatterFence: expected a string, got ${typeof text}`);
+  }
+  const closingFenceLine = /^---[ \t]*$/;
+  const lenientClosingFenceLine = /^-{4,}[ \t]*$/;
+  const bom = text.charCodeAt(0) === 0xfeff ? text.slice(0, 1) : '';
+  const start = bom.length;
+  let eol;
+  if (text.startsWith('---\r\n', start)) eol = '\r\n';
+  else if (text.startsWith('---\n', start)) eol = '\n';
+  else return null;
+  const openEnd = start + 3 + eol.length;
+  const closedAt = (lineStart, lineEnd) => {
+    let bodyEnd = openEnd;
+    if (lineStart > openEnd) {
+      bodyEnd = lineStart - 1;
+      if (bodyEnd > openEnd && text[bodyEnd - 1] === '\r') bodyEnd -= 1;
+    }
+    return { bom, eol, openEnd, closed: true, closingStart: lineStart, closingFenceEnd: lineEnd, bodyEnd };
+  };
+  let lenient = null;
+  let lineStart = openEnd;
+  while (lineStart <= text.length) {
+    const newline = text.indexOf('\n', lineStart);
+    const lineEnd = newline === -1 ? text.length : newline > lineStart && text[newline - 1] === '\r' ? newline - 1 : newline;
+    const line = text.slice(lineStart, lineEnd);
+    if (closingFenceLine.test(line)) return closedAt(lineStart, lineEnd);
+    if (lenient === null && lenientClosingFenceLine.test(line)) lenient = [lineStart, lineEnd];
+    if (newline === -1) break;
+    lineStart = newline + 1;
+  }
+  if (lenient !== null) return closedAt(lenient[0], lenient[1]);
+  return { bom, eol, openEnd, closed: false, closingStart: -1, closingFenceEnd: -1, bodyEnd: text.length };
+}
+
 function parseFragment(src) {
-  const fmMatch = src.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-  if (!fmMatch) return { ok: false, reason: FRAGMENT_ERROR.MISSING_FRONTMATTER };
-  const [, fmBlock, body] = fmMatch;
+  const fence = locateFrontmatterFence(src);
+  if (!fence || !fence.closed) return { ok: false, reason: FRAGMENT_ERROR.MISSING_FRONTMATTER };
+  const fmBlock = src.slice(fence.openEnd, fence.bodyEnd);
+  // Everything past the closing fence line and its line ending.
+  const body = src.slice(fence.closingFenceEnd).replace(/^\r?\n/, '');
 
   const fields = {};
   for (const line of fmBlock.split(/\r?\n/)) {
@@ -137,4 +185,4 @@ function parseFragment(src) {
   return { ok: true, fragment: { type: fields.type, pr, body: visibleBody, docsExempt } };
 }
 
-module.exports = { parseFragment, extractDocsExempt, FRAGMENT_ERROR, ALLOWED_TYPES, DOCS_EXEMPT_RE };
+module.exports = { parseFragment, extractDocsExempt, locateFrontmatterFence, FRAGMENT_ERROR, ALLOWED_TYPES, DOCS_EXEMPT_RE };