qfai 1.9.2 → 1.10.0

package/dist/index.d.ts

@@ -27,6 +27,12 @@ type Issue = {
     suppressed?: boolean;
     suggested_action?: string;
     file?: string;
+    /**
+     * Every other file this finding implicates, when `file` is only a
+     * representative (a duplicate ID is defined in N files but reported once).
+     * `--spec` scoping keeps the finding if any of these is in scope.
+     */
+    relatedFiles?: string[];
     refs?: string[];
     rule?: string;
     loc?: IssueLocation;
@@ -169,8 +175,10 @@ type QfaiPrototypingExecutionConfig = {
      *
      * Accepted values during the deprecation window:
      *   - `"playwright"` (primary, post-1.9.x default).
-     *   - `"playwright-cli"` (deprecated; sunset 1.10.0). When chosen,
-     *     the doctor probe emits `D-DEPRECATED-PROBE` (severity warning).
+     *   - `"playwright-cli"` (deprecated; sunset `SUNSETS.playwrightCli`).
+     *     Inside the window the doctor probe emits `D-DEPRECATED-PROBE` at
+     *     `warning`; from the sunset onwards `normalizePrototypingExecution`
+     *     rejects the value and the probe reports `error`.
      *
      * At sunset only `"playwright"` is accepted.
      */
@@ -246,7 +254,7 @@ declare function loadConfig(root: string): Promise<ConfigLoadResult>;
 declare function resolvePath(root: string, config: QfaiConfig, key: ConfigPathKey): string;
 
 type AtddTestKind = "e2e" | "api" | "integration";
-type AtddUnknownRefKind = "us" | "tc" | "conApi";
+type AtddUnknownRefKind = "us" | "tc" | "conApi" | "conDb";
 type AtddUnknownRef = {
     file: string;
     token: string;
@@ -267,27 +275,109 @@ type AtddTraceabilityMissing = {
     us: string[];
     tc: string[];
     conApi: string[];
+    conDb: string[];
 };
 type AtddCodeTraceabilityResult = {
     specsRoot: string;
     contractsApiRoot: string;
     specUsIds: Map<string, Set<string>>;
     specTcIds: Map<string, Set<string>>;
+    /**
+     * Every declared `CON-API-*`, active and deferred alike. This is the public
+     * meaning the field has always had — adding `x-qfai-status: planned` defers
+     * the test obligation, it does not un-declare the contract, so an external
+     * consumer using this set for "is this ID declared?" must keep seeing it.
+     */
     apiContractIds: Set<string>;
+    /** The subset that carries the `QFAI-ATDD-113` obligation. */
+    activeApiContractIds: Set<string>;
+    /**
+     * `CON-API-*` IDs excluded from the `QFAI-ATDD-113` obligation because their
+     * contract declares `x-qfai-status: planned`. Reported as `info` so the
+     * deferral stays visible instead of silently shrinking the gate.
+     */
+    deferredApiContractIds: Set<string>;
+    contractsDbRoot: string;
+    /** Every declared `CON-DB-*`, active and deferred alike. */
+    dbContractIds: Set<string>;
+    /** The subset that carries the `QFAI-ATDD-115` obligation. */
+    activeDbContractIds: Set<string>;
+    /** `CON-DB-*` deferred by `-- x-qfai-status: planned`; reported at `info`. */
+    deferredDbContractIds: Set<string>;
     refs: {
         us: AtddSpecRefs;
         tc: AtddSpecRefs;
         api: Map<string, Set<string>>;
+        /**
+         * `CON-DB-*` references found in integration tests. L3 Integration is the
+         * layer whose declared scope is real-infrastructure integration including
+         * the database, so it is the one that can actually exercise a DB contract.
+         */
+        db: Map<string, Set<string>>;
     };
     unknown: AtddUnknownRef[];
     forbidden: {
         tcInApi: AtddForbiddenRef[];
         tcInE2e: AtddForbiddenRef[];
+        /** TC annotated under integration although its declared Level routes elsewhere. */
+        tcInIntegration: AtddForbiddenRef[];
     };
     missing: AtddTraceabilityMissing;
+    /**
+     * Formatted missing TC ref -> the test kind its declared `Level` routes to.
+     * Lets the CLI phrase `QFAI-ATDD-112` (message, `suggested_action`, report)
+     * per declared layer instead of naming `tests/integration/**` for every TC.
+     */
+    missingTcHomes: Map<string, AtddTestKind>;
+    /** Test files outside the scanned roots; surfaced instead of dropped. */
+    skippedTestFiles: string[];
     scan: AtddTraceabilityScan;
 };
+/** Test directory each `AtddTestKind` owns, for user-facing messages. */
+declare const ATDD_TEST_KIND_DIRS: Record<AtddTestKind, string>;
+/**
+ * The same map rendered against the project's configured `paths.testsDir`.
+ *
+ * The scan already follows `testsDir`, so a project that renamed it to e.g.
+ * `spec-tests` would otherwise be told by `QFAI-ATDD-112` to annotate
+ * `tests/api/**` — a directory the scan never reads, leaving the finding
+ * unclearable. A root-level layout (`testsDir: "."`) is the same trap in the
+ * other direction: the scan reads `api/**` at the repository root, so the
+ * `tests/` segment must be dropped rather than kept.
+ * {@link ATDD_TEST_KIND_DIRS} stays as the default-shaped fallback for callers
+ * with no config in hand.
+ */
+declare function atddTestKindDirs(testsDirRelative: string): Record<AtddTestKind, string>;
 declare function evaluateAtddCodeTraceability(root: string, config: QfaiConfig): Promise<AtddCodeTraceabilityResult>;
+declare const PLANNED_CONTRACT_KEY = "x-qfai-status";
+/**
+ * True when the contract declares itself not yet implemented.
+ *
+ * `/qfai-sdd` authors contracts in Phase 0 (Contracts-first) but slices them in
+ * Phase 2, so between the second contract and the last slice every declared
+ * `CON-API-*` would otherwise be a `QFAI-ATDD-113` error. The marker makes the
+ * deferral explicit and reviewable in the contract itself.
+ *
+ * The marker is only honoured at the **document root**. A text scan that
+ * accepted any indentation would let an `x-qfai-status: planned` on a single
+ * OpenAPI operation defer the whole file, silently dropping the API-test
+ * obligation for every other `CON-API-*` it declares. The document is therefore
+ * parsed (YAML is a superset of JSON, so both contract formats go through the
+ * same path) and only a top-level key counts. An unparseable document falls
+ * back to a column-0 text match, which cannot see a nested key either.
+ */
+declare function isPlannedApiContract(text: string): boolean;
+/**
+ * Derives the per-layer file pattern from the project's configured
+ * `testFileGlobs`, so a non-JS repository is scanned with its own extensions.
+ *
+ * Configured globs describe whole paths (`tests/**\/*.py`); the ATDD scan needs
+ * a pattern to append under `tests/{e2e,api,integration}/`. The extension set is
+ * therefore lifted out of them, unioned with the structural annotation carriers
+ * above, and recombined. When no extension can be recovered, the JS/TS default
+ * is used.
+ */
+declare function deriveAtddFilePattern(testFileGlobs: readonly string[]): string;
 
 type GuardrailType = "non-goal" | "not-now" | "trade-off";
 type DecisionGuardrailEntry = {
@@ -351,12 +441,77 @@ declare function filterDecisionGuardrailsByKeyword(items: DecisionGuardrail[], k
 declare function formatGuardrailsForLlm(items: DecisionGuardrail[], max: number): string;
 declare function checkDecisionGuardrails(entries: DecisionGuardrailEntry[]): GuardrailCheckResult;
 
-type IdPrefix = "CAP" | "SPEC" | "US" | "BR" | "SC" | "AC" | "CASE" | "UI" | "API" | "DB" | "THEMA";
-type IdFormatPrefix = IdPrefix | "ADR";
+type IdPrefix = "CAP" | "SPEC" | "US" | "BR" | "SC" | "AC" | "EX" | "TC" | "CASE" | "UI" | "API" | "DB" | "THEMA";
+/**
+ * Prefixes with a declared format but no membership in {@link ID_PREFIXES}.
+ *
+ * `DR` joins `ADR` here rather than in `ID_PREFIXES` because a Decision Record
+ * is not a spec-pack item: `extractAllIds` walks the layers a spec decomposes
+ * into, and sweeping `DR-*` into that walk would make every citation of a
+ * decision look like an undeclared spec item to the traceability rules.
+ *
+ * What was missing is the *format*. `qfai-implement` makes a non-empty `DR-ID`
+ * the hard precondition for the `exception` status and `tddList.ts` enforces it
+ * at `error`, but no ID class existed — so any non-empty string satisfied the
+ * gate, including a token the operator invented on the spot.
+ */
+type IdFormatPrefix = IdPrefix | "ADR" | "DR";
 declare const ID_PREFIXES: IdPrefix[];
-declare function extractIds(text: string, prefix: IdPrefix): string[];
+/**
+ * Every strict-format match for `prefix`.
+ *
+ * Takes {@link IdFormatPrefix}, not {@link IdPrefix}: `ADR` and `DR` have a
+ * declared format but are not spec-pack items, and a caller asking for one
+ * should not have to assert its way past the type. `extractAllIds` still walks
+ * {@link ID_PREFIXES} only, so the decomposition layers are unchanged.
+ */
+declare function extractIds(text: string, prefix: IdFormatPrefix): string[];
 declare function extractAllIds(text: string): string[];
-declare function extractInvalidIds(text: string, prefixes: IdFormatPrefix[]): string[];
+/**
+ * The one section whose fenced bodies are primary spec content: the v1421
+ * `03_Acceptance-Criteria.md` `## AC Gherkin (required)` block. Masking it
+ * would let a mistyped required definition (`# AC-0001-1`) reach
+ * `validateLayeredIdFormat` as if it did not exist.
+ */
+declare const AC_GHERKIN_SECTION = "ac gherkin (required)";
+type FenceMaskOptions = {
+    /**
+     * Normalized H2 heading (see {@link AC_GHERKIN_SECTION}) whose fenced bodies
+     * stay in the ID scan when their info string is a Gherkin dialect. Omitted:
+     * every fence body is masked.
+     */
+    scannedSection?: string;
+};
+/**
+ * Blanks the body of illustrative fenced code blocks while preserving the line
+ * count, so an ID-shaped token inside a sample or a diagram is not read as a
+ * spec ID and reported line numbers still point at the source file.
+ *
+ * Two properties matter:
+ *
+ * - A fence closes only on the **same marker character** at **at least the
+ *   opening length**. A ```` ```` ```` block that quotes a ```` ``` ```` sample
+ *   inside itself is legal markdown; toggling on any fence line would end the
+ *   outer block early and re-expose the very sample it was hiding.
+ * - A fence keeps its body only when it is tagged with a
+ *   `SCANNED_FENCE_LANGUAGES` info string **and** sits inside
+ *   `options.scannedSection`. Keying on the language alone exempted every
+ *   ```` ```gherkin ```` block in every layered file — including an
+ *   illustration in a Purpose paragraph — which is the case the mask exists
+ *   for. Only the required AC Gherkin section is the spec's own definition.
+ */
+declare function maskFencedCodeBlocks(text: string, options?: FenceMaskOptions): string;
+type InvalidIdOccurrence = {
+    id: string;
+    /** 1-based line number in the original text. */
+    line: number;
+};
+/**
+ * Finds ID-shaped tokens that do not match their prefix's canonical format,
+ * with the line each was first seen on. Fenced code blocks are excluded.
+ */
+declare function extractInvalidIdOccurrences(text: string, prefixes: IdFormatPrefix[], options?: FenceMaskOptions): InvalidIdOccurrence[];
+declare function extractInvalidIds(text: string, prefixes: IdFormatPrefix[], options?: FenceMaskOptions): string[];
 declare function extractSpecNumber(specId: string): string | null;
 declare function extractCapSpecNumber(capId: string): string | null;
 declare function extractUsSpecNumber(usId: string): string | null;
@@ -450,6 +605,20 @@ type ReportTraceability = {
 type ReportTestStrategy = {
     totalScenarios: number;
     limit: number;
+    /**
+     * Where the layer buckets came from.
+     *
+     * `scenario-tags` is the Gherkin `@layer-*` path, which only exists for the
+     * legacy `scenario.feature` layout. On the v1421 layered layout
+     * `examplesPath` is the **Markdown** `05_Examples.md`, so the parse failed,
+     * the error was swallowed by `continue`, and every bucket printed 0 — while
+     * the toolkit mandates layer routing and gates completion on it.
+     * `ledger-layer` is the `Layer` column of `tdd/test-list.md`, which is the
+     * artifact the shipped templates actually produce.
+     */
+    layerSource: "scenario-tags" | "ledger-layer" | "none";
+    /** Scenario files that failed to parse; reported instead of silently zeroed. */
+    unparsedScenarioFiles: string[];
     layer: Record<"unit" | "component" | "integration" | "api" | "e2e" | "none" | "unknown", number>;
     size: Record<"s" | "m" | "l" | "none" | "unknown", number>;
     missing: {
@@ -545,8 +714,12 @@ type ReportTddCoverageSpec = {
     specNumber: string;
     unitComponentTotal: number;
     doneCount: number;
+    /** Has a passing test, has not cleared its blocking reviewers / checkpoint. */
+    inReviewCount: number;
     exceptionCount: number;
     openCount: number;
+    /** Open rows that cannot be started, reported apart from "not started yet". */
+    blockedCount: number;
     missingTcRefs: string[];
     exceptionRows: Array<{
         tddId: string;
@@ -699,6 +872,12 @@ declare function formatReportJson(data: ReportData): string;
 type ValidationOptions = {
     profile?: ValidationProfile;
     platform?: string;
+    /**
+     * Restrict the run to the named specs (`--spec`). Repo-level findings are
+     * always kept; only findings owned by an out-of-scope `spec-NNNN` directory
+     * are dropped, and per-spec report writes are skipped for them.
+     */
+    specIds?: readonly string[];
 };
 declare function validateProject(root: string, configResult?: ConfigLoadResult, options?: ValidationOptions): Promise<ValidationResult>;
 
@@ -720,6 +899,61 @@ declare function validateSpecSplitByCapability(root: string, config: QfaiConfig)
 declare function validateTraceability(root: string, config: QfaiConfig, options: {
     includeCodeReferences: boolean;
 }): Promise<Issue[]>;
+type TraceabilityGraphNode = {
+    id: string;
+    layer: string;
+    path?: string;
+};
+type TraceabilityGraphEdge = {
+    from: string;
+    to: string;
+    type: string;
+};
+type TraceabilityGraph = {
+    nodes: TraceabilityGraphNode[];
+    edges: TraceabilityGraphEdge[];
+};
+/**
+ * Builds the requirement graph from the parsed spec pack.
+ *
+ * Exposed so the per-run `traceability.json` artifact can be populated from the specs themselves
+ * rather than from the refs of emitted findings. Deriving it from findings inverted the artifact's
+ * intent: it was empty precisely when the spec pack was healthy, and populated only with IDs that
+ * failed.
+ *
+ * Every layered style `collectSpecEntries` recognises is walked, because restricting this to the
+ * v1416 style `validateTraceability` gates would leave the artifact empty for every spec written
+ * in the current v1421 layout. The layer vocabulary differs per style — v1416 links
+ * `US -> AC -> BR -> SC -> CASE`, v1417/v1421 link `US -> AC -> BR -> EX -> TC` — so the edge
+ * types differ too; the node/edge shape does not.
+ *
+ * Emits no issues; parse problems are reported by `validateTraceability` and
+ * `validateLayerCoverage` on the same inputs.
+ */
+declare function buildLayeredTraceabilityGraph(root: string, config: QfaiConfig): Promise<TraceabilityGraph>;
+/**
+ * Make an item ID unique across the pack.
+ *
+ * Item IDs are file-local (`spec-traceability-rules.md`, "ID and Parent
+ * Rules") and the shipped templates start every spec at `US-0001` / `AC-0001`,
+ * so two specs using the short form collide. Keying the graph on the raw ID
+ * silently dropped the second spec's nodes and overwrote its same-shaped edges,
+ * leaving `traceability.json` holding only the first spec's paths.
+ *
+ * The composite form already carries its spec number, so it is left untouched —
+ * qualifying it would rewrite every ID in the packs that actually ship today
+ * for no gain.
+ */
+declare function qualifyId(specNumber: string, id: string): string;
+/**
+ * The spec number owning `filePath`, or `null` for a repo-level file.
+ *
+ * Exported next to {@link qualifyId} because every producer of graph IDs has to
+ * namespace them the same way. A finding-derived node built from a raw short ID
+ * lands beside — not on — the `spec-NNNN/AC-0001` node the edges point at, and
+ * two specs' findings then merge onto the same unqualified node.
+ */
+declare function specNumberForPath(filePath: string | undefined): string | null;
 
 type SurfaceType = CanonicalPrototypingSurface | "non-ui";
 declare const DISCUSSION_UI_BEARING_SURFACES: Set<SurfaceType>;
@@ -932,5 +1166,43 @@ type ParseResult = {
 declare function parseDesignMd(text: string): ParseResult;
 declare function validateDesignMd(d: DesignMd): ValidationIssue[];
 declare function hashDesignMd(text: string): string;
+/**
+ * Sentinel carried by every DESIGN.md the package ships as a sample:
+ *   - `assets/init/root/DESIGN.md` (seeded into the project root by `qfai init`)
+ *   - `assets/init/.qfai/assistant/skills/qfai-prototyping/templates/DESIGN.md.sample`
+ *
+ * The two files are the same fictional brand but are NOT byte-identical
+ * (they differ in front-matter whitespace alignment), so a sha256-equality
+ * guard would have to enumerate — and keep in sync — one digest per shipped
+ * sample. A marker is content-addressed instead of byte-addressed: it
+ * survives whitespace edits, covers both samples with one constant, and
+ * keeps covering any future sample that carries it.
+ *
+ * The marker lives in the markdown body, so `parseDesignMd` (which only
+ * reads front-matter) is unaffected: an unreplaced sample still parses and
+ * validates, and is rejected by identity instead.
+ */
+declare const DESIGN_MD_SAMPLE_MARKER = "QFAI-SAMPLE-DESIGN-MD";
+/**
+ * True when `text` is still (or is derived from) a DESIGN.md the package
+ * ships as a sample. Used to stop `/qfai-sdd` Phase 0 from sha256-freezing
+ * an unauthored brand as the project's brand contract, and to surface the
+ * same condition from `qfai validate` (QFAI-DCON-034).
+ *
+ * Two detectors, because the marker only covers samples seeded by releases
+ * that carry it:
+ *   1. `DESIGN_MD_SAMPLE_MARKER` — current samples, survives any edit that
+ *      leaves the comment in place.
+ *   2. Legacy content fingerprint — samples seeded before the marker
+ *      existed, which `qfai init` will never overwrite.
+ *
+ * `text` is `unknown` rather than `string` because this is re-exported from
+ * `core/index.ts` and so is reachable from untyped JavaScript, where a caller
+ * can hand over the result of a read that failed or a value that was never a
+ * file body. The guard below is what makes that safe; typing the parameter
+ * `string` would have made it dead code that only looked defensive. Internal
+ * callers pass a string and are unaffected.
+ */
+declare function isUnreplacedDesignMdSample(text: unknown): boolean;
 
-export { ARCHETYPES, type Archetype, type AtddCodeTraceabilityResult, type AtddForbiddenRef, type AtddSpecRefs, type AtddTestKind, type AtddTraceabilityMissing, type AtddTraceabilityScan, type AtddUnknownRef, type AtddUnknownRefKind, BROWSER_QA_PHASES, COLOR_KEYS, type ColorKey, type ConfigLoadResult, type ConfigPathKey, type ConfigSearchResult, DISCUSSION_NON_UI_SURFACES, DISCUSSION_UI_BEARING_SURFACES, type DecisionGuardrail, type DecisionGuardrailEntry, type DesignMd, type DesignMdColors, type DesignMdFonts, type DesignMdRadius, type DesignMdShadow, FONT_KEYS, type FailOn, type FontKey, type GuardrailCheckResult, type GuardrailIssue, type GuardrailIssueSeverity, type GuardrailLoadError, type GuardrailLoadResult, type GuardrailType, ID_PREFIXES, type IdFormatPrefix, type IdPrefix, type Issue, type IssueCategory, type IssueLocation, type IssueSeverity, type OrphanContractsPolicy, type OutputFormat, PROTOTYPING_SUPPORTED_SURFACES, type ParseError, type ParseResult, type PrototypingBrowserTool, type PrototypingSurface, type QfaiAtddConfig, type QfaiConfig, type QfaiOutputConfig, type QfaiPaths, type QfaiPrototypingCalibrationConfig, type QfaiPrototypingConfig, type QfaiPrototypingExecutionConfig, type QfaiReviewConfig, type QfaiUiuxAuditConfig, type QfaiUiuxConfig, type QfaiValidationConfig, RADIUS_KEYS, type RadiusKey, type ReportChangeType, type ReportChangeTypeSummary, type ReportChangeTypeWarning, type ReportContractCoverage, type ReportData, type ReportDeltaCoverage, type ReportFullHarnessExecution, type ReportGuardrailItem, type ReportGuardrails, type ReportIds, type ReportPrototypingSummary, type ReportRoundLifecycle, type ReportRuleFinding, type ReportSpecContractRefs, type ReportSpecCoverage, type ReportSummary, type ReportSurfaceClassification, type ReportTddCoverage, type ReportTddCoverageSpec, type ReportTestStrategy, type ReportTraceability, type ReportWaivers, type RunSddPreflightOptions, SHADOW_KEYS, type SddPreflightResult, type SddPreflightSource, type SddPreflightStatus, type ShadowKey, type TraceabilitySeverity, VISUAL_BROWSER_SURFACES, type ValidationCounts, type ValidationIssue, type ValidationOptions, type ValidationProfile, type ValidationResult, type ValidationTraceability, type ValidationWaiverAction, type ValidationWaiverDowngradeTo, type ValidationWaiverEntry, type ValidationWaiverMatch, type ValidationWaiverScope, type ValidationWaiverSeverity, type ValidationWaiverSuppressed, type ValidationWaivers, checkDecisionGuardrails, createReportData, defaultConfig, evaluateAtddCodeTraceability, extractAcSpecNumber, extractAllIds, extractBrSpecNumber, extractCapSpecNumber, extractCaseSpecNumber, extractDecisionGuardrailsFromMarkdown, extractIds, extractInvalidIds, extractScSpecNumber, extractSpecNumber, extractUsSpecNumber, filterDecisionGuardrailsByKeyword, findConfigRoot, formatGuardrailsForLlm, formatReportJson, formatReportMarkdown, getConfigPath, hashDesignMd, isDiscussionUiBearingSurfaceType, isNonUiDiscussionSurface, isSupportedPrototypingSurface, isValidPrototypingSurface, lintSql, loadConfig, loadDecisionGuardrails, normalizeDecisionGuardrails, parseDesignMd, requiresVisualBrowserEvidence, resolvePath, resolveToolVersion, runBrowserQaOrchestrated, runRenderCapture, runSddPreflight, sortDecisionGuardrails, summarizeBrowserQaResult, validateAtddCodeTraceability, validateContracts, validateDefinedIds, validateDesignMd, validateLayeredTraceability, validateOrphanProhibition, validateProject, validateSpecSplitByCapability, validateTraceability };
+export { AC_GHERKIN_SECTION, ARCHETYPES, ATDD_TEST_KIND_DIRS, type Archetype, type AtddCodeTraceabilityResult, type AtddForbiddenRef, type AtddSpecRefs, type AtddTestKind, type AtddTraceabilityMissing, type AtddTraceabilityScan, type AtddUnknownRef, type AtddUnknownRefKind, BROWSER_QA_PHASES, COLOR_KEYS, type ColorKey, type ConfigLoadResult, type ConfigPathKey, type ConfigSearchResult, DESIGN_MD_SAMPLE_MARKER, DISCUSSION_NON_UI_SURFACES, DISCUSSION_UI_BEARING_SURFACES, type DecisionGuardrail, type DecisionGuardrailEntry, type DesignMd, type DesignMdColors, type DesignMdFonts, type DesignMdRadius, type DesignMdShadow, FONT_KEYS, type FailOn, type FenceMaskOptions, type FontKey, type GuardrailCheckResult, type GuardrailIssue, type GuardrailIssueSeverity, type GuardrailLoadError, type GuardrailLoadResult, type GuardrailType, ID_PREFIXES, type IdFormatPrefix, type IdPrefix, type InvalidIdOccurrence, type Issue, type IssueCategory, type IssueLocation, type IssueSeverity, type OrphanContractsPolicy, type OutputFormat, PLANNED_CONTRACT_KEY, PROTOTYPING_SUPPORTED_SURFACES, type ParseError, type ParseResult, type PrototypingBrowserTool, type PrototypingSurface, type QfaiAtddConfig, type QfaiConfig, type QfaiOutputConfig, type QfaiPaths, type QfaiPrototypingCalibrationConfig, type QfaiPrototypingConfig, type QfaiPrototypingExecutionConfig, type QfaiReviewConfig, type QfaiUiuxAuditConfig, type QfaiUiuxConfig, type QfaiValidationConfig, RADIUS_KEYS, type RadiusKey, type ReportChangeType, type ReportChangeTypeSummary, type ReportChangeTypeWarning, type ReportContractCoverage, type ReportData, type ReportDeltaCoverage, type ReportFullHarnessExecution, type ReportGuardrailItem, type ReportGuardrails, type ReportIds, type ReportPrototypingSummary, type ReportRoundLifecycle, type ReportRuleFinding, type ReportSpecContractRefs, type ReportSpecCoverage, type ReportSummary, type ReportSurfaceClassification, type ReportTddCoverage, type ReportTddCoverageSpec, type ReportTestStrategy, type ReportTraceability, type ReportWaivers, type RunSddPreflightOptions, SHADOW_KEYS, type SddPreflightResult, type SddPreflightSource, type SddPreflightStatus, type ShadowKey, type TraceabilityGraph, type TraceabilityGraphEdge, type TraceabilityGraphNode, type TraceabilitySeverity, VISUAL_BROWSER_SURFACES, type ValidationCounts, type ValidationIssue, type ValidationOptions, type ValidationProfile, type ValidationResult, type ValidationTraceability, type ValidationWaiverAction, type ValidationWaiverDowngradeTo, type ValidationWaiverEntry, type ValidationWaiverMatch, type ValidationWaiverScope, type ValidationWaiverSeverity, type ValidationWaiverSuppressed, type ValidationWaivers, atddTestKindDirs, buildLayeredTraceabilityGraph, checkDecisionGuardrails, createReportData, defaultConfig, deriveAtddFilePattern, evaluateAtddCodeTraceability, extractAcSpecNumber, extractAllIds, extractBrSpecNumber, extractCapSpecNumber, extractCaseSpecNumber, extractDecisionGuardrailsFromMarkdown, extractIds, extractInvalidIdOccurrences, extractInvalidIds, extractScSpecNumber, extractSpecNumber, extractUsSpecNumber, filterDecisionGuardrailsByKeyword, findConfigRoot, formatGuardrailsForLlm, formatReportJson, formatReportMarkdown, getConfigPath, hashDesignMd, isDiscussionUiBearingSurfaceType, isNonUiDiscussionSurface, isPlannedApiContract, isSupportedPrototypingSurface, isUnreplacedDesignMdSample, isValidPrototypingSurface, lintSql, loadConfig, loadDecisionGuardrails, maskFencedCodeBlocks, normalizeDecisionGuardrails, parseDesignMd, qualifyId, requiresVisualBrowserEvidence, resolvePath, resolveToolVersion, runBrowserQaOrchestrated, runRenderCapture, runSddPreflight, sortDecisionGuardrails, specNumberForPath, summarizeBrowserQaResult, validateAtddCodeTraceability, validateContracts, validateDefinedIds, validateDesignMd, validateLayeredTraceability, validateOrphanProhibition, validateProject, validateSpecSplitByCapability, validateTraceability };