@opengsd/gsd-core 1.6.1 → 1.7.0-rc.2

package/commands/gsd/review.md

@@ -35,6 +35,12 @@ Phase number: extracted from $ARGUMENTS (required)
 - `--cursor` — Include Cursor agent review
 - `--agy` / `--antigravity` — Include Antigravity CLI review
 - `--all` — Include all available CLIs
+
+**No flags** — if `review.default_reviewers` is set, review with only those configured
+reviewers that are detected; otherwise review with all available CLIs. Configured
+`review.reviewer_instances` names may appear in `review.default_reviewers`; each runs as an
+independent reviewer identity backed by its configured adapter+model (see
+`docs/CONFIGURATION.md`). Instance names are not valid as flags.
 </context>
 
 <process>

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-core",
-  "version": "1.6.1",
+  "version": "1.7.0-rc.2",
   "description": "GSD Core — a meta-prompting, context engineering, and spec-driven development system for AI coding agents. Loads gsd's operating context into every Gemini CLI session.",
   "contextFileName": "GEMINI.md"
 }

package/gsd-core/bin/gsd-tools.cjs

@@ -57,7 +57,7 @@
  * Milestone Operations:
  *   milestone complete <version>       Archive milestone, create MILESTONES.md
  *     [--name <name>]
- *     [--archive-phases]               Move phase dirs to milestones/vX.Y-phases/
+ *     [--no-archive-phases]          Skip moving phase dirs to milestones/vX.Y-phases/ (archived by default)
  *
  * User Story Validation:
  *   user-story validate --story "..."  Validate "As a / I want to / so that" format
@@ -204,11 +204,31 @@ const projectRoot = require('./lib/project-root.cjs');
 // against any require/load-ordering edge where the export isn't bound yet
 // when this entrypoint is first required (#604).
 const findProjectRoot = (...args) => projectRoot.findProjectRoot(...args);
+
+// #1754: CLI skew detection — warn (stderr, non-blocking) if this gsd-tools.cjs
+// is NOT the project-local install while a project-local install exists. Catches
+// the shadowing scenario from #1748 (stale global canary shadowing project-local).
+try {
+  const _skew = require('./lib/cli-skew-check.cjs');
+  const _skewRoot = findProjectRoot(process.cwd());
+  if (_skewRoot) {
+    const _skewLocal = path.join(_skewRoot, '.claude', 'gsd-core', 'bin', 'gsd-tools.cjs');
+    const _skewWarn = _skew.checkCliSkew({
+      resolvedPath: path.resolve(__filename),
+      projectRoot: _skewRoot,
+      projectLocalExists: fs.existsSync(_skewLocal),
+    });
+    if (_skewWarn) process.stderr.write(_skewWarn + '\n');
+  }
+} catch { /* advisory — never block */ }
+
 const { getActiveWorkstream } = require('./lib/planning-workspace.cjs');
 const { resolveActiveWorkstream, applyResolvedWorkstreamEnv } = require('./lib/active-workstream-store.cjs');
 const state = require('./lib/state.cjs');
 const phase = require('./lib/phase.cjs');
 const roadmap = require('./lib/roadmap.cjs');
+// #1561 — assumption-delta advisory checkpoint detector (pure function).
+const { detectAssumptionDelta } = require('./lib/assumption-delta.cjs');
 const verify = require('./lib/verify.cjs');
 const config = require('./lib/config.cjs');
 const template = require('./lib/template.cjs');
@@ -227,6 +247,10 @@ const evalMod = require('./lib/eval.cjs');
 const { routeVerificationCommand } = require('./lib/verification-command-router.cjs');
 const verification = require('./lib/verification.cjs');
 const { routeInitCommand } = require('./lib/init-command-router.cjs');
+// Stale-bake guard (#1688): warns once when model config changed since agents
+// were last baked on static-frontmatter runtimes (codex/opencode). Lazy-required
+// here, invoked from case 'init' below.
+const { warnIfStaleBake } = require('./lib/stale-bake-guard.cjs');
 const loopResolver = require('./lib/loop-resolver.cjs');
 const capabilityState = require('./lib/capability-state.cjs');
 const capabilityWriter = require('./lib/capability-writer.cjs');
@@ -635,7 +659,7 @@ async function main() {
   // discovery; previously it was a partial subset that didn't include
   // phase / roadmap / milestone / progress / etc.
   const TOP_LEVEL_USAGE = 'Usage: gsd-tools <command> [args] [--raw] [--pick <field>] [--cwd <path>] [--ws <name>] [--json-errors]\n' +
-    'Commands: agent, agent-skills, audit-open, audit-uat, check, check-commit, commit, commit-to-subrepo, pr-subrepo, ' +
+    'Commands: agent, agent-skills, assumption-delta, audit-open, audit-uat, check, check-commit, commit, commit-to-subrepo, pr-subrepo, ' +
     'config-ensure-section, config-get, config-new-project, config-path, config-set, migrate-config, ' +
     'current-timestamp, detect-custom-files, docs-init, drift-guard, effort, extract-messages, find-phase, ' +
     'from-gsd2, frontmatter, gap-analysis, generate-claude-md, generate-claude-profile, ' +
@@ -1234,6 +1258,56 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
       break;
     }
 
+    case 'dispatch-should-flatten': {
+      // #1708 / #853: typed query replacing the `RUNTIME === 'codex'` prose rule.
+      //
+      // Resolves the current runtime (GSD_RUNTIME > config.runtime > 'claude'),
+      // looks up registry.runtimes[id].runtime.hostIntegration.dispatch, and
+      // calls shouldFlattenDispatch(dispatch) from host-integration.cjs.
+      //
+      // Fail-closed: any unknown runtime, missing dispatch, or thrown error
+      // yields `true` (inline — the always-safe default).
+      //
+      // Output:
+      //   --raw   → prints exactly `true` or `false`
+      //   --json  → prints { runtime, shouldFlatten, dispatch }
+      //   default → same as --raw
+      try {
+        // Resolve runtime using the same precedence as `config-get runtime`.
+        const { resolveRuntime } = require('./lib/runtime-slash.cjs');
+        const runtimeId = resolveRuntime(cwd);
+
+        // Look up dispatch from the capability registry.
+        const registry = require('./lib/capability-registry.cjs');
+        const runtimeEntry = registry.runtimes != null
+          ? registry.runtimes[runtimeId]
+          : null;
+        const dispatch = runtimeEntry?.runtime?.hostIntegration?.dispatch ?? null;
+
+        // Call shouldFlattenDispatch from host-integration.cjs.
+        const hostIntegration = require('./lib/host-integration.cjs');
+        const shouldFlat = dispatch !== null
+          ? hostIntegration.shouldFlattenDispatch(dispatch)
+          : true; // fail-closed: unknown runtime → inline
+
+        const jsonIdx = args.indexOf('--json');
+        if (jsonIdx !== -1) {
+          output({
+            runtime: runtimeId,
+            shouldFlatten: shouldFlat,
+            dispatch: dispatch,
+          }, raw);
+        } else {
+          // --raw or default: print exactly true or false
+          process.stdout.write(shouldFlat ? 'true' : 'false');
+        }
+      } catch {
+        // Fail-closed on any error: inline is always safe.
+        process.stdout.write('true');
+      }
+      break;
+    }
+
     case 'config-new-project': {
       // Phase 6 (#3575): dispatch via SDK executeForCjs when available.
       const handled = _dispatchNonFamily({
@@ -1310,6 +1384,43 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
       break;
     }
 
+    case 'assumption-delta': {
+      // #1561 — advisory architecture checkpoint. `scan <phase>` reads the
+      // phase section via the same resolver as roadmap.get-phase and runs the
+      // deterministic detectAssumptionDelta, emitting the typed IR as JSON.
+      const sub = args[1];
+      if (sub === 'scan') {
+        const phaseNum = args[2];
+        // Reject missing or flag-shaped phase values (QA matrix: values that
+        // look like flags). `scan --json` must not treat "--json" as a phase.
+        if (!phaseNum || phaseNum.startsWith('-')) {
+          error('Usage: assumption-delta scan <phase> [--terms <csv>]', ERROR_REASON.SDK_UNKNOWN_COMMAND);
+          break;
+        }
+        // Optional --terms <csv> override (replaces the pluralization cues;
+        // optional/chosen keep defaults). An EMPTY value ("") or a flag-shaped
+        // value restores the curated defaults (does NOT disable pluralization).
+        // Terms are normalized (deduped, alphanumeric-only, capped) by
+        // detectAssumptionDelta's resolveTerms.
+        let termsOverride;
+        const termsIdx = args.indexOf('--terms');
+        const termsVal = termsIdx !== -1 ? args[termsIdx + 1] : undefined;
+        if (typeof termsVal === 'string' && !termsVal.startsWith('-')) {
+          const list = termsVal
+            .split(',')
+            .map((t) => t.trim().toLowerCase())
+            .filter((t) => t.length > 0);
+          termsOverride = list.length > 0 ? { pluralization: list } : undefined;
+        }
+        const section = roadmap.getRoadmapPhaseWithFallback(cwd, phaseNum);
+        const result = detectAssumptionDelta(section ?? '', termsOverride);
+        output(result, raw);
+        break;
+      }
+      error(`Unknown assumption-delta subcommand: ${sub}. Available: scan`, ERROR_REASON.SDK_UNKNOWN_COMMAND);
+      break;
+    }
+
     case 'requirements': {
       const subcommand = args[1];
       if (subcommand === 'mark-complete') {
@@ -1342,7 +1453,9 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
       const subcommand = args[1];
       if (subcommand === 'complete') {
         const milestoneName = parseMultiwordArg(args, 'name');
-        const archivePhases = args.includes('--archive-phases');
+        // #1871: archive phase dirs by default on milestone complete so the next
+        // new-milestone never inherits un-archived dirs. --no-archive-phases opts out.
+        const archivePhases = !args.includes('--no-archive-phases');
         const force = args.includes('--force');
         milestone.cmdMilestoneComplete(cwd, args[2], { name: milestoneName, archivePhases, force }, raw);
       } else {
@@ -1414,6 +1527,10 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
     }
 
     case 'init': {
+      // #1688: warn (at most once per process) if the user edited model_overrides
+      // without re-running `gsd install <runtime>` on a static-frontmatter runtime.
+      // Best-effort, stderr-only, swallowed errors — never blocks the command.
+      try { warnIfStaleBake(cwd); } catch { /* guard must never break init */ }
       routeInitCommand({
         init,
         args,
@@ -1550,13 +1667,22 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
         return undefined;
       };
       // Running GSD version (hard gate for engines.gsd at install/load); fail-closed to 0.0.0.
+      // #1920: prefer the authoritative gsd-core/VERSION the installer writes for EVERY runtime
+      // (gsd-core/bin/ -> ../VERSION), so installed layouts report the true version even when the
+      // walked-up ../../package.json is the versionless CommonJS marker or the user's own project.
+      // Fall back to the runtime-root package.json (dev/source tree), then fail-closed. Mirrors
+      // readHostVersion() in capability-loader.cts.
       const capHostVersion = () => {
+        const SEMVER_PREFIX = /^\d+\.\d+\.\d+/;
         try {
-          const pkg = require('../../package.json'); // gsd-core/bin/ -> repo root is two up
-          return typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
-        } catch {
-          return '0.0.0';
-        }
+          const v = fs.readFileSync(path.join(__dirname, '..', 'VERSION'), 'utf8').trim();
+          if (SEMVER_PREFIX.test(v)) return v;
+        } catch { /* not an installed tree (no gsd-core/VERSION) */ }
+        try {
+          const pkg = require(path.join(__dirname, '..', '..', 'package.json')); // gsd-core/bin/ -> repo root is two up
+          if (pkg && typeof pkg.version === 'string' && SEMVER_PREFIX.test(pkg.version)) return pkg.version;
+        } catch { /* runtime root has no package.json */ }
+        return '0.0.0';
       };
       // #1459: the USER-OWNED consent home (GSD_HOME||homedir()) where project-scope consent records
       // live — OUTSIDE any repo. SAME rule as the loader/consent-store path resolution so a record

package/gsd-core/bin/lib/adapter-declarative.cjs

@@ -0,0 +1,35 @@
+/**
+ * Declarative embedding adapter (ADR-1239 Phase C-1, AC1 / #1680).
+ *
+ * NAMES + BOUNDS today's projection path (file emission via install-engine)
+ * behind `HostIntegrationInterface`. The declarative adapter is lossy by
+ * design: it projects skills/agents/commands and does NOT drive the loop
+ * orchestration (that is the imperative adapter's job, AC2 / a later slice).
+ *
+ * `install`/`uninstall` delegate IN-PROCESS to install-engine's
+ * `installRuntimeArtifacts` / `uninstallRuntimeArtifacts` — the SAME engine
+ * functions `bin/install.js` uses — so the adapter's output is byte-identical to
+ * today's install (the link is gated by `tests/golden-install-parity.test.cjs`).
+ * The module-ref call style (`installEngine.fn`) keeps it monkeypatch-friendly
+ * for tests, mirroring the install-engine.cts:31-38 pattern.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeclarativeAdapter = createDeclarativeAdapter;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const installEngine = require("./install-engine.cjs");
+function createDeclarativeAdapter({ runtime }) {
+    if (!runtime || typeof runtime !== 'string') {
+        throw new TypeError('createDeclarativeAdapter: runtime is required (non-empty string)');
+    }
+    return Object.freeze({
+        kind: 'declarative',
+        runtime,
+        install(intent) {
+            installEngine.installRuntimeArtifacts(runtime, intent.configDir, intent.scope, intent.resolvedProfile, intent.resolveAttribution);
+        },
+        uninstall(intent) {
+            installEngine.uninstallRuntimeArtifacts(runtime, intent.configDir, intent.scope);
+        },
+    });
+}

package/gsd-core/bin/lib/adapter-imperative.cjs

@@ -0,0 +1,52 @@
+/**
+ * Imperative embedding adapter (ADR-1239 Phase C-1, AC2 / #1680).
+ *
+ * The engine-as-library path: an in-process host plugin calls
+ * `createImperativeAdapter({runtime})`, which composes the capability registry
+ * via `loadRegistry({includeInstalled:true})` (first-party-wins + consent +
+ * fail-closed gates) and binds the engine surface behind the SAME
+ * `HostIntegrationInterface` the declarative adapter satisfies. The adapter
+ * stays thin — it does NOT reimplement the loop resolver; it delegates to the
+ * engine + exposes the composed registry so a host (Phase 5) can bind its
+ * primitives (command/dispatch/model/hooks/state/artifact) to the registry's
+ * declared capability set.
+ *
+ * Concrete host binding (OpenCode/VS Code/pi) is deferred to Phase 5 (#1682,
+ * D15/D18). This slice ships the adapter + the composed-registry seam.
+ *
+ * Minimal interface (per ADR-1239 open wire-shape question): satisfies the
+ * same `{kind, runtime, install, uninstall}` shape as the declarative adapter,
+ * plus an imperative-specific `registry` accessor (the composed loadRegistry
+ * result). The full 6-point binding surface grows when a real host consumer
+ * fixes the shape.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImperativeAdapter = createImperativeAdapter;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const installEngine = require("./install-engine.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const capabilityLoader = require("./capability-loader.cjs");
+function createImperativeAdapter({ runtime }, options = {}) {
+    if (!runtime || typeof runtime !== 'string') {
+        throw new TypeError('createImperativeAdapter: runtime is required (non-empty string)');
+    }
+    // Compose first-party ∪ installed capability overlays with the SAME
+    // precedence, consent, and fail-closed-gate guarantees the CLI enforces —
+    // an in-process host gets identical trust semantics, not a parallel path.
+    const registry = capabilityLoader.loadRegistry({
+        includeInstalled: true,
+        ...(options.loadOptions ?? {}),
+    });
+    return Object.freeze({
+        kind: 'imperative',
+        runtime,
+        registry,
+        install(intent) {
+            installEngine.installRuntimeArtifacts(runtime, intent.configDir, intent.scope, intent.resolvedProfile, intent.resolveAttribution);
+        },
+        uninstall(intent) {
+            installEngine.uninstallRuntimeArtifacts(runtime, intent.configDir, intent.scope);
+        },
+    });
+}

package/gsd-core/bin/lib/assumption-delta.cjs

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Assumption-Delta detector (#1561).
+ *
+ * A rarely-firing, advisory architecture checkpoint. When a phase makes
+ * something PLURAL / OPTIONAL / CHOSEN that used to be SINGULAR / REQUIRED /
+ * DERIVED, the primary key / identity model may silently stop matching the
+ * generalized intent. This detector scans phase-scope prose for the linguistic
+ * signals of that transition so the plan:pre capability hook (see
+ * capabilities/assumption-delta/) can surface ONE identity-model question.
+ *
+ * Design notes (rubber-duck'd):
+ *  - DETERMINISTIC + TYPED IR. The "does it fire?" decision is a pure function
+ *    returning { detected, signals, terms }, not an LLM judgment — so the
+ *    low-false-positive guarantee (acceptance criterion #2) is testable.
+ *  - BARE "or" IS INTENTIONALLY EXCLUDED from the default pluralization cues.
+ *    The issue lists "or" as a tell, but bare "or" is extremely common in
+ *    English prose and would make the gate fire on nearly every phase
+ *    description. Pluralization requires a stronger second-case cue
+ *    (second / alternative / fallback / additional / ...). The vocabulary is
+ *    tunable (config + the `terms` parameter) so teams can widen it.
+ *  - FENCED CODE BLOCKS ARE STRIPPED first (via the markdown-sectionizer seam)
+ *    so a trigger term that appears only inside a code snippet does not fire.
+ *  - Mirrors ui-safety-gate.cts: a pure function + a STDIN-reading CLI whose
+ *    exit codes mirror grep (0 = signal found, 1 = none, 2 = usage error).
+ *
+ * Public API:
+ *   detectAssumptionDelta(text, terms?) -> { detected, signals, terms }
+ *   DEFAULT_ASSUMPTION_DELTA_TERMS
+ *
+ * CLI:
+ *   echo "$PHASE_SECTION" | node gsd-core/bin/lib/assumption-delta.cjs [--json]
+ *     exit 0 = signal detected, 1 = none, 2 = startup error
+ *     --json additionally prints the typed IR on stdout
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ASSUMPTION_DELTA_TERMS = void 0;
+exports.detectAssumptionDelta = detectAssumptionDelta;
+const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
+/**
+ * Curated default trigger vocabulary. Each kind lists cue terms that signal a
+ * core-assumption monopoly has been lost. ADDITIVE-ONLY (Hyrum's Law: once
+ * shipped, this set is a depended-upon interface). Tunable via the `terms`
+ * parameter or the capability's config slice.
+ */
+exports.DEFAULT_ASSUMPTION_DELTA_TERMS = {
+    // Primary trigger — a second X where there was one.
+    // Bare "or" excluded (prose-frequency false positives).
+    pluralization: [
+        'second',
+        'alternative',
+        'alternate',
+        'fallback',
+        'also',
+        'additional',
+        'another',
+        'supplementary',
+        'alongside',
+        'multiple',
+        'plural',
+        '2nd',
+    ],
+    // required / `only` -> optional
+    optional: ['optional', 'optionally'],
+    // derived -> chosen / constant -> parameter
+    chosen: [
+        'chosen',
+        'choose',
+        'selectable',
+        'configurable',
+        'parameterized',
+        'parameterised',
+        'parameterize',
+        'parameterise',
+        'custom',
+    ],
+};
+/** Hardening caps for the tunable term vocabulary (Codex review finding). */
+const MAX_TERMS_PER_KIND = 200;
+const MAX_TERM_LEN = 32;
+/**
+ * Normalize a caller-provided term list: trim, lowercase, reject empties and
+ * punctuation-only terms (e.g. "-"), dedupe (preserve order), and cap the
+ * count/length so a huge or hostile `--terms` value cannot build a giant
+ * alternation regex or echo a massive payload. Defaults are already clean, so
+ * this is a no-op on them.
+ */
+function normalizeTerms(list) {
+    if (!Array.isArray(list))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const raw of list) {
+        if (typeof raw !== 'string')
+            continue;
+        const t = raw.trim().toLowerCase().slice(0, MAX_TERM_LEN);
+        // Require at least one alphanumeric char so punctuation-only terms like
+        // "-" cannot match prose punctuation as a "signal".
+        if (!t || !/[a-z0-9]/.test(t))
+            continue;
+        if (seen.has(t))
+            continue;
+        seen.add(t);
+        out.push(t);
+        if (out.length >= MAX_TERMS_PER_KIND)
+            break;
+    }
+    return out;
+}
+/**
+ * Resolve the effective term set: per-kind override. An explicitly-provided
+ * non-empty array for a kind REPLACES that kind's defaults (then normalized);
+ * an absent kind KEEPS its defaults. An explicitly-empty array disables that
+ * kind (override present, normalized to []). This lets a caller narrow one axis
+ * without re-declaring the others.
+ */
+function resolveTerms(terms) {
+    const merge = (key) => {
+        const t = terms && terms[key];
+        return Array.isArray(t) ? normalizeTerms(t) : [...exports.DEFAULT_ASSUMPTION_DELTA_TERMS[key]];
+    };
+    return {
+        pluralization: merge('pluralization'),
+        optional: merge('optional'),
+        chosen: merge('chosen'),
+    };
+}
+/** Trim + collapse + truncate a context window around a match for the snippet. */
+function makeSnippet(line, term) {
+    const cleaned = line.replace(/\s+/g, ' ').trim();
+    if (cleaned.length <= 120)
+        return cleaned;
+    // Centre the window on the matched term when the line is long.
+    const idx = cleaned.toLowerCase().indexOf(term);
+    if (idx < 0)
+        return cleaned.slice(0, 120);
+    const start = Math.max(0, idx - 50);
+    const end = Math.min(cleaned.length, idx + term.length + 50);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < cleaned.length ? '…' : '';
+    return `${prefix}${cleaned.slice(start, end)}${suffix}`;
+}
+/**
+ * Detect assumption-delta signals in phase-scope prose.
+ *
+ * @param text - Roadmap phase section / scope prose. Non-string inputs degrade
+ *   to `{ detected: false }` without throwing.
+ * @param terms - Optional per-kind override (see resolveTerms).
+ * @returns typed IR: { detected, signals[], terms }. `terms` is the effective
+ *   (merged) set actually used, so callers/tests can audit what fired.
+ */
+function detectAssumptionDelta(text, terms) {
+    if (typeof text !== 'string') {
+        return { detected: false, signals: [], terms: resolveTerms(terms) };
+    }
+    const effective = resolveTerms(terms);
+    // Strip fenced code blocks so trigger terms inside code snippets do not fire.
+    // stripFencedCode is CommonMark-correct and CRLF-safe.
+    const stripped = (0, markdown_sectionizer_cjs_1.stripFencedCode)(text.replace(/\r\n/g, '\n')).text;
+    if (stripped.trim().length === 0) {
+        return { detected: false, signals: [], terms: effective };
+    }
+    const signals = [];
+    const kinds = ['pluralization', 'optional', 'chosen'];
+    for (const kind of kinds) {
+        const cueTerms = effective[kind];
+        if (cueTerms.length === 0)
+            continue;
+        // Word-boundary anchored, case-insensitive — same shape as ui-safety-gate.
+        // (^|[^a-zA-Z0-9])(TERM)([^a-zA-Z0-9]|$) prevents interior-substring matches.
+        const escaped = cueTerms.map(escapeRegex).join('|');
+        const pattern = new RegExp('(^|[^a-zA-Z0-9])(' + escaped + ')([^a-zA-Z0-9]|$)', 'gi');
+        const seen = new Set();
+        for (const line of stripped.split('\n')) {
+            pattern.lastIndex = 0;
+            for (const m of line.matchAll(pattern)) {
+                const raw = m[2];
+                if (!raw)
+                    continue;
+                const matched = raw.toLowerCase();
+                const key = `${kind}:${matched}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                signals.push({ kind, term: matched, snippet: makeSnippet(line, matched) });
+            }
+        }
+    }
+    return { detected: signals.length > 0, signals, terms: effective };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// ── CLI entry point ──────────────────────────────────────────────────────────
+// Reads phase-section text from STDIN (not argv) to avoid OS ARG_MAX limits.
+// Invoked by workflow bash as: echo "$PHASE_SECTION" | node .../assumption-delta.cjs [--json]
+// Exit 0 = signal detected, 1 = none, 2 = startup error. Mirrors ui-safety-gate.
+if (require.main === module) {
+    const argv = process.argv.slice(2);
+    const wantJson = argv.includes('--json');
+    // --terms <csv>: config-tunable vocabulary override. Replaces the
+    // pluralization cues (the primary trigger); optional/chosen keep defaults.
+    // An EMPTY value ("") or a flag-shaped value restores the curated defaults
+    // (does NOT disable pluralization). Terms are normalized (deduped, etc.) by
+    // detectAssumptionDelta's resolveTerms.
+    let termsOverride;
+    const termsIdx = argv.indexOf('--terms');
+    const termsVal = termsIdx !== -1 ? argv[termsIdx + 1] : undefined;
+    if (typeof termsVal === 'string' && !termsVal.startsWith('-')) {
+        const list = termsVal
+            .split(',')
+            .map((t) => t.trim().toLowerCase())
+            .filter((t) => t.length > 0);
+        termsOverride = list.length > 0 ? { pluralization: list } : undefined;
+    }
+    const chunks = [];
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => {
+        const input = chunks.join('');
+        const result = detectAssumptionDelta(input, termsOverride);
+        if (wantJson) {
+            process.stdout.write(JSON.stringify(result) + '\n');
+        }
+        process.exit(result.detected ? 0 : 1);
+    });
+    process.stdin.on('error', (err) => {
+        process.stderr.write(`ERROR: assumption-delta.cjs stdin read failed: ${err.message}\n`);
+        process.exit(2);
+    });
+}

package/gsd-core/bin/lib/capability-lifecycle.cjs

@@ -33,7 +33,7 @@ const consentMod = require('./capability-consent.cjs');
 const projectRootMod = require('./project-root.cjs');
 // #1459 finding 4: the SHARED hardened lock primitive (single source of truth for lifecycle + consent).
 const lockMod = require('./capability-lock.cjs');
-const { platformWriteSync } = require('./shell-command-projection.cjs');
+const { platformWriteSync, retryRenameSync } = require('./shell-command-projection.cjs');
 // #1463: numeric major.minor.patch comparison for the outdated check (the SAME compare the resolver
 // and capability list use). -1 (a<b), 0 (equal), 1 (a>b).
 const semverMod = require('./semver-compare.cjs');
@@ -369,16 +369,16 @@ function promoteStagingToFinal(stagingDir, finalDir, backupName) {
             ? node_path_1.default.join(parent, backupName)
             // CONC-3: a random nonce in the unnamed-branch backup name prevents same-ms cross-process collision.
             : node_path_1.default.join(parent, newBackupName(node_path_1.default.basename(finalDir)));
-        node_fs_1.default.renameSync(finalDir, backupDir);
+        retryRenameSync(finalDir, backupDir);
         // DUR-3: fsync the parent dir so the old→backup rename is durable BEFORE the second rename —
         // a crash here must not lose the backup (the only recovery path for reconcile).
         fsyncDir(parent);
         try {
-            node_fs_1.default.renameSync(stagingDir, finalDir);
+            retryRenameSync(stagingDir, finalDir);
         }
         catch (err) {
             try {
-                node_fs_1.default.renameSync(backupDir, finalDir);
+                retryRenameSync(backupDir, finalDir);
             }
             catch { /* best-effort restore */ }
             throw err;
@@ -388,7 +388,7 @@ function promoteStagingToFinal(stagingDir, finalDir, backupName) {
         return { backupDir };
     }
     node_fs_1.default.mkdirSync(parent, { recursive: true });
-    node_fs_1.default.renameSync(stagingDir, finalDir);
+    retryRenameSync(stagingDir, finalDir);
     fsyncDir(parent); // DUR-3: durable fresh-install promotion.
     return { backupDir: null };
 }
@@ -1330,8 +1330,8 @@ function reconcileCapabilities(opts) {
                             //   - crash after step (b): old bundle live at finalDir; only the aside copy leaks → swept.
                             const discard = `${finalDir}.discard-${process.pid}-${Date.now()}-${node_crypto_1.default.randomBytes(4).toString('hex')}`;
                             if (node_fs_1.default.existsSync(finalDir))
-                                node_fs_1.default.renameSync(finalDir, discard); // (a) set the new dir aside
-                            node_fs_1.default.renameSync(backupDir, finalDir); // (b) restore the old bundle
+                                retryRenameSync(finalDir, discard); // (a) set the new dir aside
+                            retryRenameSync(backupDir, finalDir); // (b) restore the old bundle
                             fsyncDir(root); // make the restore durable
                             try {
                                 node_fs_1.default.rmSync(discard, { recursive: true, force: true });