@opengsd/gsd-core 1.5.0 → 1.6.0-rc.1

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

@@ -8,67 +8,56 @@
  * Accepts both numeric (D-42) and alphanumeric (D-INFRA-01) IDs.
  * Returns {id, text, category, tags, trackable} per decision.
  * CJS callers that only use {id, text} safely ignore the extra fields.
+ *
+ * ADR-1372 T1: rewritten to adopt the markdown-sectionizer seam.
+ * - `stripFencedCode` → seam's `stripFencedCode` (CommonMark-correct)
+ * - `extractDecisionsBlock` → seam's `extractTaggedBlocks(content,'decisions')`
+ * - Markdown-header fallback → seam's `collectSection(content, /decisions?/i, ...)`
+ * - Outer bullet loop → seam's `iterateBullets` (for the header-fallback path)
+ *
+ * Resolves #1364 (markdown-header + em-dash recall) and #1365 (fail-loud gate).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDecisions = extractDecisions;
 exports.parseDecisions = parseDecisions;
+const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 const DISCRETION_HEADINGS = new Set([
     "claude's discretion",
     'claudes discretion',
     'claude discretion',
 ]);
 const NON_TRACKABLE_TAGS = new Set(['informational', 'folded', 'deferred']);
+// ─── Bullet parsers (decisions-specific grammar) ─────────────────────────────
 /**
- * Strip fenced code blocks from `content` so example `<decisions>` snippets
- * inside ```` ``` ```` do not pollute the parser (review F11).
+ * Colon form: `- **D-NN[ [tags]]:** text`
+ * (#1343: `[^:*]*` subsumes any pre-colon prose, stops at `:**`)
  */
-function stripFencedCode(content) {
-    return content.replace(/```[\s\S]*?```/g, ' ').replace(/~~~[\s\S]*?~~~/g, ' ');
-}
+const bulletColonRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?[^:*]*:\*\*\s*(.*)$/;
 /**
- * Extract the inner text of EVERY `<decisions>...</decisions>` block in
- * order, concatenated by `\n\n`. Returns null when no block is present.
+ * Em-dash form: `- **D-NN[ [tags]] — title** body`
+ * The em-dash (U+2014) or its lookalike separates the ID+tags group from a title
+ * that lives inside the bold markers; the body (which may be empty) follows
+ * outside the closing `**`. This form was not handled pre-T1 (bug #1364).
  *
- * CONTEXT.md may legitimately contain more than one block (for example, a
- * "current decisions" block plus a "carry-over from prior phase" block);
- * dropping all-but-the-first silently lost the second batch (review F13).
+ * Accepts both U+2014 em-dash (—) and U+2013 en-dash (–) for robustness.
  */
-function extractDecisionsBlock(content) {
-    const cleaned = stripFencedCode(content);
-    const matches = [...cleaned.matchAll(/<decisions>([\s\S]*?)<\/decisions>/g)];
-    if (matches.length === 0)
-        return null;
-    return matches.map((m) => m[1]).join('\n\n');
-}
+const bulletEmDashRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?[^*]*[—–][^*]*\*\*\s*(.*)$/;
 /**
- * Parse trackable decisions from CONTEXT.md content.
+ * Parse decision lines from a block of text (the inner text of a <decisions>
+ * or markdown-header section body). Returns the extracted decisions and a count
+ * of parse-misses (lines that looked like D-NN bullets but failed both regexes).
  *
- * Returns ALL D-NN decisions found inside `<decisions>` (including
- * non-trackable ones, with `trackable: false`). Callers that only want the
- * gate-enforced decisions should filter `.filter(d => d.trackable)`.
+ * FIX B (#1365): parseMisses > 0 means the caller must treat the result as
+ * could-not-parse even when some decisions were extracted — a silent drop is
+ * worse than a fail-loud signal.
  */
-function parseDecisions(content) {
-    if (!content || typeof content !== 'string')
-        return [];
-    const block = extractDecisionsBlock(content);
-    if (block === null)
-        return [];
+function parseDecisionLines(block) {
     const lines = block.split(/\r?\n/);
     const out = [];
     let category = '';
     let inDiscretion = false;
-    // Bullet line: `- **D-NN[ [tags]]:** text`
-    // Phase 6 (#3575): aligned to CJS regex — accepts alphanumeric IDs (D-01, D-INFRA-01, D-FOO_BAR)
-    // in addition to numeric-only IDs (D-42). The first character after `D-` must
-    // be alphanumeric, so malformed shapes like `D--foo` or `D-_bar` are rejected.
-    // CJS callers consume {id, text} and ignore the optional extras.
-    // #1343: `[^:*]*` replaces the old `\s*` before `:**` so that a freeform run
-    // such as `(parenthetical)`, an em-dash, or other prose between the optional
-    // bracket-tag group and the closing `:**` is tolerated rather than silently
-    // dropping the whole decision. `[^:*]*` subsumes plain whitespace and stops
-    // correctly at `:**`. Capture groups 1 (id), 2 (bracket tags), 3 (text) are
-    // unchanged.
-    const bulletRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?[^:*]*:\*\*\s*(.*)$/;
     let current = null;
+    let parseMisses = 0;
     const flush = () => {
         if (current) {
             current.text = current.text.trim();
@@ -84,39 +73,49 @@ function parseDecisions(content) {
             flush();
             category = headingMatch[1];
             // Strip the full unicode-quote family so any rendering of "Claude's
-            // Discretion" (ASCII apostrophe, curly U+2019, U+2018, U+201A, U+201B,
-            // double-quote variants U+201C/D/E/F, etc.) collapses to the same key
-            // (review F20).
+            // Discretion" (ASCII apostrophe, curly U+2019 ’, U+2018 ‘,
+            // U+201A, U+201B, double-quote variants U+201C/D/E/F, etc.) collapses
+            // to the same key (FIX C + review F20).
             const normalized = category
                 .toLowerCase()
-                .replace(/[‘’‚‛“”„‟'"`]/g, '')
+                .replace(/[‘’‚‛“”„‟''"`]/g, '')
                 .trim();
             inDiscretion = DISCRETION_HEADINGS.has(normalized);
             continue;
         }
-        const bulletMatch = line.match(bulletRe);
-        if (bulletMatch) {
+        // Colon form: `- **D-NN[ [tags]]:** text`
+        const colonMatch = line.match(bulletColonRe);
+        if (colonMatch) {
+            flush();
+            const id = `D-${colonMatch[1]}`;
+            const tags = colonMatch[2]
+                ? colonMatch[2].split(',').map((t) => t.trim().toLowerCase()).filter(Boolean)
+                : [];
+            const trackable = !inDiscretion && !tags.some((t) => NON_TRACKABLE_TAGS.has(t));
+            current = { id, text: colonMatch[3], category, tags, trackable };
+            continue;
+        }
+        // Em-dash form: `- **D-NN[ [tags]] — title** body`
+        const emDashMatch = line.match(bulletEmDashRe);
+        if (emDashMatch) {
             flush();
-            const id = `D-${bulletMatch[1]}`;
-            const tags = bulletMatch[2]
-                ? bulletMatch[2]
-                    .split(',')
-                    .map((t) => t.trim().toLowerCase())
-                    .filter(Boolean)
+            const id = `D-${emDashMatch[1]}`;
+            const tags = emDashMatch[2]
+                ? emDashMatch[2].split(',').map((t) => t.trim().toLowerCase()).filter(Boolean)
                 : [];
             const trackable = !inDiscretion && !tags.some((t) => NON_TRACKABLE_TAGS.has(t));
-            current = { id, text: bulletMatch[3], category, tags, trackable };
+            // The body (emDashMatch[3]) may be empty for the pure title form; the
+            // title itself is embedded in the bold run but we report the body as text
+            // (consistent with how the gate cares only about coverage, not title/body split).
+            current = { id, text: emDashMatch[3] || '', category, tags, trackable };
             continue;
         }
-        // Parse-miss guard (#1343): a line that looks like a `D-NN` decision bullet
-        // but failed `bulletRe` (e.g. a `:` or `*` inside the pre-colon run) must NOT
-        // be silently dropped — a narrowed trackable set lets a blocking coverage gate
-        // report a false pass. Surface it loudly instead.
+        // Parse-miss guard (FIX B + #1343): a line that looks like a `D-NN` decision
+        // bullet but failed both patterns — flush, warn, and record the miss.
+        // parseMisses > 0 forces could-not-parse even when other decisions parsed.
         if (/^\s*-\s+\*\*D-/.test(line)) {
-            // A malformed D-bullet still starts a (failed) new decision, so it ends the
-            // previous one — flush before warning so a following continuation line cannot
-            // be mis-appended to the prior valid decision.
             flush();
+            parseMisses += 1;
             console.warn(`parseDecisions: ignored unparseable decision bullet: ${trimmed}`);
             continue;
         }
@@ -132,5 +131,95 @@ function parseDecisions(content) {
         }
     }
     flush();
-    return out;
+    return { decisions: out, parseMisses };
+}
+// ─── Primary entry point: extractDecisions ────────────────────────────────────
+/**
+ * Extract decisions from CONTEXT.md content with a typed outcome.
+ *
+ * Strategy (in priority order):
+ * 1. If the content (fence-stripped) contains `<decisions>...</decisions>` blocks,
+ *    parse ONLY those blocks (canonical form; markdown-header content outside blocks
+ *    is ignored when a block is present — existing behavior preserved).
+ * 2. Otherwise, look for a /decisions?/i heading and collect its section body.
+ *    This is the T1 recall fix for #1364.
+ * 3. If neither is found, return outcome based on decision-shape heuristics.
+ */
+function extractDecisions(content) {
+    if (!content || typeof content !== 'string') {
+        return { decisions: [], outcome: 'none-present' };
+    }
+    // Apply fence-stripping for block extraction (prevents example blocks inside
+    // ``` fences from polluting the parser — review F11).
+    const { text: stripped, unterminatedFence } = (0, markdown_sectionizer_cjs_1.stripFencedCode)(content);
+    // ── Path 1: <decisions> blocks present ──────────────────────────────────────
+    const taggedBlocks = (0, markdown_sectionizer_cjs_1.extractTaggedBlocks)(stripped, 'decisions');
+    if (taggedBlocks.length > 0) {
+        const combined = taggedBlocks.join('\n\n');
+        const { decisions, parseMisses } = parseDecisionLines(combined);
+        if (decisions.length > 0 && parseMisses === 0) {
+            return { decisions, outcome: 'parsed' };
+        }
+        // FIX B: parse-misses present — could-not-parse even if some decisions extracted.
+        if (parseMisses > 0) {
+            return { decisions, outcome: 'could-not-parse' };
+        }
+        // FIX A: Block present but 0 extracted and no parse-misses.
+        // Only report could-not-parse when there is genuine evidence of real decisions
+        // that failed to parse: a \bD- token in the block text, or an unterminated fence.
+        // An empty scaffold (<decisions></decisions>) or an all-prose block has no such
+        // evidence — treat as none-present so the gate passes cleanly.
+        const hasDecisionTokenInBlock = /\bD-[A-Za-z0-9]/m.test(combined);
+        if (hasDecisionTokenInBlock || unterminatedFence) {
+            return { decisions: [], outcome: 'could-not-parse' };
+        }
+        return { decisions: [], outcome: 'none-present' };
+    }
+    // ── Path 2: markdown-header fallback (#1364 fix) ─────────────────────────────
+    // Use the seam's collectSection to find a /decisions?/i heading section.
+    // levelBounded:true → stop at next same-or-higher-level heading.
+    // stripFences:true → inner fences inside the section body are stripped.
+    const section = (0, markdown_sectionizer_cjs_1.collectSection)(content, (h) => /decisions?\b/i.test(h.text), { levelBounded: true, stripFences: true });
+    if (section !== null) {
+        const { decisions, parseMisses } = parseDecisionLines(section.body);
+        if (decisions.length > 0 && parseMisses === 0) {
+            return { decisions, outcome: 'parsed' };
+        }
+        // FIX B: parse-misses present — could-not-parse even if some decisions extracted.
+        if (parseMisses > 0) {
+            return { decisions, outcome: 'could-not-parse' };
+        }
+        // FIX A: Heading found but 0 extracted and no parse-misses.
+        // Only report could-not-parse when the section body contains a D- token.
+        // A heading with only prose, sub-headings, or all-discretion content
+        // (no trackable D- tokens) is a legitimate empty/discretion section → none-present.
+        const hasDecisionTokenInSection = /\bD-[A-Za-z0-9]/m.test(section.body);
+        if (hasDecisionTokenInSection) {
+            return { decisions: [], outcome: 'could-not-parse' };
+        }
+        return { decisions: [], outcome: 'none-present' };
+    }
+    // ── Path 3: no blocks, no heading ────────────────────────────────────────────
+    // Apply shape heuristics to distinguish none-present from could-not-parse.
+    // We re-use the already-computed unterminatedFence and check for D- tokens.
+    const hasDecisionToken = /\bD-[A-Za-z0-9]/m.test(stripped);
+    if (unterminatedFence || hasDecisionToken) {
+        return { decisions: [], outcome: 'could-not-parse' };
+    }
+    return { decisions: [], outcome: 'none-present' };
+}
+// ─── parseDecisions: thin delegate (backwards-compatible entry point) ─────────
+/**
+ * Parse trackable decisions from CONTEXT.md content.
+ *
+ * Thin delegate over extractDecisions — callers receive the decisions array
+ * exactly as before; nothing breaks. Use extractDecisions directly when the
+ * outcome enum is needed (e.g. for the fail-loud gate logic).
+ *
+ * Returns ALL D-NN decisions found (including non-trackable ones, with
+ * `trackable: false`). Callers that only want the gate-enforced decisions
+ * should filter `.filter(d => d.trackable)`.
+ */
+function parseDecisions(content) {
+    return extractDecisions(content).decisions;
 }

package/gsd-core/bin/lib/gap-checker.cjs

@@ -31,6 +31,7 @@ const { escapeRegex } = phaseId;
 const planningWorkspace = require("./planning-workspace.cjs");
 const { planningPaths, planningDir, findContextMdIn } = planningWorkspace;
 const decisions_cjs_1 = require("./decisions.cjs");
+const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 /**
  * Parse REQ-IDs from REQUIREMENTS.md content.
  *
@@ -44,16 +45,27 @@ function parseRequirements(reqMd) {
     const seen = new Set();
     // Prefix-agnostic ID format: REQ-01, TST-01, BACK-07, INSP-04, etc.
     const ID_PATTERN = '[A-Z][A-Z0-9]*-[A-Za-z0-9_-]+';
-    const checkboxRe = new RegExp(`^\\s*-\\s*\\[[x ]\\]\\s*\\*\\*(${ID_PATTERN})\\*\\*\\s*(.*)$`, 'gm');
-    let cm = checkboxRe.exec(reqMd);
-    while (cm !== null) {
-        const id = cm[1];
+    const idRe = new RegExp(`^(${ID_PATTERN})$`);
+    // Checkbox-bullet path: migrate to seam's iterateBullets (checkbox markers).
+    // The **ID** is extracted from the bullet text caller-side — the seam provides
+    // the raw text; we parse the bold-ID prefix from it here.
+    const boldIdRe = new RegExp(`^\\*\\*(${ID_PATTERN})\\*\\*\\s*(.*)$`);
+    for (const bullet of (0, markdown_sectionizer_cjs_1.iterateBullets)(reqMd)) {
+        if (bullet.marker !== 'checkbox-unchecked' && bullet.marker !== 'checkbox-checked')
+            continue;
+        const m = boldIdRe.exec(bullet.text);
+        if (!m)
+            continue;
+        const id = m[1];
+        if (!idRe.test(id))
+            continue;
         if (!seen.has(id)) {
             seen.add(id);
-            out.push({ id, text: (cm[2] || '').trim() });
+            out.push({ id, text: (m[2] || '').trim() });
         }
-        cm = checkboxRe.exec(reqMd);
     }
+    // Pipe-table-row path and separator-row skip stay caller-side
+    // (table parsing is out of seam scope per ADR-1372 T3 spec).
     const tableFirstCellRe = new RegExp(`^\\s*\\|\\s*(${ID_PATTERN})\\s*\\|`);
     const separatorRowRe = /^\s*\|[\s:|-]+\|\s*$/;
     const lines = reqMd.split(/\r?\n/);
@@ -128,13 +140,77 @@ function readGate(cwd) {
     catch { /* fall through */ }
     return true;
 }
+/**
+ * Same-prefix ascending numeric range, e.g. `SEL-01..SEL-03`. Both sides must
+ * share an identical prefix and a numeric suffix. Captures are:
+ *   1 low prefix, 2 low digits, 3 high prefix (compared to group 1 for equality), 4 high digits.
+ */
+const PHASE_REQ_RANGE_RE = /^(.+-)(\d+)\.\.(.+-)(\d+)$/;
+/**
+ * Maximum number of IDs a single range token may expand to. A range whose span
+ * exceeds this cap stays literal (fail-closed) rather than expanding, guarding
+ * against pathological input like `X-1..X-100000` ballooning the comparison set.
+ */
+const MAX_PHASE_REQ_RANGE = 1000;
+/**
+ * Expand a single `--phase-req-ids` token in place. If it is a valid ascending
+ * same-prefix numeric range (`<PREFIX>-NN..<PREFIX>-MM`, identical prefix both
+ * sides, numeric NN ≤ MM), return the individual IDs `<PREFIX>-NN … <PREFIX>-MM`
+ * preserving the bounds' zero-pad width. Anything that does NOT cleanly match a
+ * valid range stays literal (fail-closed) — returned as a single-element array.
+ *
+ * The two numeric bounds must share the same digit width; a range with
+ * differing widths (e.g. `SEL-9..SEL-11`) is ambiguous (padding to the wider
+ * width could invent IDs like `SEL-09` that never appear unpadded in
+ * REQUIREMENTS) and is left literal. A range spanning more than
+ * MAX_PHASE_REQ_RANGE IDs also stays literal.
+ */
+function expandPhaseReqIdToken(token) {
+    const m = PHASE_REQ_RANGE_RE.exec(token);
+    if (!m)
+        return [token];
+    const [, prefixLow, lowDigits, prefixHigh, highDigits] = m;
+    // Fail closed unless the prefixes are identical.
+    if (prefixLow !== prefixHigh)
+        return [token];
+    // Fail closed unless the bounds share an identical digit width. Differing
+    // widths are ambiguous: padding to the wider width could invent IDs that
+    // never appear unpadded in REQUIREMENTS.
+    if (lowDigits.length !== highDigits.length)
+        return [token];
+    const low = Number(lowDigits);
+    const high = Number(highDigits);
+    // Fail closed on descending ranges (NN > MM). NN == MM is a valid single-element range.
+    if (!Number.isFinite(low) || !Number.isFinite(high) || low > high)
+        return [token];
+    // Fail closed (DoS guard) on ranges spanning more than the cap.
+    if (high - low + 1 > MAX_PHASE_REQ_RANGE)
+        return [token];
+    // Preserve the bounds' (shared) zero-pad width.
+    const width = lowDigits.length;
+    const out = [];
+    for (let n = low; n <= high; n++) {
+        out.push(`${prefixLow}${String(n).padStart(width, '0')}`);
+    }
+    return out;
+}
 /**
  * Normalize a raw `--phase-req-ids` argument into the scoping signal used by
  * runGapAnalysis (#447). Mirrors §13's null/TBD skip semantics.
  *
- *   undefined           → flag absent: compare the whole REQUIREMENTS.md (back-compat)
- *   null | '' | TBD     → no requirements mapped to this phase: skip the comparison
- *   "REQ-01,REQ-02"     → restrict the comparison to these IDs
+ *   undefined                  → flag absent: compare the whole REQUIREMENTS.md (back-compat)
+ *   null | '' | TBD            → no requirements mapped to this phase: skip the comparison
+ *   "REQ-01,REQ-02"            → restrict the comparison to these IDs
+ *   "SEL-01..SEL-03"           → range form: expands in place to SEL-01, SEL-02, SEL-03 (#1269)
+ *
+ * Range form (#1269): a list element of the shape `<PREFIX>-NN..<PREFIX>-MM`
+ * (identical prefix both sides, identical bound digit width, ascending numeric
+ * NN ≤ MM) is expanded in place to the individual IDs, preserving the bounds'
+ * zero-pad width; mixed lists expand in input order. Any element that does not
+ * cleanly match a valid ascending same-prefix numeric range (mismatched
+ * prefix, differing bound width, descending, non-numeric, missing bound, or
+ * spanning more than MAX_PHASE_REQ_RANGE IDs) stays literal — no partial
+ * expansion, no guessing.
  *
  * Tolerates JSON-array-ish input (`["REQ-01","REQ-02"]`) since callers may pass
  * the roadmap value through verbatim.
@@ -151,7 +227,9 @@ function normalizePhaseReqIds(rawVal) {
     // Tolerate comma-, space-, or newline-separated lists (callers may pass the
     // roadmap value verbatim, whose serialization is not guaranteed).
     const ids = v.split(/[\s,]+/).map(s => s.trim()).filter(Boolean);
-    return ids.length === 0 ? null : ids;
+    // Expand range tokens (#1269) per-token AFTER the split, preserving input order.
+    const expanded = ids.flatMap(expandPhaseReqIdToken);
+    return expanded.length === 0 ? null : expanded;
 }
 function runGapAnalysis(cwd, phaseDir, options = {}) {
     const phaseReqIds = normalizePhaseReqIds(options.phaseReqIds);
@@ -193,7 +271,9 @@ function runGapAnalysis(cwd, phaseDir, options = {}) {
     const ctxFile = findContextMdIn(phaseDirFiles);
     const ctxPath = ctxFile ? node_path_1.default.join(absPhaseDir, ctxFile) : null;
     const ctxMd = ctxPath ? node_fs_1.default.readFileSync(ctxPath, 'utf-8') : '';
-    const dItems = (0, decisions_cjs_1.parseDecisions)(ctxMd).map(d => ({ ...d, source: 'CONTEXT.md' }));
+    // Use extractDecisions so gap-checker can distinguish could-not-parse from none-present.
+    const ctxExtraction = (0, decisions_cjs_1.extractDecisions)(ctxMd);
+    const dItems = ctxExtraction.decisions.map(d => ({ ...d, source: 'CONTEXT.md' }));
     const items = [...reqItems, ...dItems];
     let planText = '';
     try {
@@ -210,6 +290,41 @@ function runGapAnalysis(cwd, phaseDir, options = {}) {
         }
     }
     catch { /* unreadable */ }
+    // FIX D (#1365): surface decision could-not-parse independently of whether
+    // requirements items exist. Without this, a could-not-parse on decisions is
+    // silently masked whenever REQUIREMENTS.md has ≥1 item — the mismatch must
+    // appear in the report regardless of the requirements row count.
+    if (ctxExtraction.outcome === 'could-not-parse') {
+        const mismatchMsg = '## Post-Planning Gap Analysis\n\nextracted 0 of N — possible format mismatch in CONTEXT.md decisions block.\n';
+        // If there are also requirement items, include them in the return with the
+        // mismatch summary appended, so the caller still sees requirement coverage.
+        if (items.length > 0) {
+            const rows = sortRows([
+                ...detectCoverage(items, planText),
+                ...ghostReqIds.map(id => ({ source: 'REQUIREMENTS.md', item: id, status: 'Missing from REQUIREMENTS.md' })),
+            ]);
+            const covered = rows.filter(r => r.status === 'Covered').length;
+            const uncovered = rows.length - covered;
+            const coverageSummary = uncovered === 0
+                ? `✓ All ${rows.length} items covered by plans`
+                : `⚠ ${uncovered} of ${rows.length} items not covered by any plan`;
+            return {
+                enabled: true,
+                rows,
+                table: formatGapTable(rows) + '\n' + coverageSummary + '\n\n' + mismatchMsg,
+                summary: coverageSummary + '; extracted 0 of N — possible format mismatch',
+                counts: { total: rows.length, covered, uncovered },
+            };
+        }
+        return {
+            enabled: true,
+            rows: [],
+            table: mismatchMsg,
+            summary: 'extracted 0 of N — possible format mismatch',
+            counts: { total: 0, covered: 0, uncovered: 0 },
+        };
+    }
+    // #1365: if no items at all, surface a clean no-check message.
     if (items.length === 0) {
         return {
             enabled: true,