@shrkcrft/cli 0.1.0-alpha.29 → 0.1.0-alpha.31

package/dist/quality/run-quality.js

@@ -0,0 +1,442 @@
+import { withFileReadCache, withLexCache } from '@shrkcrft/boundaries';
+import { DEAD_SELECTOR_CAUSES, formatUnitLiveness } from '@shrkcrft/core';
+import { buildQualityReport, examineQualityGate, KNOWLEDGE_STALE_GATE_ID, QualityGateExamination, } from '@shrkcrft/inspector';
+import { warmCliReferenceRegistries } from "../surface/cli-command-resolver.js";
+import { ExitCode } from "../exit-codes.js";
+import { GATE_PLANES } from "../gates/gate-rule-view.js";
+import { runGatePlanes } from "../gates/run-gate-planes.js";
+import { buildGateEnvelope } from "../gates/gate-envelope.js";
+import { settleVerdict } from "../gates/settle-verdict.js";
+import { buildGateCoverage, coverageDeadUnits, coverageWentLiveUnits, formatDeadUnits, reportsDeadGlobs, settleGateCoverage, withRejectedRules, } from "../gates/rule-coverage.js";
+export const QUALITY_RUN_SCHEMA = 'sharkcraft.quality-run/v1';
+/** The isolated repro command for each inspector-bundle gate. */
+const INSPECTOR_REPRO = Object.freeze({
+    doctor: 'shrk doctor',
+    readiness: 'shrk doctor',
+    boundaries: 'shrk check boundaries',
+    coverage: 'shrk coverage',
+    drift: 'shrk drift',
+    'context-tests': 'shrk test context',
+    'agent-tests': 'shrk test agent',
+    packs: 'shrk packs doctor',
+    // Round 13: the item is `buildDeclaredXrefReport` — exactly what `self-config
+    // xrefs` prints. `self-config doctor` computes a different report (dead
+    // units, probes, rejections), so on a tree with no declared id the item
+    // said "skipped — none declared" while its repro exited 2 over dead units.
+    'cross-references': 'shrk self-config xrefs',
+});
+/** At most this many unexamined gate ids ride on the run's coverage record. */
+const COVERAGE_LABEL_CAP = 20;
+/**
+ * Run EVERY configured gate to completion and report every failure.
+ *
+ * A CI job that chains gates as separate steps stops at the first failing step,
+ * so N independent failures cost N round-trips to discover — the classic case
+ * being a first-ever run on a long-lived branch, where fixing gate A only
+ * reveals gate B. The default here is therefore exhaustive: the point is to
+ * surface the whole backlog in one local pass. `failFast` is available for the
+ * opposite, CI-like behaviour, and says so in the report rather than making the
+ * remaining gates look clean.
+ */
+export async function runQuality(input) {
+    const items = [];
+    const diagnostics = [...(input.planeDiagnostics ?? [])];
+    // Warm the shared reference registry WITH the command resolver BEFORE any
+    // bundle gate reads it. The agent-test gate resolves `expectedCommands`
+    // through it: warmed bare (the inspector cannot build the command index), a
+    // correct `shrk doctor` read as NOT VERIFIED here while `shrk test agent`
+    // passed it — the aggregate and the verb disagreeing about one test.
+    try {
+        await warmCliReferenceRegistries(input.inspection);
+    }
+    catch (e) {
+        diagnostics.push(`could not warm the reference registries: ${e.message}`);
+    }
+    const report = await buildQualityReport({
+        inspection: input.inspection,
+        config: input.config,
+        strict: input.strict,
+        ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}),
+        // This bundle runs the seven planes below, so the report must not add its
+        // not-run `gate-planes` row.
+        callerRunsGatePlanes: true,
+    });
+    // The knowledge stale-check row is THE gate MCP / the dashboard read too; it
+    // becomes this bundle's item after the fail-fast check below, as before.
+    let knowledgeGate;
+    for (const g of report.gates) {
+        if (g.id === KNOWLEDGE_STALE_GATE_ID) {
+            knowledgeGate = g;
+            continue;
+        }
+        // A gate that ran over NOTHING (zero context tests, zero boundary rules)
+        // reports `passed` from a zero failure count, which is not a pass. It is a
+        // skip: DELIBERATE when the gate is optional (so a repo without context
+        // tests still goes green), accidental — NOT verified — when it is required.
+        // THE classification of a gate's run (`examineQualityGate`), the same one
+        // the inspector derives `IQualityReport.overall` from, so MCP / the
+        // dashboard and this bundle cannot disagree about a gate. A gate that ran
+        // over NOTHING (zero context tests, zero boundary rules) is a skip:
+        // deliberate when optional, NOT verified when required. A gate that found
+        // nothing wrong over PART of its scope is an accidental skip too.
+        const exam = examineQualityGate(g);
+        const examinedNothing = g.executed && g.data?.['examinedNothing'] === true;
+        const partial = g.executed && !examinedNothing && exam === QualityGateExamination.Unexamined;
+        const status = !g.executed
+            ? 'error'
+            : exam !== QualityGateExamination.Examined
+                ? 'skipped'
+                : g.passed
+                    ? 'passed'
+                    : 'failed';
+        items.push({
+            id: g.id,
+            label: g.label,
+            status,
+            severity: g.blocking ? 'error' : 'warning',
+            notes: examinedNothing
+                ? [
+                    ...g.notes,
+                    g.blocking
+                        ? 'examined nothing — this gate is required, so it is NOT verified'
+                        : 'examined nothing — optional, so skipped (never counted as a pass)',
+                ]
+                : g.notes,
+            repro: INSPECTOR_REPRO[g.id] ?? 'shrk quality',
+            ...(examinedNothing ? { skippedDeliberately: !g.blocking } : {}),
+            ...(partial && !examinedNothing ? { partial: true } : {}),
+            ...(g.data ? { data: g.data } : {}),
+        });
+    }
+    const stopNow = () => input.failFast && items.some((i) => i.status === 'failed' && i.severity === 'error');
+    // The knowledge corpus verdict, through the SAME gate `shrk knowledge
+    // stale-check` settles — so the pre-push bundle and the verb cannot disagree
+    // (an unverifiable entry keeps both off `pass`) — read from the report's own
+    // row, the one MCP `get_quality_report` and the dashboard read.
+    if (!stopNow() && knowledgeGate)
+        items.push(knowledgeStaleItem(knowledgeGate));
+    // The seven data-defined planes. Without them the "before you push" command
+    // does not run the rules the repo actually declared, which is the gap that
+    // makes `gates check` a separate step people forget.
+    // A pack rule the merge seam rejected is a configured rule that did NOT run:
+    // a FAILED item (a config failure blocks, as in `gates check`), and an
+    // errored row of the coverage item (round 12 review, R12-X1).
+    const rejectedRules = input.rejectedRules ?? [];
+    const rejectedKeys = new Set(rejectedRules.map((r) => `${r.type}:${r.id}`));
+    const hasPlaneRules = input.gateRules.length > 0 || rejectedRules.length > 0;
+    if (hasPlaneRules && !stopNow()) {
+        // ONE lex window and ONE read window around the plane check AND the
+        // coverage pass (round 11 review: the coverage item re-walked, re-read and
+        // re-lexed every file the plane run had just read — ~0.4s on this repo).
+        // The lex memo is keyed by CONTENT, so it can never be stale; the read memo
+        // is exact because every spawn site (`compute.run`, `regen`) clears it
+        // right after the child exits.
+        withLexCache(() => withFileReadCache(() => {
+            const planeRun = input.gateRules.length > 0
+                ? runGatePlanes(input.gateRules, {
+                    cwd: input.cwd,
+                    excludeDirs: input.excludeDirs,
+                    ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}),
+                    inspection: input.inspection,
+                })
+                : { results: [], diagnostics: [] };
+            diagnostics.push(...planeRun.diagnostics);
+            const results = [...planeRun.results, ...rejectedRules];
+            // `partial` is derived in ONE place — the envelope builder — so quality
+            // marks a rule partial exactly when `gates check` does.
+            const settledRules = buildGateEnvelope('quality', ExitCode.VerifiedPass, results, {
+                unit: 'rules',
+                expected: results.length,
+                examined: results.length,
+            }).rules;
+            for (const plane of GATE_PLANES) {
+                for (const r of settledRules.filter((x) => x.type === plane)) {
+                    const item = planeItem(plane, r, input.strict);
+                    items.push(rejectedKeys.has(`${plane}:${r.id}`)
+                        ? { ...item, status: 'failed', severity: 'error', repro: 'shrk packs contributions' }
+                        : item);
+                }
+            }
+            // The stale-selector detector and every rule's selfTest — what `gates
+            // coverage` concludes. Without it "the before-you-push gate" passed a
+            // rule whose selfTest was broken, because only `gates coverage`
+            // evaluates one.
+            items.push(stopNow() ? coverageNotRun() : gatesCoverageItem(input, results));
+        }));
+    }
+    else if (hasPlaneRules) {
+        for (const r of rejectedRules) {
+            items.push({
+                id: `${r.type}:${r.id}`,
+                label: `[${r.type}] ${r.id}`,
+                status: 'failed',
+                severity: 'error',
+                notes: [r.error ?? 'failed validation at the pack-plane merge seam — NOT evaluated'],
+                repro: 'shrk packs contributions',
+            });
+        }
+        for (const r of input.gateRules) {
+            items.push({
+                id: `${r.plane}:${r.id}`,
+                label: `[${r.plane}] ${r.id}`,
+                status: 'skipped',
+                severity: 'warning',
+                notes: ['not run — an earlier gate failed under --fail-fast'],
+                repro: `shrk gates check --only ${r.id}`,
+                skippedDeliberately: true,
+            });
+        }
+        items.push(coverageNotRun());
+    }
+    for (const r of input.skippedByScope ?? []) {
+        items.push({
+            id: `${r.plane}:${r.id}`,
+            label: `[${r.plane}] ${r.id}`,
+            status: 'skipped',
+            severity: 'warning',
+            notes: ['outside the changeset'],
+            repro: `shrk gates check --only ${r.id}`,
+            skippedDeliberately: true,
+        });
+    }
+    const failed = items.filter((i) => i.status === 'failed' && i.severity === 'error').length;
+    const failedWarnings = items.filter((i) => i.status === 'failed' && i.severity !== 'error').length;
+    const errored = items.filter((i) => i.status === 'error').length;
+    const evaluated = items.filter((i) => i.status === 'passed' || i.status === 'failed').length;
+    const deliberate = items.filter((i) => i.status === 'skipped' && i.skippedDeliberately === true).length;
+    const unexamined = items.filter((i) => i.status === 'error' || (i.status === 'skipped' && i.skippedDeliberately !== true));
+    // The verdict goes through the one guard every verdict verb uses: a blocking
+    // failure is `fail`; otherwise any gate that errored, skipped by accident or
+    // passed over part of its scope — or a run that examined nothing at all — is
+    // a coverage shortfall, which can never settle to `pass`.
+    const coverage = {
+        unit: 'gates',
+        expected: items.length - deliberate,
+        examined: evaluated,
+        ...(unexamined.length > 0
+            ? {
+                unexamined: unexamined.slice(0, COVERAGE_LABEL_CAP).map((i) => i.id),
+                unexaminedTotal: unexamined.length,
+                reason: unexamined.some((i) => i.partial === true)
+                    ? 'could not run, examined nothing, or examined only part of their scope'
+                    : 'could not run, or examined nothing',
+            }
+            : {}),
+    };
+    const settled = settleVerdict(failed > 0 ? ExitCode.Failure : ExitCode.VerifiedPass, [coverage]);
+    const verdict = settled.verdict === 'pass' ? 'pass' : settled.verdict === 'not-verified' ? 'not-verified' : 'fail';
+    return {
+        schema: QUALITY_RUN_SCHEMA,
+        items,
+        passed: items.filter((i) => i.status === 'passed').length,
+        failed,
+        failedWarnings,
+        skipped: items.filter((i) => i.status === 'skipped').length,
+        errored,
+        evaluated,
+        verdict,
+        exit: settled.exit,
+        coverage,
+        shortfalls: settled.shortfalls,
+        accepted: settled.accepted,
+        ...(input.changedFiles ? { scopedFiles: input.changedFiles.length } : {}),
+        failFast: input.failFast,
+        diagnostics,
+    };
+}
+const COVERAGE_ITEM_ID = 'gates-coverage';
+const COVERAGE_ITEM_LABEL = 'Gate-rule coverage — stale selectors + selfTest';
+/**
+ * `gates coverage` as one bundle item: stale selectors, every rule's selfTest,
+ * partial rules. Settled by `settleGateCoverage` — the derivation the verb
+ * itself uses — so this item and `shrk gates coverage` cannot disagree. Dead
+ * globs inside connected rules ride along as advisory notes, exactly as they
+ * are advisory in the verb without `--fail-on-dead-units`.
+ *
+ * A rule coverage cannot inspect without a side effect (`inspectable: false`,
+ * e.g. a `command` baseline with no `watchFiles`) is settled on the coverage
+ * its plane CHECK reported in this same run. That check spawned the command and
+ * examined it. Reading coverage's "could not inspect" as "unverified" would
+ * leave a healthy rule a permanent `2`, with this item and the rule's own plane
+ * item contradicting each other about one rule. A selfTest such a rule can
+ * never evaluate stays a misconfiguration (`1`): its status is untouched.
+ */
+function gatesCoverageItem(input, planeResults) {
+    // Rules arrive with `$use` already resolved; the shared-extractor section of
+    // the report is not read here, so no extractor map is needed.
+    const built = withRejectedRules(buildGateCoverage(input.cwd, input.gateRules, input.excludeDirs, {}, false, input.inspection), input.rejectedRules ?? []);
+    const checked = new Map(planeResults.map((r) => [`${r.type}:${r.id}`, r.coverage]));
+    const settledOnCheck = [];
+    const report = {
+        ...built,
+        rules: built.rules.map((r) => {
+            const fromCheck = r.inspectable === false ? checked.get(`${r.plane}:${r.id}`) : undefined;
+            if (!fromCheck)
+                return r;
+            settledOnCheck.push(`[${r.plane}] ${r.id}`);
+            return { ...r, coverage: fromCheck };
+        }),
+    };
+    const env = settleGateCoverage(report);
+    const notes = [];
+    const noticed = new Set();
+    // A rule its own negations emptied is not stale — its skipReason says why.
+    const emptiedByNegations = new Set(report.rules.filter((r) => r.excludedByNegations !== undefined).map((r) => `${r.plane}:${r.id}`));
+    for (const r of env.rules) {
+        if (r.status === 'passed')
+            continue;
+        noticed.add(r.id);
+        const lead = `[${r.type}] ${r.id}`;
+        if (r.status === 'partial') {
+            notes.push(`${lead} — PARTIAL: ${r.shortfall ?? 'examined less than its scope'}`);
+        }
+        else if (r.status === 'skipped') {
+            notes.push(`${lead} — ${r.skipReason ?? 'matched nothing'}` +
+                (emptiedByNegations.has(`${r.type}:${r.id}`) ? '' : '; the selector is probably stale'));
+        }
+        else if (r.status === 'error') {
+            notes.push(`${lead} — ${r.error ?? 'could not run'}`);
+        }
+        else if (r.violations.length > 0) {
+            for (const v of r.violations)
+                notes.push(`${lead} — selfTest: ${v.message ?? v.id}`);
+        }
+        else {
+            notes.push(`${lead} — ${r.skipReason ?? 'failed'}`);
+        }
+    }
+    for (const r of report.rules) {
+        // The same predicate `gates coverage` counts and draws with: a rule already
+        // reported as matching nothing gets no second, advisory note.
+        if (!reportsDeadGlobs(r))
+            continue;
+        // Worded by the one formatter `gates coverage` prints with, so a dead
+        // negation reads "excludes nothing", never "matched 0 files".
+        const dead = coverageDeadUnits(r);
+        // …with the one causes sentence (round 13 review): a note has no footer,
+        // so it carries `DEAD_SELECTOR_CAUSES` itself, as `check boundaries` does.
+        notes.push(`[${r.plane}] ${r.id} — advisory: ${dead.length} dead glob(s): ${formatDeadUnits(dead)} — ${DEAD_SELECTOR_CAUSES}`);
+    }
+    // Round 13 (lane G): a glob marked `expectEmpty` whose target now exists —
+    // the fence went live — is an ADVISORY note here, worded by the one
+    // per-unit formatter; quality never fails on a selector unit (`gates
+    // coverage --fail-on-dead-units` does, for a local marker). A PACK marker is
+    // INFO (round 13 review), as `check boundaries` prints it.
+    for (const r of report.rules) {
+        for (const u of coverageWentLiveUnits(r)) {
+            const tag = u.mark?.packageName !== undefined ? 'info' : 'advisory';
+            notes.push(`[${r.plane}] ${r.id} — ${tag}: ${formatUnitLiveness(u, { causes: false })}`);
+        }
+    }
+    // …and every intended-empty unit it ACCEPTED is printed, never silent — the
+    // settled acceptance lines (non-empty only when the item passed).
+    for (const a of env.accepted)
+        notes.push(`accepted: ${a}`);
+    for (const label of settledOnCheck) {
+        notes.push(`${label} — coverage cannot inspect it without running it; settled on its plane check in this run`);
+    }
+    return {
+        id: COVERAGE_ITEM_ID,
+        label: COVERAGE_ITEM_LABEL,
+        status: env.exit === ExitCode.Failure ? 'failed' : env.exit === ExitCode.VerifiedPass ? 'passed' : 'skipped',
+        // A broken selfTest blocks whatever --strict says, as it does in the verb.
+        severity: 'error',
+        notes,
+        repro: noticed.size > 0 ? `shrk gates coverage --only ${[...noticed].join(',')}` : 'shrk gates coverage',
+        data: {
+            rules: report.total,
+            empty: report.empty,
+            errored: report.errored,
+            expectationFailures: report.expectationFailures,
+            deadGlobs: report.deadGlobCount,
+        },
+    };
+}
+/** The coverage item when `--fail-fast` stopped the run before it. */
+function coverageNotRun() {
+    return {
+        id: COVERAGE_ITEM_ID,
+        label: COVERAGE_ITEM_LABEL,
+        status: 'skipped',
+        severity: 'warning',
+        notes: ['not run — an earlier gate failed under --fail-fast'],
+        repro: 'shrk gates coverage',
+        skippedDeliberately: true,
+    };
+}
+/** Map one plane rule result onto a bundle item, with its isolated repro verb. */
+function planeItem(plane, r, strict) {
+    const notes = [];
+    if (r.status === 'skipped' && r.skipReason)
+        notes.push(`SKIPPED — ${r.skipReason}`);
+    // A rule that passed over PART of its scope proved nothing about the rest, so
+    // here it is an accidental skip: the verdict cannot be `pass` over it.
+    if (r.status === 'partial' && r.shortfall)
+        notes.push(`PARTIAL — ${r.shortfall}`);
+    if (r.error)
+        notes.push(r.error);
+    for (const v of r.violations.slice(0, 5)) {
+        const at = v.file ? ` (${v.file}${v.line !== undefined ? `:${v.line}` : ''})` : '';
+        notes.push(`${v.id}${at}${v.message ? ` — ${v.message}` : ''}`);
+    }
+    if (r.violations.length > 5)
+        notes.push(`… ${r.violations.length - 5} more`);
+    return {
+        id: `${plane}:${r.id}`,
+        label: `[${plane}] ${r.id}`,
+        status: r.status === 'partial' ? 'skipped' : r.status,
+        ...(r.status === 'partial' ? { partial: true } : {}),
+        severity: strict || r.severity === 'error' ? 'error' : 'warning',
+        notes,
+        // `gates explain` resolves a rule id across EVERY plane, so one form works
+        // for all seven and the developer never has to know which verb owns it.
+        repro: `shrk gates explain ${r.id}`,
+        ...(Object.keys(r.counts).length > 0 ? { data: { ...r.counts } } : {}),
+    };
+}
+/**
+ * The knowledge stale-check as one bundle item — the report's own
+ * `knowledge-stale` row (`knowledgeStaleQualityGate`, decided by the SAME gate
+ * the verb settles), mapped onto the item shape. Nothing is re-derived here, so
+ * this item, MCP `get_quality_report` and the dashboard read one answer.
+ *
+ * An empty corpus (or a changeset no entry references) is a DELIBERATE skip —
+ * a missing `sharkcraft/` folder or a broken config is the doctor gate's
+ * finding. Any unverifiable entry that no `knowledgeCheck.minReferenced` floor
+ * accepts is an ACCIDENTAL skip: the run cannot settle to `pass` over it.
+ */
+function knowledgeStaleItem(g) {
+    const base = {
+        id: g.id,
+        label: g.label,
+        severity: 'error',
+        repro: 'shrk knowledge stale-check',
+    };
+    const skip = g.data?.['skip'];
+    if (skip === 'empty-corpus') {
+        return { ...base, status: 'skipped', notes: g.notes, skippedDeliberately: true, data: { examinedNothing: true } };
+    }
+    if (skip === 'out-of-changeset') {
+        return {
+            ...base,
+            status: 'skipped',
+            notes: g.notes,
+            repro: 'shrk knowledge stale-check --changed-only',
+            skippedDeliberately: true,
+        };
+    }
+    if (!g.executed)
+        return { ...base, status: 'error', notes: g.notes };
+    const exit = g.data?.['settledExit'];
+    return {
+        ...base,
+        status: exit === ExitCode.VerifiedPass ? 'passed' : exit === ExitCode.Failure ? 'failed' : 'skipped',
+        notes: g.notes,
+        ...(exit === ExitCode.NotVerified ? { skippedDeliberately: false } : {}),
+        data: {
+            coverage: g.data?.['coverage'],
+            unverifiableIds: g.data?.['unverifiableIds'],
+            failureCounts: g.data?.['failureCounts'],
+        },
+    };
+}

package/dist/schemas/json-schemas.d.ts

@@ -420,9 +420,115 @@ export declare const KnowledgeEntrySchema: {
         readonly summary: {
             readonly type: "string";
         };
+        readonly related: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly seeAlso: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly supersededBy: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
         readonly actionHints: {
             readonly $ref: "action-hints.json";
         };
+        readonly references: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["kind"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly enum: readonly ["file", "directory", "symbol", "command", "template", "playbook", "construct", "helper", "policy", "boundary-rule", "path-convention", "package", "url"];
+                    };
+                    readonly path: {
+                        readonly type: "string";
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                    };
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly command: {
+                        readonly type: "string";
+                    };
+                    readonly required: {
+                        readonly type: "boolean";
+                    };
+                    readonly note: {
+                        readonly type: "string";
+                    };
+                    readonly contains: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly matches: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly scan: {
+                        readonly enum: readonly ["all", "code", "strings", "comments", "code-and-templates"];
+                    };
+                    readonly count: {
+                        readonly type: "object";
+                        readonly required: readonly ["source", "expected"];
+                        readonly properties: {
+                            readonly source: {
+                                readonly type: "object";
+                            };
+                            readonly expected: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                            };
+                            readonly measure: {
+                                readonly enum: readonly ["ids", "sites"];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly anchors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["id", "kind"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["file", "symbol", "command", "construct", "template", "helper", "playbook", "policy"];
+                    };
+                    readonly path: {
+                        readonly type: "string";
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                    };
+                    readonly targetId: {
+                        readonly type: "string";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly verifiedOn: {
+            readonly type: "string";
+            readonly pattern: "^\\d{4}-\\d{2}-\\d{2}$";
+        };
     };
 };
 export declare const AdoptionStateSchema: {
@@ -943,10 +1049,29 @@ export declare const ScaffoldPatternSchema: {
         };
         readonly matchPaths: {
             readonly type: "array";
+            readonly minItems: 1;
             readonly items: {
-                readonly type: "string";
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["pattern", "expectEmpty"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly pattern: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly expectEmpty: {
+                            readonly const: true;
+                        };
+                        readonly reason: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                }];
             };
-            readonly minItems: 1;
         };
         readonly excludePaths: {
             readonly type: "array";
@@ -1063,7 +1188,7 @@ export declare const QualityReportSchema: {
     readonly required: readonly ["overall", "gates", "score"];
     readonly properties: {
         readonly overall: {
-            readonly enum: readonly ["pass", "warn", "fail"];
+            readonly enum: readonly ["pass", "warn", "fail", "not-verified"];
         };
         readonly blockers: {
             readonly type: "integer";
@@ -1092,6 +1217,15 @@ export declare const QualityReportSchema: {
                 readonly type: "string";
             };
         };
+        readonly coverage: {
+            readonly type: "object";
+        };
+        readonly shortfalls: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
     };
 };
 export declare const SafetyAuditSchema: {
@@ -1540,6 +1674,34 @@ export declare const AreaMapSchema: {
         readonly unclassifiedFiles: {
             readonly type: "integer";
         };
+        readonly totalFiles: {
+            readonly type: "integer";
+        };
+        readonly classifiedFiles: {
+            readonly type: "integer";
+        };
+        readonly classificationRate: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly minClassificationRate: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly degraded: {
+            readonly type: "boolean";
+        };
+        readonly unclassifiedSample: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly patternSource: {
+            readonly enum: readonly ["built-in", "config", "config+built-in"];
+        };
     };
 };
 export declare const ImpactAnalysisSchema: {
@@ -1564,6 +1726,25 @@ export declare const ImpactAnalysisSchema: {
         readonly affectedAreas: {
             readonly type: "array";
         };
+        readonly areaCoverage: {
+            readonly type: "object";
+            readonly properties: {
+                readonly classificationRate: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                };
+                readonly degraded: {
+                    readonly type: "boolean";
+                };
+                readonly unclassifiedTargets: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
     };
 };
 export declare const TestImpactSchema: {