@opengsd/gsd-core 1.9.1 → 1.11.0

package/gsd-core/bin/lib/api-coverage.cjs

@@ -63,6 +63,7 @@ exports.parseCoverageMatrix = parseCoverageMatrix;
 exports.validateCoverageMatrix = validateCoverageMatrix;
 exports.renderCoverageMatrix = renderCoverageMatrix;
 const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
+const pattern_cjs_1 = require("./pattern.cjs");
 /**
  * Curated default trigger vocabulary. ADDITIVE-ONLY (Hyrum's Law). Tunable via
  * the `terms` parameter.
@@ -156,9 +157,6 @@ function resolveTerms(terms) {
     };
     return { verbs: merge('verbs'), nouns: merge('nouns') };
 }
-function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function makeSnippet(line, anchor) {
     const cleaned = line.replace(/\s+/g, ' ').trim();
     if (cleaned.length <= 120)
@@ -238,6 +236,30 @@ const SURFACE_DESCRIPTOR_WORDS = new Set([
  *  EXTERNAL-API surface signal. Only unambiguously-internal words: "external"
  *  is deliberately absent (an external API IS external). */
 const INTERNAL_DESCRIPTORS = new Set(['internal', 'in-house', 'local', 'first-party', 'private']);
+/** #2784: negation suppression. A clause that pairs an integration verb with an
+ *  API noun but the verb itself is directly negated (e.g. "does not integrate",
+ *  "integrates no external API") is suppressed. Two windows are checked: a
+ *  negation qualifier within 2 words directly before the verb, or "no"/"zero"/
+ *  "none" between the verb and a following noun.
+ *  KNOWN LIMIT (deliberate, not a bug to fix later): a negation further than 2
+ *  words before the verb, or a clause where the noun precedes the verb, is NOT
+ *  suppressed — e.g. "Ships without any API integration." still reports
+ *  detected:true, because "without" sits outside the verb's 2-word lookback
+ *  and the noun precedes the verb. This is intentional: detectApiIntegration
+ *  is fail-closed — an unsuppressed false positive costs a one-line
+ *  COVERAGE.md declaration, while widening the suppression window risks a
+ *  false negative that silently lets a real external-API phase past a
+ *  blocking gate.
+ *  Hoisted to module scope (#3127 regression fix): this was previously
+ *  allocated fresh on every source line, which is wasted work on documents
+ *  with many lines. */
+const NEGATION_QUALIFIERS = new Set([
+    'no', 'not', 'without', 'zero', 'neither', 'nor', 'none', "don't", "doesn't", "didn't", "won't", "can't", "cannot",
+]);
+/** Negation tokens checked BETWEEN a verb and a later noun (narrower than
+ *  NEGATION_QUALIFIERS — "not" and "without" are checked only immediately
+ *  before the verb, via NEGATION_QUALIFIERS above). */
+const NEGATION_NOUN_TOKENS = new Set(['no', 'zero', 'none']);
 /** A capitalized compound modifier ("Resolver-only", "Read-only", "E-commerce"
  *  — lowercase letter right after the hyphen) is an adjective phrase, not a
  *  service name. Real hyphenated services capitalize the second segment
@@ -378,10 +400,10 @@ function detectApiIntegration(text, terms) {
     // Trailing boundary is a LOOKAHEAD (not consumed) so back-to-back terms
     // separated by one boundary char are both found.
     const verbRe = hasCompoundTerms
-        ? new RegExp('(^|[^a-zA-Z0-9])(' + effective.verbs.map(escapeRegex).join('|') + ')(?=[^a-zA-Z0-9]|$)', 'gi')
+        ? new RegExp('(^|[^a-zA-Z0-9])(' + effective.verbs.map(pattern_cjs_1.escapeRegex).join('|') + ')(?=[^a-zA-Z0-9]|$)', 'gi')
         : null;
     const nounRe = hasCompoundTerms
-        ? new RegExp('(^|[^a-zA-Z0-9])(' + effective.nouns.map(escapeRegex).join('|') + ')(?=[^a-zA-Z0-9]|$)', 'gi')
+        ? new RegExp('(^|[^a-zA-Z0-9])(' + effective.nouns.map(pattern_cjs_1.escapeRegex).join('|') + ')(?=[^a-zA-Z0-9]|$)', 'gi')
         : null;
     const surfaceRe = new RegExp(SERVICE_SURFACE_API_RE.source, 'g');
     const nounSet = new Set(effective.nouns);
@@ -421,11 +443,45 @@ function detectApiIntegration(text, terms) {
         // boundary is the whole relationship test. Nouns are NOT filtered on
         // "internal" qualification here — "integrate the internal API" is a
         // fail-closed positive; the declaration dismisses it if wrong.
+        //
+        // #2784: negation suppression. A clause that pairs an integration verb with
+        // an API noun but the verb itself is directly negated (e.g. "does not
+        // integrate", "integrates no external API") is suppressed. The check is
+        // scoped to the verb's immediate context (the word directly before the
+        // verb, or the word directly between verb and noun) — NOT a blanket
+        // clause-wide scan, because "without changing runtime dependencies" in a
+        // long clause does NOT negate the integration.
+        // KNOWN LIMIT (deliberate, not a bug to fix later): a negation further than
+        // 2 words before the verb, or a clause where the noun precedes the verb, is
+        // NOT suppressed — e.g. "Ships without any API integration." is NOT
+        // suppressed today (pinned by a test in tests/api-coverage.test.cjs).
+        // detectApiIntegration is fail-closed by design: an unsuppressed false
+        // positive costs a one-line COVERAGE.md declaration, while widening the
+        // window trades that for a silent false negative on a blocking gate.
         if (verbRe && nounRe) {
             for (const clause of clauses) {
                 const verbs = collectTermMatches(verbRe, clause.text);
                 if (verbs.length === 0)
                     continue;
+                // #2784: check if any verb is immediately preceded by a negation
+                // qualifier (within 2 words before the verb match).
+                //
+                // OFFSET NOTE: `v.start`/`n.start` (from collectTermMatches below and
+                // above) are already CLAUSE-LOCAL — collectTermMatches was called with
+                // `clause.text`, not the full line — and so is `clauseText`
+                // (`clause.text.toLowerCase()`). They must be used AS-IS to index into
+                // `clauseText`; do not re-base them against `clause.start` (that field
+                // is the clause's offset within the LINE, a different coordinate space,
+                // used only to map line-level spans like `extraNouns`/`masked` into a
+                // clause). Subtracting `clause.start` here double-offsets the slice
+                // bounds for every clause after the first on a line (#3127 follow-up).
+                const clauseText = clause.text.toLowerCase();
+                const hasNegatedVerb = verbs.some((v) => {
+                    const before = clauseText.slice(Math.max(0, v.start - 20), v.start);
+                    const beforeWords = before.split(/\s+/).filter(Boolean).slice(-2);
+                    return beforeWords.some((w) => NEGATION_QUALIFIERS.has(w.replace(/[^a-z']/g, '')));
+                });
+                // Also check if "no"/"zero"/"none" appears between the verb and the noun.
                 const nouns = collectTermMatches(nounRe, clause.text);
                 const nounTerms = new Set(nouns.map((t) => t.term));
                 for (const u of extraNouns) {
@@ -435,6 +491,68 @@ function detectApiIntegration(text, terms) {
                 }
                 if (nounTerms.size === 0)
                     continue;
+                // Check for negation between verb and noun.
+                //
+                // #3127 regression: the original form of this check was
+                // O(verbs × nouns), re-slicing and re-splitting the clause text for
+                // every (verb, noun) pair — effectively cubic in clause length (a
+                // clause of N repeated "integrate api" pairs did O(N^2) pair checks,
+                // each doing an O(N) slice/split). On a clause with 800 repeated
+                // pairs this took ~8.5s; fast-check's property test then generated
+                // documents large enough to hang the whole test file past node:test's
+                // 600s timeout. It ALSO subtracted `clause.start` from `v.start`/
+                // `n.start` before slicing `clauseText` — but `v.start`/`n.start` are
+                // already local to `clause.text` (collectTermMatches was called with
+                // clause.text, not the full line), and `clauseText` is exactly
+                // `clause.text.toLowerCase()`. So that subtraction double-offset the
+                // slice bounds for every clause after the first on a line, sliding
+                // (and for negative results, JS's negative-index slice() wraparound
+                // non-monotonically re-mapping) the window to characters unrelated to
+                // the verb/noun pair — an independent latent bug, fixed here as part
+                // of establishing a well-defined O(1) predicate (a piecewise/clamped
+                // window has no single "widest span" to reason about at all).
+                //
+                // EXACT-EQUIVALENCE, single pass: the predicate is "does any pair
+                // (v, n) with n.start > v.start have a negation token in the span
+                // (v.end, n.start)". Every such span is a SUBSET of the widest
+                // possible span for a given noun: [min(v.end) over verbs valid for
+                // that noun, n.start). And since that window only widens as a
+                // noun's start increases (more verbs become valid, and the noun
+                // bound itself grows), the single widest span across the WHOLE
+                // clause is anchored at the noun with the maximum start, using the
+                // minimum verb-end among verbs valid for THAT noun (not the global
+                // minimum verb-end, which could belong to a verb that starts after
+                // this noun and so is never a valid pairing with it — a mismatch
+                // that would either miss or falsely include a negation). If that one
+                // substring contains no negation token, no narrower pair-specific
+                // substring can either; if it does, the (minVerb, maxNoun) pair
+                // itself contains it. This drops the check to O(verbs + nouns).
+                let hasNegatedNoun = false;
+                if (nouns.length > 0) {
+                    let minVerbStart = Infinity;
+                    for (const v of verbs)
+                        if (v.start < minVerbStart)
+                            minVerbStart = v.start;
+                    let maxNounStart = -Infinity;
+                    for (const n of nouns)
+                        if (n.start > maxNounStart)
+                            maxNounStart = n.start;
+                    if (maxNounStart > minVerbStart) {
+                        let minQualifyingVerbEnd = Infinity;
+                        for (const v of verbs) {
+                            if (v.start < maxNounStart) {
+                                const vEnd = v.start + v.term.length;
+                                if (vEnd < minQualifyingVerbEnd)
+                                    minQualifyingVerbEnd = vEnd;
+                            }
+                        }
+                        const between = clauseText.slice(minQualifyingVerbEnd, maxNounStart);
+                        const betweenWords = between.split(/\s+/).filter(Boolean);
+                        hasNegatedNoun = betweenWords.some((w) => NEGATION_NOUN_TOKENS.has(w.replace(/[^a-z']/g, '')));
+                    }
+                }
+                if (hasNegatedVerb || hasNegatedNoun)
+                    continue;
                 for (const vTerm of new Set(verbs.map((t) => t.term))) {
                     for (const nTerm of nounTerms)
                         emitPair(vTerm, nTerm, rawLine);

package/gsd-core/bin/lib/artifacts.cjs

@@ -27,6 +27,9 @@ exports.CANONICAL_EXACT = new Set([
     'config.json',
     'CLAUDE.md',
     'RETROSPECTIVE.md',
+    'WINDOWS.md', // #3224: broken-windows ledger (src/broken-windows.cts, LEDGER_FILE_NAME)
+    'STATE-ARCHIVE.md', // state.cts's cmdStatePrune writes this at the .planning/ root
+    'milestone.lock', // #3311: milestone (phase + session) claim (src/milestone-lock.cts); persistent, unlike the transient STATE.md.lock/WAITING.json
 ]);
 // Pattern-match canonical file names (regex tests on the basename)
 // Each pattern includes the name of the workflow that produces it as a comment.

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

@@ -37,6 +37,7 @@ 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");
+const pattern_cjs_1 = require("./pattern.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
@@ -168,7 +169,7 @@ function detectAssumptionDelta(text, terms) {
             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 escaped = cueTerms.map(pattern_cjs_1.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')) {
@@ -188,9 +189,6 @@ function detectAssumptionDelta(text, terms) {
     }
     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]

package/gsd-core/bin/lib/audit-command-router.cjs

@@ -71,7 +71,7 @@ function routeAuditOpen({ args, cwd, raw, error, _audit, _core }) {
     routeHubCommandFamily({
         family: 'audit-open',
         args: hubArgs,
-        subcommands: ['run'],
+        subcommands: ['run', 'acknowledge'],
         defaultSubcommand: 'run',
         handlers: {
             run: () => {
@@ -86,8 +86,15 @@ function routeAuditOpen({ args, cwd, raw, error, _audit, _core }) {
                     c.output(null, true, a.formatAuditReport(result));
                 }
             },
+            // #3458 follow-up (design point A4): `audit-open acknowledge --category
+            // ... --milestone ...` writes/refreshes an `audit_acknowledged`
+            // suppression marker. `hubArgs.slice(2)` drops the family token and the
+            // `acknowledge` subcommand token itself, leaving just this
+            // subcommand's OWN `--flag value` pairs — the same slice
+            // `routeHubCommandFamily` itself passes to `hub.dispatch`'s `args`.
+            acknowledge: () => a.cmdAuditAcknowledge(cwd, hubArgs.slice(2), raw),
         },
-        unknownMessage: (subcommand) => `Unknown audit-open subcommand: "${subcommand}". audit-open takes no subcommands (use --json for JSON output).`,
+        unknownMessage: (subcommand) => `Unknown audit-open subcommand: "${subcommand}". Available: run (default, use --json for JSON output), acknowledge.`,
         error,
         cwd,
         raw,