@jjchill/probity-rules 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0
+
+First packaged release. Previously, consumers `cp`'d `probity.config.ts` +
+`rules/` + `scripts/` into their project; rule fixes in this fork never
+reached them. Rules and scripts are now a versioned npm package
+(`@jjchill/probity-rules`); the config stays project-owned and imports
+preset factories from the package.
+
+Migrating from the copied-templates layout:
+
+- `./rules/<x>.js` imports → `@jjchill/probity-rules/rules/<x>`
+- `npx tsx scripts/scope-report.ts` → `npx probity-scope-report`
+- `node scripts/spec-parity.mjs` → `npx probity-spec-parity`
+
+Or run `/probity-update`, which detects the legacy layout and offers to
+migrate it for you.

package/GLOSSARY.template.md

@@ -0,0 +1,33 @@
+# Glossary
+
+<!--
+Ubiquitous-language glossary (see the ubiquitous-language skill).
+Copy to docs/GLOSSARY.md and point the probity config's glossaryPath
+at it.
+
+Format convention — the probity rules parse this file:
+- one term per level-2 heading: `## Term`
+- one term per concept, one concept per term; no aliases — if two
+  words compete for a concept, hold the glossary conversation and
+  record the winner
+- definition text below the heading is free-form; record decisions
+  ("was called X until 2026-07; renamed because...") in the entry
+- multi-word terms are matched in code as PascalCase / camelCase /
+  snake_case, so `## Delivery Window` covers DeliveryWindow,
+  deliveryWindow, delivery_window
+
+Enforcement, when wired in probity.config:
+- renaming/removing a term still used by specs, tests, or code blocks
+  the glossary edit with the list of users (surfaceGlossaryTermBreakage)
+- spec content naming a recorded concept with a conflicting term is
+  blocked (enforceAcceptanceLanguage with glossaryPath)
+- port/domain names conflicting with recorded terms are blocked
+  (enforcePortsBoundary with glossaryPath)
+- optional strict mode: spec concepts with no entry at all are blocked
+  (enforceAcceptanceLanguage with requireGlossaryEntry: true)
+-->
+
+## Example Term
+
+Replace with your first real term. State what the concept is in the
+problem domain's own words, not how the system implements it.

package/README.md

@@ -0,0 +1,96 @@
+# @jjchill/probity-rules
+
+Versioned [Probity](https://github.com/nizos/probity) rule presets and CLI
+tooling for the [agent-skills](https://github.com/addyosmani/agent-skills)
+catalog. Turns three of the catalog's prose disciplines —
+test-driven-development, ports-and-adapters, acceptance-testing — into hard
+PreToolUse gates, plus spec-test parity and ubiquitous-language checks. See
+[`hooks/PROBITY.md`](../PROBITY.md) for full rule semantics.
+
+Rules and scripts live in this package now instead of being copied into a
+project; a project's `probity.config.ts` imports from it, so `npm update`
+brings rule fixes in instead of a fork rotting.
+
+## Install
+
+Not yet published to npm. Install from a clone until then:
+
+```sh
+npm install -D @nizos/probity /path/to/agent-skills/hooks/probity
+```
+
+(run `npm run build` in `hooks/probity` first — the package resolves its
+own compiled `dist/`, not the TypeScript sources.)
+
+Target, once published:
+
+```sh
+npm install -D @nizos/probity @jjchill/probity-rules
+```
+
+## Presets
+
+Each preset is a factory returning `RuleEntry[]` from `@nizos/probity`. Copy
+the matching thin config template from the package root (`probity.config.ts`,
+`probity.config.kotlin.ts`, `probity.config.kmp.ts`,
+`probity.config.swift.ts`) into your project root, then edit its options.
+
+| Preset | Import | Config template |
+| --- | --- | --- |
+| Plain JS/TS | `@jjchill/probity-rules/presets/js` — `jsRuleEntries(options?)` | `probity.config.ts` |
+| Kotlin/JVM/Android | `@jjchill/probity-rules/presets/kotlin` — `kotlinRuleEntries(root, options?)` | `probity.config.kotlin.ts` |
+| Kotlin Multiplatform | `@jjchill/probity-rules/presets/kmp` — `kmpRuleEntries(root, parity?)` | `probity.config.kmp.ts` |
+| Swift/iOS | `@jjchill/probity-rules/presets/swift` — `swiftRuleEntries(root)` | `probity.config.swift.ts` |
+
+Minimal example (plain JS/TS):
+
+```ts
+// probity.config.ts
+import { defineConfig } from '@nizos/probity'
+import { jsRuleEntries } from '@jjchill/probity-rules/presets/js'
+
+export default defineConfig({
+  rules: jsRuleEntries({
+    coreGlobs: ['src/core/**', 'src/domain/**'],
+  }),
+})
+```
+
+Kotlin Multiplatform:
+
+```ts
+// probity.config.kmp.ts
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { defineConfig } from '@nizos/probity'
+import { kmpRuleEntries } from '@jjchill/probity-rules/presets/kmp'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+export default defineConfig({ rules: kmpRuleEntries(ROOT) })
+```
+
+Every preset's options and their current defaults are documented at the top
+of its module in `presets/`.
+
+## Bins
+
+- `npx probity-scope-report [--config probity.config.ts] [--root .] [--strict]`
+  — dry-runs your config's `{ files, rules }` blocks against your real repo
+  and reports dead scopes (globs matching zero files) and suspicious claims
+  (core-purity rules touching adapter code, the language rule touching
+  driver code).
+- `npx probity-spec-parity` — the CI mirror of the spec↔test traceability
+  rule: checks that every non-`wip` scenario under `docs/specs` is claimed
+  by an acceptance test.
+
+## Updating
+
+Run `/probity-update` (a plugin slash command) from your project to update
+the package, migrate your config to new options, refresh the Kiro shim
+files, and re-verify scoping — see the command for the full procedure.
+
+## Kiro
+
+`kiro/` ships the Kiro hook shim (unchanged install model: copy into your
+project's `.kiro/hooks/`). `/probity-update` re-copies changed files from
+here.

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@jjchill/probity-rules` barrel — language-NEUTRAL rule modules
+ * only.
+ *
+ * kotlin.ts and swift.ts are deliberately NOT re-exported here: both
+ * export `requireGreenTestRun` and `forbidNewAmbientEffects` with
+ * different signatures than the language-neutral versions in
+ * gates.ts, so a combined `export *` would collide. Reach the
+ * language-specific rules directly via `@jjchill/probity-rules/rules/kotlin`
+ * or `@jjchill/probity-rules/rules/swift`, or use a preset
+ * (`@jjchill/probity-rules/presets/*`) which already wires the right
+ * ones together.
+ */
+export * from './rules/gates.js';
+export * from './rules/ports-and-adapters.js';
+export * from './rules/acceptance-language.js';
+export * from './rules/spec-test-parity.js';
+export * from './rules/ubiquitous-language.js';
+export * from './rules/scoping.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,kBAAkB,CAAA;AAChC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * `@jjchill/probity-rules` barrel — language-NEUTRAL rule modules
+ * only.
+ *
+ * kotlin.ts and swift.ts are deliberately NOT re-exported here: both
+ * export `requireGreenTestRun` and `forbidNewAmbientEffects` with
+ * different signatures than the language-neutral versions in
+ * gates.ts, so a combined `export *` would collide. Reach the
+ * language-specific rules directly via `@jjchill/probity-rules/rules/kotlin`
+ * or `@jjchill/probity-rules/rules/swift`, or use a preset
+ * (`@jjchill/probity-rules/presets/*`) which already wires the right
+ * ones together.
+ */
+export * from './rules/gates.js';
+export * from './rules/ports-and-adapters.js';
+export * from './rules/acceptance-language.js';
+export * from './rules/spec-test-parity.js';
+export * from './rules/ubiquitous-language.js';
+export * from './rules/scoping.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,kBAAkB,CAAA;AAChC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oBAAoB,CAAA"}

package/dist/presets/js.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Probity rule-entry factory — plain JS/TS preset.
+ *
+ * Turns three of the agent-skills catalog's prose disciplines into
+ * hard PreToolUse gates via https://github.com/nizos/probity :
+ *
+ *   test-driven-development  → enforceTdd (built-in)
+ *   ports-and-adapters       → enforcePortsBoundary + forbidInternalModuleMocks
+ *                              + a deterministic import screen
+ *   acceptance-testing       → enforceAcceptanceLanguage
+ *
+ * `jsRuleEntries(options?)` reproduces exactly what the shipped
+ * `probity.config.ts` template wires by default — every option below
+ * defaults to that template's current value. A consuming project
+ * copies the thin template (which calls this factory) and overrides
+ * only the options its layout needs.
+ */
+import { type RuleEntry } from '@nizos/probity';
+import type { Globs } from '../rules/scoping.js';
+/**
+ * Deterministic first line of defense for the Dependency Rule: known
+ * framework/vendor/OS-I/O imports never belong in core code, so block
+ * them without spending an AI call. Extend with your stack's usual
+ * suspects; enforcePortsBoundary catches what this list misses.
+ */
+export declare const KNOWN_INFRASTRUCTURE_IMPORTS: RegExp;
+export type JsPresetOptions = {
+    /** Core/domain globs — adapters and composition roots import
+     *  vendors by design and must NOT match here. */
+    coreGlobs?: Globs;
+    /** The deterministic infrastructure-import screen for core code. */
+    infrastructureImports?: RegExp;
+    /** Point at your canonical ports once they exist, e.g. "inject the
+     *  Clock port from src/ports/clock.ts". */
+    seamHint?: string;
+    /** Files where internal-module mocking is forbidden (the only test
+     *  seam is a port). */
+    mockGlobs?: Globs;
+    /** Files the TDD gate (the expensive, AI-validated rule) applies
+     *  to — scope this to the code you actually TDD. */
+    tddGlobs?: Globs;
+    /** The spec/acceptance layer the Language Test applies to. Do NOT
+     *  widen this to DSL or protocol-driver files. */
+    specGlobs?: Globs;
+    /** Absolute path to a glossary (ubiquitous-language skill) to hold
+     *  specs to. */
+    glossaryPath?: string;
+    /** The real test command your commit gate should look for. */
+    commitCommand?: RegExp;
+    /** Your runner's green summary line. */
+    commitSuccessPattern?: RegExp;
+    /** Your runner's failure summary line. */
+    commitFailurePattern?: RegExp;
+};
+/**
+ * Rule entries for a plain JS/TS project. Probity stops at the first
+ * violation, so deterministic screens (pattern match, free, instant)
+ * are ordered before AI-validated rules (a model call per matching
+ * write): a vendor import in core code is rejected free by the
+ * import screen, never after a TDD model call.
+ */
+export declare function jsRuleEntries(options?: JsPresetOptions): RuleEntry[];
+//# sourceMappingURL=js.d.ts.map

package/dist/presets/js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js.d.ts","sourceRoot":"","sources":["../../presets/js.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAoC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAYjF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,QAC2O,CAAA;AAEpR,MAAM,MAAM,eAAe,GAAG;IAC5B;qDACiD;IACjD,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB,oEAAoE;IACpE,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;+CAC2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;2BACuB;IACvB,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB;wDACoD;IACpD,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB;sDACkD;IAClD,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB;oBACgB;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,wCAAwC;IACxC,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,0CAA0C;IAC1C,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,eAAoB,GAAG,SAAS,EAAE,CAkFxE"}

package/dist/presets/js.js

@@ -0,0 +1,112 @@
+/**
+ * Probity rule-entry factory — plain JS/TS preset.
+ *
+ * Turns three of the agent-skills catalog's prose disciplines into
+ * hard PreToolUse gates via https://github.com/nizos/probity :
+ *
+ *   test-driven-development  → enforceTdd (built-in)
+ *   ports-and-adapters       → enforcePortsBoundary + forbidInternalModuleMocks
+ *                              + a deterministic import screen
+ *   acceptance-testing       → enforceAcceptanceLanguage
+ *
+ * `jsRuleEntries(options?)` reproduces exactly what the shipped
+ * `probity.config.ts` template wires by default — every option below
+ * defaults to that template's current value. A consuming project
+ * copies the thin template (which calls this factory) and overrides
+ * only the options its layout needs.
+ */
+import { enforceTdd, forbidContentPattern } from '@nizos/probity';
+import { enforceAcceptanceLanguage } from '../rules/acceptance-language.js';
+import { forbidNewAmbientEffects, JS_AMBIENT_EFFECT_PATTERNS, requireGreenTestRun, } from '../rules/gates.js';
+import { enforcePortsBoundary, forbidInternalModuleMocks, } from '../rules/ports-and-adapters.js';
+/**
+ * Deterministic first line of defense for the Dependency Rule: known
+ * framework/vendor/OS-I/O imports never belong in core code, so block
+ * them without spending an AI call. Extend with your stack's usual
+ * suspects; enforcePortsBoundary catches what this list misses.
+ */
+export const KNOWN_INFRASTRUCTURE_IMPORTS = /from\s+['"](?:node:(?:fs|http|https|net|child_process|process)|fs|http|https|express|fastify|@nestjs\/[^'"]+|next\/[^'"]+|pg|mysql2?|mongodb|mongoose|redis|ioredis|@prisma\/client|typeorm|knex|axios|node-fetch|got|undici|stripe|@aws-sdk\/[^'"]+|aws-sdk|firebase-admin)['"]/;
+/**
+ * Rule entries for a plain JS/TS project. Probity stops at the first
+ * violation, so deterministic screens (pattern match, free, instant)
+ * are ordered before AI-validated rules (a model call per matching
+ * write): a vendor import in core code is rejected free by the
+ * import screen, never after a TDD model call.
+ */
+export function jsRuleEntries(options = {}) {
+    const coreGlobs = options.coreGlobs ?? ['src/core/**', 'src/domain/**'];
+    const mockGlobs = options.mockGlobs ?? ['**/*.test.*', '**/*.spec.*', 'test/**', 'tests/**'];
+    const tddGlobs = options.tddGlobs ?? ['src/**', 'test/**', 'tests/**'];
+    const specGlobs = options.specGlobs ?? ['specs/**', 'acceptance/**', '**/*.feature'];
+    return [
+        // ── Boundaries: ports-and-adapters ──────────────────────────────
+        // Core purity. Point these globs at your core/domain/use-case
+        // code only — adapters and composition roots import vendors by
+        // design and must NOT match here.
+        {
+            files: coreGlobs,
+            rules: [
+                forbidContentPattern({
+                    match: options.infrastructureImports ?? KNOWN_INFRASTRUCTURE_IMPORTS,
+                    reason: 'Core code imports an infrastructure module. The Dependency ' +
+                        'Rule: core imports nothing from adapters, frameworks, ' +
+                        'vendors, or OS I/O — define a port in the core and reach ' +
+                        'the dependency through an adapter (see the ' +
+                        'ports-and-adapters skill).',
+                }),
+                // Clock, randomness, and environment are ports too. Delta-based:
+                // existing call sites don't block; net-new ones do. Point
+                // seamHint at your canonical ports once they exist.
+                forbidNewAmbientEffects({
+                    patterns: JS_AMBIENT_EFFECT_PATTERNS,
+                    seamHint: options.seamHint,
+                }),
+                enforcePortsBoundary(),
+            ],
+        },
+        // Ports are the only test seam: no jest.mock()/vi.mock() of our
+        // own modules anywhere in the suite. Deterministic — free to run
+        // broadly.
+        {
+            files: mockGlobs,
+            rules: [forbidInternalModuleMocks()],
+        },
+        // ── Inner loop: test-driven-development ─────────────────────────
+        // Red → Green → Refactor on all production and test code. This is
+        // the expensive rule (AI call per matching write) — scope it to
+        // the code you actually TDD. Listed AFTER the deterministic
+        // screens above: Probity stops at the first violation, so a
+        // vendor import in core code is rejected free by the import
+        // screen, never after a model call.
+        {
+            files: tddGlobs,
+            rules: [enforceTdd()],
+        },
+        // ── Outer loop: acceptance-testing ──────────────────────────────
+        // The Language Test on the spec layer only. Do NOT widen this to
+        // DSL or protocol-driver files — those layers are supposed to
+        // contain the mechanics this rule blocks. To hold specs to your
+        // glossary (ubiquitous-language skill), pass glossaryPath as an
+        // absolute path, e.g.:
+        //   enforceAcceptanceLanguage({
+        //     glossaryPath: fileURLToPath(new URL('./docs/GLOSSARY.md', import.meta.url)),
+        //   })
+        {
+            files: specGlobs,
+            rules: [enforceAcceptanceLanguage({ glossaryPath: options.glossaryPath })],
+        },
+        // ── Ship gate ────────────────────────────────────────────────────
+        // No commit on an unverified tree — and the recorded run must be
+        // GREEN. Probity's built-in requireCommand only checks that a test
+        // command ran after the last write; a run whose output was all
+        // failures would still unlock the commit. Match your real test
+        // command and your runner's summary lines (defaults below cover
+        // vitest and jest).
+        requireGreenTestRun({
+            command: options.commitCommand ?? /npm (run )?test|vitest|jest/,
+            successPattern: options.commitSuccessPattern ?? /Test Files\s+\d+ passed|Tests:\s+.*\b\d+ passed/,
+            failurePattern: options.commitFailurePattern ?? /\d+ failed|FAIL\s/,
+        }),
+    ];
+}
+//# sourceMappingURL=js.js.map

package/dist/presets/js.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js.js","sourceRoot":"","sources":["../../presets/js.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAkB,MAAM,gBAAgB,CAAA;AAEjF,OAAO,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAA;AAC3E,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,gCAAgC,CAAA;AAGvC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GACvC,kRAAkR,CAAA;AA+BpR;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,UAA2B,EAAE;IACzD,MAAM,SAAS,GAAU,OAAO,CAAC,SAAS,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAA;IAC9E,MAAM,SAAS,GAAU,OAAO,CAAC,SAAS,IAAI,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;IACnG,MAAM,QAAQ,GAAU,OAAO,CAAC,QAAQ,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;IAC7E,MAAM,SAAS,GAAU,OAAO,CAAC,SAAS,IAAI,CAAC,UAAU,EAAE,eAAe,EAAE,cAAc,CAAC,CAAA;IAE3F,OAAO;QACL,mEAAmE;QACnE,8DAA8D;QAC9D,+DAA+D;QAC/D,kCAAkC;QAClC;YACE,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE;gBACL,oBAAoB,CAAC;oBACnB,KAAK,EAAE,OAAO,CAAC,qBAAqB,IAAI,4BAA4B;oBACpE,MAAM,EACJ,6DAA6D;wBAC7D,wDAAwD;wBACxD,2DAA2D;wBAC3D,6CAA6C;wBAC7C,4BAA4B;iBAC/B,CAAC;gBACF,iEAAiE;gBACjE,0DAA0D;gBAC1D,oDAAoD;gBACpD,uBAAuB,CAAC;oBACtB,QAAQ,EAAE,0BAA0B;oBACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ;iBAC3B,CAAC;gBACF,oBAAoB,EAAE;aACvB;SACF;QAED,gEAAgE;QAChE,iEAAiE;QACjE,WAAW;QACX;YACE,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,CAAC,yBAAyB,EAAE,CAAC;SACrC;QAED,mEAAmE;QACnE,kEAAkE;QAClE,gEAAgE;QAChE,4DAA4D;QAC5D,4DAA4D;QAC5D,4DAA4D;QAC5D,oCAAoC;QACpC;YACE,KAAK,EAAE,QAAQ;YACf,KAAK,EAAE,CAAC,UAAU,EAAE,CAAC;SACtB;QAED,mEAAmE;QACnE,iEAAiE;QACjE,8DAA8D;QAC9D,gEAAgE;QAChE,gEAAgE;QAChE,uBAAuB;QACvB,gCAAgC;QAChC,mFAAmF;QACnF,OAAO;QACP;YACE,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,CAAC,yBAAyB,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;SAC3E;QAED,oEAAoE;QACpE,iEAAiE;QACjE,mEAAmE;QACnE,+DAA+D;QAC/D,+DAA+D;QAC/D,gEAAgE;QAChE,oBAAoB;QACpB,mBAAmB,CAAC;YAClB,OAAO,EAAE,OAAO,CAAC,aAAa,IAAI,6BAA6B;YAC/D,cAAc,EACZ,OAAO,CAAC,oBAAoB,IAAI,iDAAiD;YACnF,cAAc,EAAE,OAAO,CAAC,oBAAoB,IAAI,mBAAmB;SACpE,CAAC;KACH,CAAA;AACH,CAAC"}

package/dist/presets/kmp.d.ts

@@ -0,0 +1,27 @@
+import { type RuleEntry } from '@nizos/probity';
+import { type DriverScope } from '../rules/spec-test-parity.js';
+/**
+ * The rule entries, as a factory over the project root. Probity only
+ * reads the default export below; the factory exists so tooling can
+ * instantiate the exact same blocks against a different root — the
+ * workflow eval runs them in a temp directory, and
+ * `scripts/scope-report.ts` resolves their `files` scopes against the
+ * real tree. Keeping the entries in one place is what lets the eval's
+ * scoping stay derived from this config instead of hand-mirrored.
+ *
+ * Relative globs (`docs/...`) are NOT anchored here: Probity's
+ * `loadConfig` anchors them against this file's directory at load
+ * time, and the tooling replicates that via `rules/scoping.ts`.
+ *
+ * `parity` optionally switches on the per-scenario driver mapping
+ * (`driverScopes`/`defaultScopes` on the commit-time parity gate) —
+ * projects normally enable it by uncommenting the block in the
+ * `enforceSpecTestParity` call below; the parameter exists so the
+ * workflow eval can exercise the scope checks without changing the
+ * template's default-off posture.
+ */
+export declare function kmpRuleEntries(root: string, parity?: {
+    driverScopes?: DriverScope[];
+    defaultScopes?: string[];
+}): RuleEntry[];
+//# sourceMappingURL=kmp.d.ts.map

package/dist/presets/kmp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmp.d.ts","sourceRoot":"","sources":["../../presets/kmp.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAoC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAQjF,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAA;AAmBrC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAClE,SAAS,EAAE,CAwOb"}