@deftai/directive-core 0.90.0 → 0.92.0

package/dist/pr-closing-keywords/main.js

@@ -1,5 +1,5 @@
 import { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK } from "./constants.js";
-import { findHits, renderHit } from "./detect.js";
+import { findAllClosingKeywordHits, findHits, renderHit } from "./detect.js";
 import { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
 import { readCommitsFile, readTextFile } from "./io.js";
 export function parseAllowList(values) {
@@ -11,43 +11,43 @@ export function parseAllowList(values) {
                 continue;
             }
             if (!/^\d+$/.test(tok)) {
-                throw new Error(`Invalid issue number in --allow-known-false-positives: ${JSON.stringify(tok)}`);
+                throw new Error(`Invalid issue number in --allow-known-false-positives / --allow-close: ${JSON.stringify(tok)}`);
             }
             out.add(Number(tok));
         }
     }
     return out;
 }
+function emptyParsed(error) {
+    return {
+        pr: null,
+        bodyFile: null,
+        commitsFile: null,
+        repo: null,
+        allowKnownFalsePositives: [],
+        allowClose: [],
+        mode: "both",
+        error,
+    };
+}
 export function parseArgs(argv) {
     let pr = null;
     let bodyFile = null;
     let commitsFile = null;
     let repo = null;
+    let mode = "both";
     const allowKnownFalsePositives = [];
+    const allowClose = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--pr") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: "argument --pr: expected one argument",
-                };
+                return emptyParsed("argument --pr: expected one argument");
             }
             const n = Number(value);
             if (!Number.isInteger(n)) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: `invalid int value: ${JSON.stringify(value)}`,
-                };
+                return emptyParsed(`invalid int value: ${JSON.stringify(value)}`);
             }
             pr = n;
             i += 1;
@@ -56,28 +56,14 @@ export function parseArgs(argv) {
             const value = arg.slice("--pr=".length);
             const n = Number(value);
             if (!Number.isInteger(n)) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: `invalid int value: ${JSON.stringify(value)}`,
-                };
+                return emptyParsed(`invalid int value: ${JSON.stringify(value)}`);
             }
             pr = n;
         }
         else if (arg === "--body-file") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: "argument --body-file: expected one argument",
-                };
+                return emptyParsed("argument --body-file: expected one argument");
             }
             bodyFile = value;
             i += 1;
@@ -88,14 +74,7 @@ export function parseArgs(argv) {
         else if (arg === "--commits-file") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: "argument --commits-file: expected one argument",
-                };
+                return emptyParsed("argument --commits-file: expected one argument");
             }
             commitsFile = value;
             i += 1;
@@ -106,14 +85,7 @@ export function parseArgs(argv) {
         else if (arg === "--repo") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: "argument --repo: expected one argument",
-                };
+                return emptyParsed("argument --repo: expected one argument");
             }
             repo = value;
             i += 1;
@@ -121,17 +93,28 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--repo=")) {
             repo = arg.slice("--repo=".length);
         }
+        else if (arg === "--mode") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return emptyParsed("argument --mode: expected one argument (fp|intent|both)");
+            }
+            if (value !== "fp" && value !== "intent" && value !== "both") {
+                return emptyParsed(`invalid --mode: ${JSON.stringify(value)} (expected fp|intent|both)`);
+            }
+            mode = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--mode=")) {
+            const value = arg.slice("--mode=".length);
+            if (value !== "fp" && value !== "intent" && value !== "both") {
+                return emptyParsed(`invalid --mode: ${JSON.stringify(value)} (expected fp|intent|both)`);
+            }
+            mode = value;
+        }
         else if (arg === "--allow-known-false-positives") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    pr,
-                    bodyFile,
-                    commitsFile,
-                    repo,
-                    allowKnownFalsePositives,
-                    error: "argument --allow-known-false-positives: expected one argument",
-                };
+                return emptyParsed("argument --allow-known-false-positives: expected one argument");
             }
             allowKnownFalsePositives.push(value);
             i += 1;
@@ -139,45 +122,69 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--allow-known-false-positives=")) {
             allowKnownFalsePositives.push(arg.slice("--allow-known-false-positives=".length));
         }
+        else if (arg === "--allow-close") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return emptyParsed("argument --allow-close: expected one argument");
+            }
+            allowClose.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--allow-close=")) {
+            allowClose.push(arg.slice("--allow-close=".length));
+        }
         else if (arg?.startsWith("-")) {
-            return {
-                pr,
-                bodyFile,
-                commitsFile,
-                repo,
-                allowKnownFalsePositives,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return emptyParsed(`unrecognized arguments: ${arg}`);
         }
         else {
-            return {
-                pr,
-                bodyFile,
-                commitsFile,
-                repo,
-                allowKnownFalsePositives,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return emptyParsed(`unrecognized arguments: ${arg}`);
         }
     }
-    return { pr, bodyFile, commitsFile, repo, allowKnownFalsePositives };
+    return { pr, bodyFile, commitsFile, repo, allowKnownFalsePositives, allowClose, mode };
 }
 function filterHits(hits, allowList) {
     return hits.filter((h) => !allowList.has(h.issueNumber));
 }
-function emitResult(hits, filtered) {
-    if (filtered.length === 0) {
-        if (hits.length > 0) {
-            process.stderr.write(`OK: ${hits.length} hit(s) suppressed by --allow-known-false-positives.\n`);
+function emitResult(mode, fpFiltered, intentFiltered, fpSuppressed, intentSuppressed) {
+    const totalFail = fpFiltered.length + intentFiltered.length;
+    if (totalFail === 0) {
+        const notes = [];
+        if (fpSuppressed > 0) {
+            notes.push(`${fpSuppressed} FP hit(s) suppressed by --allow-known-false-positives`);
         }
-        else {
+        if (intentSuppressed > 0) {
+            notes.push(`${intentSuppressed} intent hit(s) suppressed by --allow-close`);
+        }
+        if (notes.length > 0) {
+            process.stderr.write(`OK: ${notes.join("; ")}.\n`);
+        }
+        else if (mode === "fp") {
             process.stderr.write("OK: no closing-keyword negation/quotation/example/code-block hits found.\n");
         }
+        else if (mode === "intent") {
+            process.stderr.write("OK: no unallowlisted closing-keyword hits (intent mode; #3015).\n");
+        }
+        else {
+            process.stderr.write("OK: no closing-keyword FP or unallowlisted intent hits found (#737 / #3015).\n");
+        }
         return EXIT_OK;
     }
-    process.stderr.write(`FAIL: ${filtered.length} closing-keyword negation-context hit(s) found (see #737). Rewrite the PR body / commit messages to avoid the trigger token, or pass --allow-known-false-positives to suppress.\n`);
-    for (const h of filtered) {
-        process.stderr.write(`${renderHit(h)}\n`);
+    if (fpFiltered.length > 0) {
+        process.stderr.write(`FAIL: ${fpFiltered.length} closing-keyword negation-context hit(s) found (FP mode / #737). ` +
+            "Rewrite the PR body / commit messages to avoid the trigger token, or pass " +
+            "--allow-known-false-positives to suppress known-safe quotes.\n");
+        for (const h of fpFiltered) {
+            process.stderr.write(`${renderHit(h)}\n`);
+        }
+    }
+    if (intentFiltered.length > 0) {
+        process.stderr.write(`FAIL: ${intentFiltered.length} real closing-keyword hit(s) without allowlist (intent mode / #3015 class D). ` +
+            "Default PR bodies use Tracking: #N / Related: #N / Refs #N. Use Closes/Fixes/Resolves only when full " +
+            "issue DoD is met, then pass --allow-close <N,M> on the lint (body trailers are not an authorization path). " +
+            "Conditional prose (Phase A / only if / partial) does NOT prevent GitHub auto-close.\n");
+        for (const h of intentFiltered) {
+            process.stderr.write(`${renderHit(h)}\n`);
+        }
     }
     return EXIT_HITS_FOUND;
 }
@@ -187,9 +194,11 @@ export function run(argv, options = {}) {
         process.stderr.write(`Error: ${args.error}\n`);
         return EXIT_CONFIG_ERROR;
     }
-    let allowList;
+    let fpAllow;
+    let closeAllow;
     try {
-        allowList = parseAllowList(args.allowKnownFalsePositives);
+        fpAllow = parseAllowList(args.allowKnownFalsePositives);
+        closeAllow = parseAllowList(args.allowClose);
     }
     catch (exc) {
         const message = exc instanceof Error ? exc.message : String(exc);
@@ -230,15 +239,35 @@ export function run(argv, options = {}) {
             commitMessages = msgs;
         }
     }
-    const hits = [];
+    const runFp = args.mode === "fp" || args.mode === "both";
+    const runIntent = args.mode === "intent" || args.mode === "both";
+    const fpHits = [];
+    const intentHits = [];
     if (bodyText !== null) {
-        hits.push(...findHits(bodyText, "pr-body"));
+        if (runFp) {
+            fpHits.push(...findHits(bodyText, "pr-body"));
+        }
+        if (runIntent) {
+            // Intent = class D only (bare/conditional real closes). Class A FP-context
+            // hits (negation/quote/example/code) stay exclusive to FP mode so operators
+            // do not need --allow-close for quoted fixtures (#3015 / SLizard).
+            intentHits.push(...findAllClosingKeywordHits(bodyText, "pr-body").filter((h) => h.reason === "intent"));
+        }
     }
     for (let idx = 0; idx < commitMessages.length; idx += 1) {
-        hits.push(...findHits(commitMessages[idx] ?? "", `commit:${idx}`));
+        const msg = commitMessages[idx] ?? "";
+        if (runFp) {
+            fpHits.push(...findHits(msg, `commit:${idx}`));
+        }
+        if (runIntent) {
+            intentHits.push(...findAllClosingKeywordHits(msg, `commit:${idx}`).filter((h) => h.reason === "intent"));
+        }
     }
-    const filtered = filterHits(hits, allowList);
-    return emitResult(hits, filtered);
+    // Intent allowlist is CLI --allow-close only (#3015). Body trailers are not
+    // an authorization path (Markdown example/fence false-authorization class).
+    const fpFiltered = filterHits(fpHits, fpAllow);
+    const intentFiltered = filterHits(intentHits, closeAllow);
+    return emitResult(args.mode, fpFiltered, intentFiltered, fpHits.length - fpFiltered.length, intentHits.length - intentFiltered.length);
 }
 export function cmdPrCheckClosingKeywords(argv, options = {}) {
     return run(argv, options);

package/dist/pr-closing-keywords/types.d.ts

@@ -12,12 +12,22 @@ export interface RunGhResult {
 }
 /** Injectable gh subprocess seam (#1366 / parity harness). */
 export type RunGhFn = (cmd: readonly string[]) => RunGhResult;
+/** Lint mode for closing-keyword checks (#3015). */
+export type ClosingKeywordMode = "fp" | "intent" | "both";
 export interface ParsedArgs {
     readonly pr: number | null;
     readonly bodyFile: string | null;
     readonly commitsFile: string | null;
     readonly repo: string | null;
     readonly allowKnownFalsePositives: readonly string[];
+    /** Intent-mode allowlist of issue numbers permitted to use real closing keywords (#3015). */
+    readonly allowClose: readonly string[];
+    /**
+     * fp = Layer 0 #737 (negation/quote/example/code only);
+     * intent = any closing keyword unless allowlisted (#3015 class D);
+     * both = default (FP + intent).
+     */
+    readonly mode: ClosingKeywordMode;
     readonly error?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/render/constants.d.ts

@@ -2,11 +2,27 @@
 export declare const VALID_STATUSES: Set<string>;
 export declare const VALID_VBRIEF_VERSIONS: Set<string>;
 export declare const SPECIFICATION_NARRATIVE_KEY_ORDER: readonly ["Overview", "ProblemStatement", "Goals", "UserStories", "Requirements", "SuccessMetrics", "EdgeCases", "Architecture", "TechDecisions", "ImplementationPhases", "PreImplementationGates"];
+/** Migration capture narrative; omitted from default compact SPECIFICATION.md (#1566). */
+export declare const LEGACY_ARTIFACTS_NARRATIVE_KEY = "LegacyArtifacts";
+/**
+ * Default lifecycle scope aggregation for `task spec:render` / `renderSpec` (#1566).
+ * `off` = product narratives only; opt in with `current` (pending+active) or `all`.
+ */
+export declare const DEFAULT_INCLUDE_SCOPES_MODE: "off";
+/** Lifecycle scope aggregation modes for rendered specs (#1566). */
+export type IncludeScopesMode = "off" | "current" | "all";
 export declare const LIFECYCLE_BUCKETS: ReadonlyArray<readonly [string, string]>;
 export declare const SPEC_RENDER_BANNER: string;
 export declare const PRD_NARRATIVE_KEY_ORDER: readonly ["Overview", "ProblemStatement", "Goals", "UserStories", "Requirements", "SuccessMetrics", "Architecture"];
 export declare const PRD_BANNER: string;
 export declare const PRD_GENERATED_SENTINEL = "AUTO-GENERATED by task prd:render";
+/** Max completed scopes listed under ## Completed in ROADMAP.md (#2653). */
+export declare const ROADMAP_COMPLETED_CAP = 25;
+/**
+ * Shown when completed/ has history but pending/, active/, and proposed/ are empty.
+ * Prevents silent Completed-only output without documenting empty-forward (#2653 D2.2).
+ */
+export declare const ROADMAP_EMPTY_FORWARD_MARKER: string;
 export declare const ROADMAP_BANNER: string;
 export declare const MIGRATOR_METADATA_KEY = "x-migrator";
 export declare const PROJECT_LIFECYCLE_FOLDERS: readonly ["proposed", "pending", "active", "completed", "cancelled"];

package/dist/render/constants.js

@@ -24,6 +24,13 @@ export const SPECIFICATION_NARRATIVE_KEY_ORDER = [
     "ImplementationPhases",
     "PreImplementationGates",
 ];
+/** Migration capture narrative; omitted from default compact SPECIFICATION.md (#1566). */
+export const LEGACY_ARTIFACTS_NARRATIVE_KEY = "LegacyArtifacts";
+/**
+ * Default lifecycle scope aggregation for `task spec:render` / `renderSpec` (#1566).
+ * `off` = product narratives only; opt in with `current` (pending+active) or `all`.
+ */
+export const DEFAULT_INCLUDE_SCOPES_MODE = "off";
 export const LIFECYCLE_BUCKETS = [
     ["pending", "Pending"],
     ["active", "Active"],
@@ -47,9 +54,17 @@ export const PRD_BANNER = "<!-- AUTO-GENERATED by task prd:render -- DO NOT EDIT
     "<!-- Source of truth: vbrief/specification.vbrief.json -->\n" +
     "<!-- Regenerate with: task prd:render -->\n";
 export const PRD_GENERATED_SENTINEL = "AUTO-GENERATED by task prd:render";
+/** Max completed scopes listed under ## Completed in ROADMAP.md (#2653). */
+export const ROADMAP_COMPLETED_CAP = 25;
+/**
+ * Shown when completed/ has history but pending/, active/, and proposed/ are empty.
+ * Prevents silent Completed-only output without documenting empty-forward (#2653 D2.2).
+ */
+export const ROADMAP_EMPTY_FORWARD_MARKER = "_No open work in `pending/`, `active/`, or `proposed/`. " +
+    "ROADMAP is an orientation view — use `task triage:queue` or plan-sequence for work selection._\n";
 export const ROADMAP_BANNER = "<!-- AUTO-GENERATED by task roadmap:render -- DO NOT EDIT MANUALLY -->\n" +
     "<!-- Purpose: rendered roadmap -->\n" +
-    "<!-- Source of truth: vbrief/pending/ (scope vBRIEFs) -->\n" +
+    "<!-- Source of truth: xbrief|vbrief pending/ + proposed/ + active/ (forward); completed/ capped -->\n" +
     "<!-- Regenerate with: task roadmap:render -->\n";
 export const MIGRATOR_METADATA_KEY = "x-migrator";
 export const PROJECT_LIFECYCLE_FOLDERS = [

package/dist/render/export-spec.d.ts

@@ -1,9 +1,15 @@
+import { type IncludeScopesMode } from "./constants.js";
 export type ExportAudience = "stakeholder" | "internal";
 export interface ExportSpecOptions {
     readonly projectRoot?: string;
     readonly outPath?: string;
     readonly audience?: ExportAudience;
-    readonly includeScopes?: boolean;
+    /**
+     * Lifecycle scope aggregation (#1566). Default `off` (compact).
+     * `current` = pending+active; `all` / true = include completed archive.
+     */
+    readonly includeScopes?: boolean | IncludeScopesMode;
+    readonly includeLegacyArtifacts?: boolean;
     readonly proposedLimit?: number;
 }
 export type ExportSpecResult = readonly [boolean, string];

package/dist/render/export-spec.js

@@ -2,8 +2,11 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { greenfieldOverviewNonEmpty, renderNarrativeSections, resolveExportNarratives, } from "../spec-authority/narratives.js";
 import { resolveSpecAuthority } from "../spec-authority/resolver.js";
+import { LEGACY_ARTIFACTS_NARRATIVE_KEY } from "./constants.js";
 import { buildScopeOutlookSection } from "./scope-outlook.js";
+import { normalizeIncludeScopesMode, tryParseIncludeScopesMode, tryParseOnOffFlag, } from "./spec-render.js";
 import { validateSpec } from "./spec-validate.js";
+import { stripTrailingWhitespace } from "./text-utils.js";
 function loadPlanTitle(path, fallback) {
     try {
         const doc = JSON.parse(readFileSync(path, "utf8"));
@@ -17,12 +20,24 @@ function loadPlanTitle(path, fallback) {
     }
     return fallback;
 }
+function filterLegacyArtifacts(narratives, includeLegacyArtifacts) {
+    if (includeLegacyArtifacts)
+        return narratives;
+    const filtered = {};
+    for (const [key, val] of Object.entries(narratives)) {
+        if (key === LEGACY_ARTIFACTS_NARRATIVE_KEY)
+            continue;
+        filtered[key] = val;
+    }
+    return filtered;
+}
 /** Unified spec export (#2013 / #1502). */
 export function exportSpec(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
     const outPath = options.outPath ?? join(projectRoot, "SPECIFICATION.md");
     const audience = options.audience ?? "stakeholder";
-    const includeScopes = options.includeScopes ?? true;
+    const includeScopesMode = normalizeIncludeScopesMode(options.includeScopes);
+    const includeLegacyArtifacts = options.includeLegacyArtifacts ?? false;
     const includeProposed = audience === "internal";
     const authority = resolveSpecAuthority(projectRoot);
     if (!authority) {
@@ -39,7 +54,7 @@ export function exportSpec(options = {}) {
             "⚠ PROJECT-DEFINITION.xbrief.json Overview narrative is empty (D3). Populate Overview before export.",
         ];
     }
-    const narratives = resolveExportNarratives(authority);
+    const narratives = filterLegacyArtifacts(resolveExportNarratives(authority), includeLegacyArtifacts);
     const title = authority.kind === "full-spec" && authority.specPath
         ? loadPlanTitle(authority.specPath, "Specification")
         : loadPlanTitle(authority.projectDefPath, "Specification");
@@ -48,15 +63,16 @@ export function exportSpec(options = {}) {
         `# ${title}\n`,
         ...renderNarrativeSections(narratives),
     ];
-    if (includeScopes) {
+    if (includeScopesMode !== "off") {
         const scopeLines = buildScopeOutlookSection(authority.vbriefDir, {
             includeProposed,
             proposedLimit: options.proposedLimit,
+            includeCompleted: includeScopesMode === "all",
         });
         if (scopeLines.length > 0)
             lines.push(...scopeLines);
     }
-    writeFileSync(outPath, lines.join("\n"), "utf8");
+    writeFileSync(outPath, stripTrailingWhitespace(lines.join("\n")), "utf8");
     return [true, `✓ Exported spec to ${outPath}`];
 }
 export function parseExportSpecArgv(argv) {
@@ -75,7 +91,37 @@ export function parseExportSpecArgv(argv) {
             continue;
         }
         if (arg === "--no-scopes") {
-            options.includeScopes = false;
+            options.includeScopes = "off";
+            continue;
+        }
+        if (arg === "--include-scopes") {
+            options.includeScopes = "all";
+            continue;
+        }
+        if (arg.startsWith("--include-scopes=")) {
+            const value = arg.split("=", 2)[1] ?? "";
+            const parsed = tryParseIncludeScopesMode(value);
+            if (parsed === undefined) {
+                errors.push(`Invalid --include-scopes=${value} (expected off|current|all|active|on|true|1|yes|false|0|no)`);
+            }
+            else {
+                options.includeScopes = parsed;
+            }
+            continue;
+        }
+        if (arg === "--include-legacy-artifacts") {
+            options.includeLegacyArtifacts = true;
+            continue;
+        }
+        if (arg.startsWith("--include-legacy-artifacts=")) {
+            const value = arg.split("=", 2)[1] ?? "";
+            const parsed = tryParseOnOffFlag(value);
+            if (parsed === undefined) {
+                errors.push(`Invalid --include-legacy-artifacts=${value} (expected on|off|true|false|1|0|yes|no)`);
+            }
+            else {
+                options.includeLegacyArtifacts = parsed;
+            }
             continue;
         }
         if (arg.startsWith("--")) {

package/dist/render/index.d.ts

@@ -10,9 +10,10 @@ export * as roadmapRender from "./roadmap-render.js";
 export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRoadmap, renderRoadmapToBuffer, } from "./roadmap-render.js";
 export { main as ruleMapMain } from "./rule-map.js";
 export { aggregateScopeSection, buildScopeOutlookSection } from "./scope-outlook.js";
+export type { RenderSpecOptions } from "./spec-render.js";
 export * as specRender from "./spec-render.js";
-export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";
+export { main as specRenderMain, normalizeIncludeScopesMode, parseIncludeScopesFlag, renderSpec, tryParseIncludeScopesMode, tryParseOnOffFlag, } from "./spec-render.js";
 export * as specValidate from "./spec-validate.js";
 export { main as specValidateMain, validateSpec } from "./spec-validate.js";
-export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords } from "./text-utils.js";
+export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords, stripTrailingWhitespace, } from "./text-utils.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/render/index.js

@@ -11,8 +11,8 @@ export { checkDrift, generateRoadmapContent, main as roadmapRenderMain, renderRo
 export { main as ruleMapMain } from "./rule-map.js";
 export { aggregateScopeSection, buildScopeOutlookSection } from "./scope-outlook.js";
 export * as specRender from "./spec-render.js";
-export { main as specRenderMain, parseIncludeScopesFlag, renderSpec } from "./spec-render.js";
+export { main as specRenderMain, normalizeIncludeScopesMode, parseIncludeScopesFlag, renderSpec, tryParseIncludeScopesMode, tryParseOnOffFlag, } from "./spec-render.js";
 export * as specValidate from "./spec-validate.js";
 export { main as specValidateMain, validateSpec } from "./spec-validate.js";
-export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords } from "./text-utils.js";
+export { parsePhaseNumber, phaseSortKey, splitCamel, splitWords, stripTrailingWhitespace, } from "./text-utils.js";
 //# sourceMappingURL=index.js.map