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

package/dist/gates/accepted-empty-note.d.ts

@@ -0,0 +1,10 @@
+/**
+ * THE printed segment for the rules accepted as intended-empty (round 13, K6):
+ * `, M accepted as intended-empty`, appended to a verb's `N of T` evaluated
+ * count — the words `check boundaries` prints in its rule list. Such a rule
+ * examined 0 files by design, so it is never inside N; it is named apart.
+ * Empty when there is none, so a run without a planned rule prints exactly
+ * what it printed before.
+ */
+export declare function acceptedEmptyNote(count: number | undefined): string;
+//# sourceMappingURL=accepted-empty-note.d.ts.map

package/dist/gates/accepted-empty-note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accepted-empty-note.d.ts","sourceRoot":"","sources":["../../src/gates/accepted-empty-note.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAEnE"}

package/dist/gates/accepted-empty-note.js

@@ -0,0 +1,11 @@
+/**
+ * THE printed segment for the rules accepted as intended-empty (round 13, K6):
+ * `, M accepted as intended-empty`, appended to a verb's `N of T` evaluated
+ * count — the words `check boundaries` prints in its rule list. Such a rule
+ * examined 0 files by design, so it is never inside N; it is named apart.
+ * Empty when there is none, so a run without a planned rule prints exactly
+ * what it printed before.
+ */
+export function acceptedEmptyNote(count) {
+    return count !== undefined && count > 0 ? `, ${count} accepted as intended-empty` : '';
+}

package/dist/gates/allow-empty.d.ts

@@ -0,0 +1,25 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import { type ParsedArgs } from '../command-registry.js';
+/** The shared flag name — one spelling across every verdict verb. */
+export declare const ALLOW_EMPTY_FLAG = "allow-empty";
+/**
+ * The `--allow-empty` valve, defined once for every verdict verb.
+ *
+ * "Nothing to examine" is not a pass — a verb whose request covered zero units
+ * (no rules declared, nothing in the changeset, nothing deleted) exits `2`. A
+ * hook that runs on every commit legitimately hits that state, so it may accept
+ * it EXPLICITLY. Spread the result into the verb's RUN coverage:
+ *
+ * ```ts
+ * buildGateEnvelope(verb, proposed, rules, { unit: 'rules', expected, examined, ...allowEmptyValve(args, expected) })
+ * ```
+ *
+ * It sets `acceptedBy: '--allow-empty'` ONLY when the flag was passed AND the
+ * request covered nothing (`expected === 0`). It never accepts a partial scope —
+ * rules that exist but checked nothing are a stale selector, not an empty
+ * request — and the acceptance is printed by `verdictLine`, never silent.
+ * Declare the flag in the verb's `booleanFlags` so it never swallows a
+ * following positional.
+ */
+export declare function allowEmptyValve(args: ParsedArgs, expected: number): Pick<IVerdictCoverage, 'acceptedBy'>;
+//# sourceMappingURL=allow-empty.d.ts.map

package/dist/gates/allow-empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allow-empty.d.ts","sourceRoot":"","sources":["../../src/gates/allow-empty.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEnE,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,GACf,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAItC"}

package/dist/gates/allow-empty.js

@@ -0,0 +1,27 @@
+import { flagBool } from "../command-registry.js";
+/** The shared flag name — one spelling across every verdict verb. */
+export const ALLOW_EMPTY_FLAG = 'allow-empty';
+/**
+ * The `--allow-empty` valve, defined once for every verdict verb.
+ *
+ * "Nothing to examine" is not a pass — a verb whose request covered zero units
+ * (no rules declared, nothing in the changeset, nothing deleted) exits `2`. A
+ * hook that runs on every commit legitimately hits that state, so it may accept
+ * it EXPLICITLY. Spread the result into the verb's RUN coverage:
+ *
+ * ```ts
+ * buildGateEnvelope(verb, proposed, rules, { unit: 'rules', expected, examined, ...allowEmptyValve(args, expected) })
+ * ```
+ *
+ * It sets `acceptedBy: '--allow-empty'` ONLY when the flag was passed AND the
+ * request covered nothing (`expected === 0`). It never accepts a partial scope —
+ * rules that exist but checked nothing are a stale selector, not an empty
+ * request — and the acceptance is printed by `verdictLine`, never silent.
+ * Declare the flag in the verb's `booleanFlags` so it never swallows a
+ * following positional.
+ */
+export function allowEmptyValve(args, expected) {
+    return flagBool(args, ALLOW_EMPTY_FLAG) && expected === 0
+        ? { acceptedBy: `--${ALLOW_EMPTY_FLAG}` }
+        : {};
+}

package/dist/gates/asset-doctor-failing-units.d.ts

@@ -0,0 +1,16 @@
+import { type IUnitLiveness } from '@shrkcrft/core';
+/**
+ * THE selector units that fail an asset doctor's run (round 13 review) — the
+ * predicate `assetDoctorProposedExit` proposes its `1` from
+ * (`selectorUnitFails`; `--strict` is not the unit promoter on these verbs):
+ * an unmarked dead unit under `--fail-on-dead-units`, or a LOCAL marker whose
+ * target appeared. A pack marker never fails. `registrations doctor`,
+ * `scaffolds doctor`, `search tuning doctor` and `self-config doctor|report`
+ * print them (`assetDoctorFailureLine`) and carry them as `failingUnits`, so an
+ * exit 1 is never silent about why.
+ */
+export declare function assetDoctorFailingUnits(units: readonly IUnitLiveness[], flags: {
+    readonly failOnDeadUnits: boolean;
+    readonly strict: boolean;
+}): IUnitLiveness[];
+//# sourceMappingURL=asset-doctor-failing-units.d.ts.map

package/dist/gates/asset-doctor-failing-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-doctor-failing-units.d.ts","sourceRoot":"","sources":["../../src/gates/asset-doctor-failing-units.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,KAAK,EAAE;IAAE,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACrE,aAAa,EAAE,CAIjB"}

package/dist/gates/asset-doctor-failing-units.js

@@ -0,0 +1,14 @@
+import { selectorUnitFails } from '@shrkcrft/core';
+/**
+ * THE selector units that fail an asset doctor's run (round 13 review) — the
+ * predicate `assetDoctorProposedExit` proposes its `1` from
+ * (`selectorUnitFails`; `--strict` is not the unit promoter on these verbs):
+ * an unmarked dead unit under `--fail-on-dead-units`, or a LOCAL marker whose
+ * target appeared. A pack marker never fails. `registrations doctor`,
+ * `scaffolds doctor`, `search tuning doctor` and `self-config doctor|report`
+ * print them (`assetDoctorFailureLine`) and carry them as `failingUnits`, so an
+ * exit 1 is never silent about why.
+ */
+export function assetDoctorFailingUnits(units, flags) {
+    return units.filter((u) => selectorUnitFails(u, { failOnDeadUnits: flags.failOnDeadUnits, strict: flags.strict, strictPromotesWarnings: false }));
+}

package/dist/gates/asset-doctor-failure-line.d.ts

@@ -0,0 +1,16 @@
+import { type IUnitLiveness } from '@shrkcrft/core';
+/**
+ * The verdict line an asset doctor prints when `--fail-on-dead-units` is what
+ * failed it (round 13 review). `verdictLine` prints nothing for a `1` with no
+ * shortfall ("the verb already printed them") — but these doctors printed only
+ * INFO issues, so the run exited 1 with no line saying why (`self-config
+ * doctor`'s header even read `verdict OK`):
+ *
+ *   Verdict: registration-hint doctor needs attention — 1 went-live expectEmpty unit(s) (--fail-on-dead-units)
+ *     • <formatUnitLiveness(u)>
+ *
+ * `failing` is `assetDoctorFailingUnits(...)`. Empty when no unit fails (the
+ * doctor's errors and warnings speak for themselves).
+ */
+export declare function assetDoctorFailureLine(label: string, failing: readonly IUnitLiveness[]): string;
+//# sourceMappingURL=asset-doctor-failure-line.d.ts.map

package/dist/gates/asset-doctor-failure-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-doctor-failure-line.d.ts","sourceRoot":"","sources":["../../src/gates/asset-doctor-failure-line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyC,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE3F;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAY/F"}

package/dist/gates/asset-doctor-failure-line.js

@@ -0,0 +1,28 @@
+import { formatUnitLiveness, UnitLivenessState } from '@shrkcrft/core';
+/**
+ * The verdict line an asset doctor prints when `--fail-on-dead-units` is what
+ * failed it (round 13 review). `verdictLine` prints nothing for a `1` with no
+ * shortfall ("the verb already printed them") — but these doctors printed only
+ * INFO issues, so the run exited 1 with no line saying why (`self-config
+ * doctor`'s header even read `verdict OK`):
+ *
+ *   Verdict: registration-hint doctor needs attention — 1 went-live expectEmpty unit(s) (--fail-on-dead-units)
+ *     • <formatUnitLiveness(u)>
+ *
+ * `failing` is `assetDoctorFailingUnits(...)`. Empty when no unit fails (the
+ * doctor's errors and warnings speak for themselves).
+ */
+export function assetDoctorFailureLine(label, failing) {
+    if (failing.length === 0)
+        return '';
+    const dead = failing.filter((u) => u.state === UnitLivenessState.Dead).length;
+    const live = failing.length - dead;
+    const parts = [
+        ...(dead > 0 ? [`${dead} dead unit(s)`] : []),
+        ...(live > 0 ? [`${live} went-live expectEmpty unit(s)`] : []),
+    ];
+    return [
+        `Verdict: ${label} needs attention — ${parts.join(', ')} (--fail-on-dead-units)`,
+        ...failing.map((u) => `  • ${formatUnitLiveness(u)}`),
+    ].join('\n');
+}

package/dist/gates/empty-rule-advice-lines.d.ts

@@ -0,0 +1,15 @@
+/**
+ * THE empty-rule advice a plane verb prints under the rules that matched
+ * nothing (round 13) — one sentence per `fails` value present, each from core's
+ * `formatEmptyRuleAdvice` with the rule's REAL `fails`: a failing rule is never
+ * told to set `failOnEmpty: true`, a soft one never told to set it `false`.
+ *
+ * Every plane verb's skip listing calls it — `check wiring`, `policy-lint`
+ * (their 0-evaluated early returns included), `gates coverage`, `baseline
+ * check`, `generated check`, `docs references check` — so no branch drops the
+ * advice, and no verb words it twice.
+ */
+export declare function emptyRuleAdviceLines(rules: readonly {
+    readonly fails: boolean;
+}[]): string[];
+//# sourceMappingURL=empty-rule-advice-lines.d.ts.map

package/dist/gates/empty-rule-advice-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-rule-advice-lines.d.ts","sourceRoot":"","sources":["../../src/gates/empty-rule-advice-lines.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,MAAM,EAAE,CAK5F"}

package/dist/gates/empty-rule-advice-lines.js

@@ -0,0 +1,20 @@
+import { formatEmptyRuleAdvice } from '@shrkcrft/core';
+/**
+ * THE empty-rule advice a plane verb prints under the rules that matched
+ * nothing (round 13) — one sentence per `fails` value present, each from core's
+ * `formatEmptyRuleAdvice` with the rule's REAL `fails`: a failing rule is never
+ * told to set `failOnEmpty: true`, a soft one never told to set it `false`.
+ *
+ * Every plane verb's skip listing calls it — `check wiring`, `policy-lint`
+ * (their 0-evaluated early returns included), `gates coverage`, `baseline
+ * check`, `generated check`, `docs references check` — so no branch drops the
+ * advice, and no verb words it twice.
+ */
+export function emptyRuleAdviceLines(rules) {
+    const out = [];
+    if (rules.some((r) => r.fails))
+        out.push(formatEmptyRuleAdvice({ fails: true }));
+    if (rules.some((r) => !r.fails))
+        out.push(formatEmptyRuleAdvice({ fails: false }));
+    return out;
+}

package/dist/gates/gate-envelope.d.ts

@@ -11,15 +11,24 @@
  * rides along under a `gate` key, so `jq .gate` is the uniform read and nothing
  * that worked before stops working.
  */
+import { type IUnitStateLists, type IVerdictCoverage } from '@shrkcrft/core';
+import type { ISettledVerdict } from './settled-verdict.js';
 export declare const GATE_ENVELOPE_SCHEMA: "sharkcraft.gate/v1";
-/** Which data-defined plane produced a rule result. */
-export type GateRuleType = 'wiring' | 'policy' | 'registry' | 'registration' | 'baseline' | 'generated' | 'doc-reference';
+/** Which data-defined plane (or verdict surface) produced a rule result. */
+export type GateRuleType = 'wiring' | 'policy' | 'registry' | 'registration' | 'baseline' | 'generated' | 'doc-reference' | 'boundary' | 'knowledge' | 'lifecycle' | 'orphans' | 'finish' | 'quality' | 'diff' | 'reuse'
+/** `conventions check` (round 13): one row per loaded convention, plus the convention-file load record. */
+ | 'convention';
 /**
  * Per-rule outcome, uniform across planes. `skipped` is deliberately a
  * first-class status, not folded into `passed` — a rule that matched nothing
  * enforced nothing.
+ *
+ * `partial` is derived by {@link buildGateEnvelope} and ONLY there: a rule its
+ * producer reported `passed` whose coverage has a shortfall. It found nothing
+ * wrong in what it examined, and it did not examine everything it was asked
+ * to — so it is not a pass, and the envelope's exit is never `0` over it.
  */
-export type GateRuleStatus = 'passed' | 'failed' | 'skipped' | 'error';
+export type GateRuleStatus = 'passed' | 'partial' | 'failed' | 'skipped' | 'error';
 /** One violation, normalized. `id` is the offending token / entry / file. */
 export interface IGateViolation {
     readonly id: string;
@@ -45,20 +54,88 @@ export interface IGateRuleResult {
     readonly skipReason?: string;
     /** Set when the rule is misconfigured (`status: 'error'`). */
     readonly error?: string;
+    /**
+     * What this rule examined against what it was asked to. REQUIRED: a producer
+     * cannot omit it (tsc fails), so no plane can report a clean rule over an
+     * unexamined scope by forgetting a check — the envelope builder compares the
+     * two for every rule, whoever produced it.
+     */
+    readonly coverage: IVerdictCoverage;
+    /**
+     * The rule's `expectEmpty` ACCEPTANCE — settle record B
+     * (`settleUnitLiveness(...).acceptance`, `@shrkcrft/core`): the units the rule
+     * asserts are intended-empty. {@link buildGateEnvelope} folds it into the ONE
+     * `settleVerdict` call beside {@link coverage} (once, when the two are the
+     * same record — `ruleVerdictRecords`), so it reaches `accepted` at exit 0 and
+     * is never dropped. It never changes the rule's status: `partial` is derived
+     * from {@link coverage} alone. Optional and additive (round 13).
+     */
+    readonly unitAcceptance?: IVerdictCoverage;
+    /**
+     * The rule's non-live selector units, each as its `formatUnitLiveness` line
+     * (built by `unitStateLists`, `@shrkcrft/core`). Optional and additive:
+     * present only on a plane that settles units; passed through unchanged.
+     */
+    readonly units?: IUnitStateLists;
+    /** The rule's coverage shortfall. Derived by {@link buildGateEnvelope}; a producer's value is ignored. */
+    readonly shortfall?: string;
 }
 /** The envelope emitted under the `gate` key of every gate verb's `--json`. */
 export interface IGateEnvelope {
     readonly schema: typeof GATE_ENVELOPE_SCHEMA;
     /** The verb that produced this, space-joined (e.g. `check wiring`). */
     readonly verb: string;
-    /** The exit code this run returns — the same number the process exits with. */
+    /**
+     * The exit code this run returns — the same number the process exits with.
+     * Settled: never `0` while {@link shortfalls} is non-empty.
+     */
     readonly exit: number;
-    readonly rules: readonly IGateRuleResult[];
-    /** Rules that ran a real comparison (status !== 'skipped'). */
+    /** `pass` / `fail` / `not-verified` / `usage-error` — {@link exit} in words. */
+    readonly verdict: ISettledVerdict['verdict'];
+    /**
+     * Rules that ran a real comparison (status neither `skipped` nor `error`;
+     * `partial` counts). A rule ACCEPTED as intended-empty (round 13, K6 — its
+     * coverage IS its `expectEmpty` acceptance: every inclusion unit of its
+     * primary list marked, 0 files examined; `ruleAcceptedAsIntendedEmpty`) is
+     * never counted here: it is counted in {@link acceptedEmpty}.
+     */
     readonly evaluated: number;
+    /**
+     * Rules accepted as intended-empty (round 13, K6) — they examined 0 files
+     * by design, so they are counted apart from {@link evaluated} and printed
+     * `N evaluated, M accepted as intended-empty`. OPTIONAL: present only when
+     * non-zero, so the envelope gains no always-present key.
+     */
+    readonly acceptedEmpty?: number;
     readonly skipped: number;
     readonly failed: number;
+    /** Rules that passed over a partially-examined scope. */
+    readonly partial: number;
+    /** Run-level coverage — e.g. rules examined of rules selected. */
+    readonly coverage: IVerdictCoverage;
+    /** Every scope gap that vetoes a clean verdict: the run's, then each rule's (prefixed `<id>: `). */
+    readonly shortfalls: readonly string[];
+    /**
+     * Gaps an explicit acceptance waived (`--allow-empty`, `registeredExtras`, a
+     * rule's `expectEmpty` units via `rules[].unitAcceptance`) — printed, never
+     * silent; non-empty only at exit 0.
+     */
+    readonly accepted: readonly string[];
+    readonly rules: readonly IGateRuleResult[];
 }
-/** Build the envelope from already-normalized per-rule results. */
-export declare function buildGateEnvelope(verb: string, exit: number, rules: readonly IGateRuleResult[]): IGateEnvelope;
+/**
+ * Build the envelope from already-normalized per-rule results — and SETTLE the
+ * exit while doing it.
+ *
+ * The caller proposes an exit from what it found; the builder compares every
+ * rule's coverage (and the run's) to what was requested, marks a `passed` rule
+ * with a shortfall `partial`, and runs the proposal through `settleVerdict`. So
+ * `gate.exit` can never be `0` over an unexamined scope, whichever verb built
+ * it. `runCoverage` is required for the same reason `IGateRuleResult.coverage`
+ * is: an envelope that could omit it would be the hole this closes.
+ *
+ * Settle first, render second: build this unconditionally (text AND JSON),
+ * return `env.exit`, and print the final line through `verdictLine(env, …)`.
+ */
+export declare function buildGateEnvelope(verb: string, proposedExit: number, rules: readonly IGateRuleResult[], runCoverage: IVerdictCoverage): IGateEnvelope;
 //# sourceMappingURL=gate-envelope.d.ts.map

package/dist/gates/gate-envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-envelope.d.ts","sourceRoot":"","sources":["../../src/gates/gate-envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,EAAG,oBAA6B,CAAC;AAElE,uDAAuD;AACvD,MAAM,MAAM,YAAY,GACpB,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,cAAc,GACd,UAAU,GACV,WAAW,GACX,eAAe,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvE,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C,gEAAgE;IAChE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,oBAAoB,CAAC;IAC7C,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;IAC3C,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,mEAAmE;AACnE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,eAAe,EAAE,GAChC,aAAa,CAUf"}
+{"version":3,"file":"gate-envelope.d.ts","sourceRoot":"","sources":["../../src/gates/gate-envelope.ts"],"names":[],"mappings":"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"}

package/dist/gates/gate-envelope.js

@@ -11,16 +11,65 @@
  * rides along under a `gate` key, so `jq .gate` is the uniform read and nothing
  * that worked before stops working.
  */
+import { coverageShortfall, ruleAcceptedAsIntendedEmpty, ruleVerdictRecords, settleRuleStatus, } from '@shrkcrft/core';
+import { settleVerdict } from "./settle-verdict.js";
 export const GATE_ENVELOPE_SCHEMA = 'sharkcraft.gate/v1';
-/** Build the envelope from already-normalized per-rule results. */
-export function buildGateEnvelope(verb, exit, rules) {
+/**
+ * Build the envelope from already-normalized per-rule results — and SETTLE the
+ * exit while doing it.
+ *
+ * The caller proposes an exit from what it found; the builder compares every
+ * rule's coverage (and the run's) to what was requested, marks a `passed` rule
+ * with a shortfall `partial`, and runs the proposal through `settleVerdict`. So
+ * `gate.exit` can never be `0` over an unexamined scope, whichever verb built
+ * it. `runCoverage` is required for the same reason `IGateRuleResult.coverage`
+ * is: an envelope that could omit it would be the hole this closes.
+ *
+ * Settle first, render second: build this unconditionally (text AND JSON),
+ * return `env.exit`, and print the final line through `verdictLine(env, …)`.
+ */
+export function buildGateEnvelope(verb, proposedExit, rules, runCoverage) {
+    const settledRules = rules.map((r) => {
+        const shortfall = coverageShortfall(r.coverage);
+        const { shortfall: _producerShortfall, ...rest } = r;
+        return {
+            ...rest,
+            // The ONE `partial` derivation (core) — the wiring explain engine calls
+            // the same function, so `gates explain` cannot disagree with this.
+            status: settleRuleStatus(r.status, r.coverage),
+            ...(shortfall !== undefined ? { shortfall } : {}),
+        };
+    });
+    // Each rule contributes its primary coverage AND its expectEmpty acceptance
+    // (settle record B), folded once by the ONE rule shared with the boundary
+    // orchestrator (`ruleVerdictRecords`): an acceptance reaches `accepted` — at
+    // exit 0 only, as settleVerdict decides — and is never dropped. `partial`
+    // above reads the primary record alone.
+    const settled = settleVerdict(proposedExit, [
+        runCoverage,
+        ...rules.flatMap((r) => ruleVerdictRecords(r.coverage, r.unitAcceptance).map((c) => ({ ...c, subject: c.subject ?? r.id }))),
+    ]);
+    // THE K6 partition (round 13): of the rules that ran (neither skipped nor
+    // errored), one whose coverage IS its `expectEmpty` acceptance examined 0
+    // files by design — ACCEPTED, never evaluated. One predicate (core's
+    // `ruleAcceptedAsIntendedEmpty`) over the record the engines' own settle put
+    // on the rule, so no verb re-derives it.
+    const ran = settledRules.filter((r) => r.status !== 'skipped' && r.status !== 'error');
+    const acceptedEmpty = ran.filter((r) => ruleAcceptedAsIntendedEmpty(r)).length;
     return {
         schema: GATE_ENVELOPE_SCHEMA,
         verb,
-        exit,
-        rules,
-        evaluated: rules.filter((r) => r.status !== 'skipped').length,
-        skipped: rules.filter((r) => r.status === 'skipped').length,
-        failed: rules.filter((r) => r.status === 'failed' || r.status === 'error').length,
+        exit: settled.exit,
+        verdict: settled.verdict,
+        evaluated: ran.length - acceptedEmpty,
+        // Optional: present only when non-zero — never an always-present key.
+        ...(acceptedEmpty > 0 ? { acceptedEmpty } : {}),
+        skipped: settledRules.filter((r) => r.status === 'skipped').length,
+        failed: settledRules.filter((r) => r.status === 'failed' || r.status === 'error').length,
+        partial: settledRules.filter((r) => r.status === 'partial').length,
+        coverage: runCoverage,
+        shortfalls: settled.shortfalls,
+        accepted: settled.accepted,
+        rules: settledRules,
     };
 }

package/dist/gates/gate-rule-globs.d.ts

@@ -1,7 +1,11 @@
-import { type IWiringSource } from '@shrkcrft/core';
+import { type IRegistrationIdiom, type IRegistryDeclaration, type IWiringSource } from '@shrkcrft/core';
 import type { IGateRuleView } from './gate-rule-view.js';
 /**
- * The FOOTPRINT of a gate rule: every project-relative glob it reads.
+ * The FOOTPRINT of a gate rule, as the glob LISTS it reads — one per source's
+ * `files`, per `import-edges` `to.files`, per watched input, per generated
+ * writer. Kept as separate lists because a `!` entry subtracts from ITS OWN
+ * list only: flattened, one source's `!x` would hide a file another source
+ * reads (and a changeset touching x would skip a rule it does touch).
  *
  * `--changed-only` is only trustworthy if the footprint is complete. A rule
  * scoped by its declared side alone would go unevaluated when the change edits
@@ -9,6 +13,12 @@ import type { IGateRuleView } from './gate-rule-view.js';
  * rule declared over file A is the precise bug this plane exists to catch, so
  * every side, every hop, and every watched input counts.
  */
+export declare function gateRuleGlobLists(view: IGateRuleView): readonly (readonly string[])[];
+/**
+ * Every glob a gate rule reads, flattened — for DISPLAY only. A scope question
+ * ("does this change touch the rule?") goes through {@link gateRuleGlobLists}
+ * per list ({@link ruleTouchedBy}), never through this union.
+ */
 export declare function gateRuleGlobs(view: IGateRuleView): readonly string[];
 /**
  * EVERY extraction source a rule reads — both wiring sides, every union sink,
@@ -21,8 +31,32 @@ export declare function gateRuleGlobs(view: IGateRuleView): readonly string[];
  * the guarantee the shared extractor exists to provide.
  */
 export declare function gateRuleSources(view: IGateRuleView): readonly IWiringSource[];
+/** A registry's sources, named `source` / `consumer` — THE labels its markers and dead units are qualified by. */
+export declare function registryLabeledSources(decl: IRegistryDeclaration): readonly {
+    readonly label: string;
+    readonly source: IWiringSource;
+}[];
+/** A registration idiom's roles, named `declared` / `provided` / `consumed` — the labels `measureRegistrationRoles` settles them under. */
+export declare function registrationLabeledSources(idiom: IRegistrationIdiom): readonly {
+    readonly label: string;
+    readonly source: IWiringSource;
+}[];
+/**
+ * {@link gateRuleSources}, each named by the side it plays (`declared`,
+ * `registered[1]`, `chain[0]`, `consumer`, …) — the ONE enumeration of a
+ * rule's sources, so a report naming a dead glob by its side cannot list a
+ * different set of sides than the extractor-consumer report does.
+ */
+export declare function gateRuleLabeledSources(view: IGateRuleView): readonly {
+    readonly label: string;
+    readonly source: IWiringSource;
+}[];
 /**
- * Whether a rule's footprint intersects the changed set.
+ * Whether a rule's footprint intersects the changed set: some changed file is
+ * SELECTED by one of the rule's glob lists (`globListSelects` — an inclusion
+ * glob matches, none of that list's negations does). Exact per list, so a
+ * changeset touching only files the rule excludes does not select it, and one
+ * source's `!` can never hide another source's file.
  *
  * A rule with NO resolvable footprint (a command baseline with no
  * `watchFiles`) cannot be proven out of scope, so it stays IN scope. Guessing

package/dist/gates/gate-rule-globs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-rule-globs.d.ts","sourceRoot":"","sources":["../../src/gates/gate-rule-globs.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,MAAM,EAAE,CAqBpE;AAcD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,aAAa,EAAE,CA+B7E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAItF"}
+{"version":3,"file":"gate-rule-globs.d.ts","sourceRoot":"","sources":["../../src/gates/gate-rule-globs.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAEzB,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CA0BrF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,MAAM,EAAE,CAEpE;AAgBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,aAAa,EAAE,CAE7E;AAED,kHAAkH;AAClH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,GACzB,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,EAAE,CAOvE;AAED,2IAA2I;AAC3I,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,kBAAkB,GACxB,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,EAAE,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,GAClB,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,EAAE,CAmBvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAMtF"}