@jjchill/probity-rules 0.1.0

package/dist/rules/gates.js

@@ -0,0 +1,285 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+function countMatches(content, pattern) {
+    let count = 0;
+    for (const _ of content.matchAll(pattern))
+        count++;
+    return count;
+}
+/** Patterns whose occurrence count grows from before → after. */
+export async function introducedPatterns(action, ctx, patterns) {
+    const hits = patterns.filter(({ pattern }) => countMatches(action.content, pattern) > 0);
+    if (hits.length === 0)
+        return [];
+    const before = await ctx?.readFile?.(action.path);
+    const beforeContent = before?.kind === 'present' ? before.content : '';
+    return hits
+        .filter(({ pattern }) => countMatches(action.content, pattern) >
+        countMatches(beforeContent, pattern))
+        .map(({ label }) => label);
+}
+/**
+ * Ambient-effect calls for a JS/TS core: OS clock, randomness, and
+ * environment reads. Pass to {@link forbidNewAmbientEffects} from a
+ * JS/TS config. `process.env` reads belong in the composition root or
+ * a config adapter; if your core legitimately branches on injected
+ * config, that config should arrive through a port, not the OS.
+ */
+export const JS_AMBIENT_EFFECT_PATTERNS = [
+    { label: 'Date.now()', pattern: /\bDate\.now\s*\(/g },
+    { label: 'new Date() (argless)', pattern: /\bnew\s+Date\s*\(\s*\)/g },
+    { label: 'Math.random()', pattern: /\bMath\.random\s*\(/g },
+    { label: 'crypto.randomUUID()', pattern: /\bcrypto\.randomUUID\s*\(/g },
+    { label: 'randomUUID()', pattern: /\brandomUUID\s*\(/g },
+    { label: 'process.env', pattern: /\bprocess\.env\b/g },
+];
+/**
+ * Blocks production writes that introduce direct ambient-effect calls.
+ * Under ports-and-adapters these are unowned OS dependencies: clock,
+ * randomness, and environment are ports.
+ *
+ * Delta-based: pre-existing call sites in a brownfield codebase don't
+ * block edits to their files; only net-new occurrences do. Scope to
+ * production sources — tests and adapter implementations (e.g. a
+ * `SystemClock`) legitimately touch the real OS, so exclude adapter
+ * paths via globs or negations.
+ *
+ * @param options.patterns — what an ambient-effect call looks like in
+ *   your language ({@link JS_AMBIENT_EFFECT_PATTERNS} for JS/TS; the
+ *   Kotlin preset supplies JVM patterns). Each RegExp needs `g`.
+ * @param options.seamHint — appended to the block message to point
+ *   the agent at the project's canonical seam(s), e.g.
+ *   "inject the Clock port from src/ports/clock.ts".
+ */
+export function forbidNewAmbientEffects(options) {
+    return async function forbidNewAmbientEffects(action, ctx) {
+        if (action.kind !== 'write')
+            return { kind: 'pass' };
+        const introduced = await introducedPatterns(action, ctx, options.patterns);
+        if (introduced.length === 0)
+            return { kind: 'pass' };
+        const hint = options.seamHint ? ` ${options.seamHint}.` : '';
+        return {
+            kind: 'violation',
+            reason: `This write introduces direct ambient-effect calls (${introduced.join(', ')}). Clock, randomness, and environment are unowned OS ` +
+                'dependencies: reach them through a port injected into this ' +
+                `code, implemented by a thin adapter.${hint} Existing call ` +
+                'sites in the file are untouched by this rule — only new ones ' +
+                'are blocked.',
+        };
+    };
+}
+/**
+ * Files the pending commit will record, repo-relative. Reads the
+ * staged set (`git diff --cached --name-only`); for a `git commit`
+ * with `-a`/`-am`/`--all` it also folds in modified-but-unstaged
+ * tracked files. Throws if git is unavailable — callers fail safe.
+ */
+function defaultListCommitFiles(command) {
+    const run = (args) => execFileSync('git', args, { cwd: process.cwd(), encoding: 'utf8' })
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const files = run(['diff', '--cached', '--name-only']);
+    if (/\s-\w*a\w*\b/.test(command) || /--all\b/.test(command)) {
+        for (const file of run(['diff', '--name-only'])) {
+            if (!files.includes(file))
+                files.push(file);
+        }
+    }
+    return files;
+}
+/**
+ * Commit-on-green, strictly: Probity's `requireCommand` checks only
+ * that a matching test invocation was *recorded* after the last write
+ * and would happily pass a transcript whose latest run FAILED. This
+ * rule additionally judges the recorded run's output: the last
+ * matching test command after the last write must look green
+ * (`successPattern` present, `failurePattern` absent).
+ *
+ * Inherent limit (unchanged from requireCommand): the gate sees only
+ * the session transcript. A green run in another terminal, CI, or a
+ * wrapper script is invisible — rerun the suite in-session, and keep
+ * the CI mirror for human commits.
+ *
+ * Applies to: command actions matching `git commit`. Deterministic —
+ * no AI call.
+ *
+ * @param options.command — regex matching a test invocation.
+ * @param options.successPattern — output must match to count as green.
+ * @param options.failurePattern — output matching this is red even if
+ *   the success pattern also appears.
+ * @param options.enforceForPaths — only demand the run when the
+ *   pending commit stages a file whose repo-relative path matches.
+ *   Scopes an expensive suite to the code it covers: infra/docs/
+ *   tooling-only commits (CI config, Markdown, the Probity config
+ *   itself) pay no friction, since they change no behaviour the suite
+ *   validates and the prior green run still stands. Commit-accurate —
+ *   read from git's staged set, not the session's write history. Any
+ *   error listing files falls through to enforcing (fail safe).
+ * @param options.listCommitFiles — injectable staged-file lister
+ *   (defaults to reading git's staged set); present for testing.
+ * @param options.reason — appended to the no-run deny text to name
+ *   the suite and any setup it needs (e.g. "supabase start").
+ */
+export function requireGreenTestRun(options) {
+    const listCommitFiles = options.listCommitFiles ?? defaultListCommitFiles;
+    return async function requireGreenTestRun(action, ctx) {
+        if (action.kind !== 'command')
+            return { kind: 'pass' };
+        if (!/git commit/.test(action.command))
+            return { kind: 'pass' };
+        // Scope the gate to commits that stage code the suite validates.
+        // On any error listing files, fall through and enforce (fail safe).
+        if (options.enforceForPaths) {
+            const pattern = options.enforceForPaths;
+            let files;
+            try {
+                files = listCommitFiles(action.command);
+            }
+            catch {
+                files = undefined;
+            }
+            if (files && !files.some((file) => pattern.test(file))) {
+                return { kind: 'pass' };
+            }
+        }
+        const history = (await ctx?.history?.()) ?? [];
+        const lastWrite = history.reduce((last, event, index) => (event.kind === 'write' ? index : last), -1);
+        const runs = history.filter((event, index) => index > lastWrite &&
+            event.kind === 'command' &&
+            options.command.test(event.command));
+        if (runs.length === 0) {
+            const extra = options.reason ? ` ${options.reason}` : '';
+            return {
+                kind: 'violation',
+                reason: 'Run the test suite after the last change before committing ' +
+                    `(see test-driven-development: commit only on green).${extra}`,
+            };
+        }
+        const lastRun = runs[runs.length - 1];
+        const output = 'output' in lastRun ? (lastRun.output ?? '') : '';
+        if (options.failurePattern.test(output) || !options.successPattern.test(output)) {
+            return {
+                kind: 'violation',
+                reason: 'The last recorded test run after your changes was not ' +
+                    'green — a recorded invocation is not a passing suite. Fix ' +
+                    'the failures (or the build) and rerun before committing.',
+            };
+        }
+        return { kind: 'pass' };
+    };
+}
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    'target',
+    '.next',
+]);
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name))
+                walk(join(dir, entry.name), out);
+        }
+        else {
+            out.push(join(dir, entry.name));
+        }
+    }
+    return out;
+}
+const DEFAULT_STRING_LITERAL = /(['"])((?:(?!\1)[^\\\n]|\\.){4,})\1|`((?:(?!`)(?!\$\{)[^\\]|\\.){4,})`/g;
+function extractStringLiterals(content, minLength) {
+    const out = new Set();
+    for (const match of content.matchAll(DEFAULT_STRING_LITERAL)) {
+        const value = match[2] ?? match[3] ?? '';
+        if (value.trim().length >= minLength)
+            out.add(value);
+    }
+    return out;
+}
+/**
+ * Surfaces the "renamed a button, broke the E2E suite" failure at
+ * write time: when a write REMOVES a string literal that still appears
+ * verbatim in files under `searchRoots` (typically your E2E/UI-test
+ * specs, which select elements by visible text or accessible name),
+ * the write is blocked with the list of dependent files.
+ *
+ * The inverse of a glossary guard: `surfaceGlossaryTermBreakage`
+ * protects the vocabulary file from code that depends on it; this
+ * protects test selectors from the UI code they depend on. Scope it to
+ * your UI sources, with `searchRoots` pointing at the spec layers the
+ * quick local loop does NOT run (E2E, smoke) — specs the inner loop
+ * runs will fail red on their own.
+ *
+ * Deterministic, delta-based — no AI call. The write goes through once
+ * the dependent specs are updated in the same session (or the string
+ * genuinely stops being referenced).
+ *
+ * @param options.searchRoots — absolute paths to scan for usages.
+ * @param options.searchPattern — which files count as usage sites
+ *   (default: `*.spec.*` / `*.test.*` under the roots).
+ * @param options.minLength — ignore removed literals shorter than
+ *   this after trimming (default 8; short strings false-positive).
+ */
+export function surfaceRemovedStringUsage(options) {
+    const pattern = options.searchPattern ?? /\.(spec|test)\.[jt]sx?$/;
+    const minLength = options.minLength ?? 8;
+    return async function surfaceRemovedStringUsage(action, ctx) {
+        if (action.kind !== 'write')
+            return { kind: 'pass' };
+        const before = await ctx?.readFile?.(action.path);
+        if (!before || before.kind !== 'present')
+            return { kind: 'pass' };
+        const beforeStrings = extractStringLiterals(before.content, minLength);
+        if (beforeStrings.size === 0)
+            return { kind: 'pass' };
+        const afterContent = action.content;
+        const removed = [...beforeStrings].filter((s) => !afterContent.includes(s));
+        if (removed.length === 0)
+            return { kind: 'pass' };
+        const files = options.searchRoots
+            .flatMap((root) => walk(root))
+            .filter((file) => pattern.test(file));
+        const broken = [];
+        for (const text of removed) {
+            // Case-insensitive: specs routinely select via /log out/i-style
+            // regexes whose source is lowercased relative to the UI text.
+            const needle = text.toLowerCase();
+            const users = files.filter((file) => {
+                try {
+                    return readFileSync(file, 'utf8').toLowerCase().includes(needle);
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (users.length > 0) {
+                broken.push(`"${text}" → ${users.join(', ')}`);
+            }
+        }
+        if (broken.length === 0)
+            return { kind: 'pass' };
+        return {
+            kind: 'violation',
+            reason: 'This write removes UI text that test specs still select by:\n' +
+                broken.map((line) => `  - ${line}`).join('\n') +
+                '\nThose suites are not in the quick local loop, so this ' +
+                'breaks them silently until CI. Update the listed specs to the ' +
+                'new text (and run their suite) alongside this change.',
+        };
+    };
+}
+//# sourceMappingURL=gates.js.map

package/dist/rules/gates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.js","sourceRoot":"","sources":["../../rules/gates.ts"],"names":[],"mappings":"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"}

package/dist/rules/kotlin.d.ts

@@ -0,0 +1,323 @@
+import type { Rule } from '@nizos/probity';
+import { type NamedPattern } from './gates.js';
+/**
+ * Kotlin/JVM/Android preset for the ports-and-adapters rules. The
+ * JS-ecosystem screens in `ports-and-adapters.ts` (ESM imports,
+ * jest/vi module mocks) never fire on Kotlin; these are their
+ * Kotlin-shaped counterparts.
+ *
+ * Brownfield note: both rules here judge the DELTA — they block only
+ * occurrences the pending write introduces, so files that already
+ * carry violations can be edited freely and migrated incrementally.
+ */
+/**
+ * Known framework/vendor/infrastructure imports that never belong in
+ * core code under the Dependency Rule. Kotlin `import` syntax.
+ * Extend with your stack's packages; `enforcePortsBoundary` catches
+ * what this list misses.
+ */
+export declare const KOTLIN_INFRASTRUCTURE_IMPORTS: RegExp;
+/**
+ * Mocking-library imports, for projects whose convention is
+ * hand-written fakes at ports with no mocking library at all (pair
+ * with `forbidContentPattern`). Distinct from `forbidStaticMocks`,
+ * which permits the library but blocks its monkey-patching APIs.
+ */
+export declare const MOCKING_LIBRARY_IMPORTS: RegExp;
+/**
+ * Matches Gradle test invocations (`./gradlew test`,
+ * `./gradlew :mysudo:testDevDebugUnitTest`, flavored Android unit-test
+ * tasks) for the commit-on-green `requireCommand` gate.
+ */
+export declare const GRADLE_TEST_COMMAND: RegExp;
+/**
+ * Kotlin counterpart of `forbidInternalModuleMocks`: blocks test
+ * writes that introduce static/object/constructor mocking —
+ * `Mockito.mockStatic`, MockK's `mockkStatic`/`mockkObject`/
+ * `mockkConstructor`, PowerMock — the JVM's monkey-patching
+ * equivalents. These always bypass the architecture ("Ports Are the
+ * Only Test Seam"): whatever they intercept should be reached through
+ * a port and replaced with a fake.
+ *
+ * Plain `mock<SomeInterface>()` is NOT blocked: whether the mocked
+ * type is a port (fine) or an internal class (violation) isn't
+ * decidable from the call site — that judgment belongs to
+ * `enforcePortsBoundary` or review.
+ *
+ * Delta-based: pre-existing static mocks in the file don't
+ * re-trigger on later edits. Applies to: write actions. No AI call.
+ *
+ * @example
+ * { files: ['**\/src\/test\/**', '**\/src\/androidTest\/**'], rules: [forbidStaticMocks()] }
+ */
+export declare function forbidStaticMocks(): Rule;
+/**
+ * Blocks production writes that introduce direct ambient-effect calls
+ * — OS clock (`Instant.now()`, `System.currentTimeMillis()`,
+ * `Date()`), randomness (`UUID.randomUUID()`, `Random()`), and
+ * environment (`System.getenv`). Under ports-and-adapters these are
+ * unowned OS dependencies: clock, randomness, and config are ports.
+ *
+ * Delta-based: the ~hundreds of pre-existing call sites in a
+ * brownfield codebase don't block edits to their files; only net-new
+ * occurrences do. Scope to production sources — tests and adapter
+ * implementations (e.g. a `DefaultTimeProvider`) legitimately touch
+ * the real OS, so exclude adapter paths via globs or negations.
+ *
+ * @param options.seamHint — appended to the block message to point
+ *   the agent at the project's canonical seam(s), e.g.
+ *   "inject com.anonyome.sudocommons.core.common.TimeProvider".
+ * @param options.patterns — replaces the default pattern list; each
+ *   RegExp needs the `g` flag.
+ *
+ * @example
+ * { files: ['**\/src\/main\/**', '!**\/adapters\/**'], rules: [forbidNewAmbientEffects()] }
+ */
+export declare function forbidNewAmbientEffects(options?: {
+    seamHint?: string;
+    patterns?: NamedPattern[];
+}): Rule;
+/**
+ * Kotlin equivalent of `enforceTdd({ fastPath: true })`, which Probity
+ * only implements for TS/JS/Python/C#/Ruby/PHP: wraps a rule so that a
+ * `.kt`/`.kts` write adding exactly one new test function passes
+ * deterministically — no AI call for the most common write in a TDD
+ * loop, adding the next red test. Everything else (production writes,
+ * multi-test writes, non-Kotlin files) delegates to the wrapped rule
+ * unchanged.
+ *
+ * Requires the optional packages `@ast-grep/napi` and
+ * `@ast-grep/lang-kotlin` (`npm install -D` both). When they're
+ * missing, or the current file content is unavailable, or parsing
+ * fails, the wrapper transparently falls through to the wrapped rule
+ * — it can only ever skip work, never block.
+ *
+ * Same trade-off as Probity's own fast-path: a deterministic pass on
+ * every single-test addition skips the green→red refactor-readiness
+ * check the AI would otherwise perform.
+ *
+ * @param rule — the rule to wrap, normally `enforceTdd()`.
+ * @param options.patterns — replaces the default ast-grep test-node
+ *   patterns (e.g. to add a Kotest spec pattern).
+ *
+ * @example
+ * { files: ['**\/src\/main\/**', '**\/src\/test\/**'], rules: [withKotlinFastPath(enforceTdd())] }
+ */
+export declare function withKotlinFastPath(rule: Rule, options?: {
+    patterns?: unknown[];
+}): Rule;
+/**
+ * Commit-on-GREEN gate — the stricter sibling of Probity's built-in
+ * `requireCommand`, which only checks that a matching test command was
+ * *recorded* after the last write and would happily pass a transcript
+ * whose latest run FAILED. This rule additionally judges the recorded
+ * run's output: the last matching test command after the last write
+ * must look green (`successPattern` present, `failurePattern` absent).
+ *
+ * Inherent limit (unchanged from requireCommand): the gate sees only
+ * the session transcript. A green run in another terminal, CI, or a
+ * wrapper script is invisible — rerun the suite in-session, and keep
+ * the CI mirror for human commits.
+ *
+ * Applies to: command actions matching `git commit`. Deterministic —
+ * no AI call.
+ *
+ * @param options.command — regex matching a test invocation (e.g.
+ *   {@link GRADLE_TEST_COMMAND}).
+ * @param options.successPattern — output must match to count as green
+ *   (default `/BUILD SUCCESSFUL/`).
+ * @param options.failurePattern — output matching this is red even if
+ *   the success pattern also appears (default `/FAILED|BUILD FAILED/`).
+ */
+export declare function requireGreenTestRun(options: {
+    command: RegExp;
+    successPattern?: RegExp;
+    failurePattern?: RegExp;
+    enforceForPaths?: RegExp;
+    listCommitFiles?: (command: string) => string[];
+    reason?: string;
+}): Rule;
+/**
+ * Deterministic fast-path for the write the observability rules
+ * encourage: adding telemetry to existing code. A `.kt`/`.kts` write
+ * whose entire delta is ADDED lines, every one a complete single-line
+ * telemetry call (`logger.event(...)`, `breadcrumbs.action/outcome`),
+ * passes without consulting the wrapped rule — no AI call, and no
+ * "over-implementation" friction from a TDD gate for instrumentation
+ * the adapter-observability rule demands anyway. Anything else — a
+ * removed/changed line, a multi-line event call, any non-telemetry
+ * addition — falls through unchanged.
+ *
+ * Wrap it around both sides of the tension: the TDD rule (so
+ * telemetry additions aren't judged as unasserted behavior) and
+ * `enforceAdapterObservability` (a telemetry-only addition trivially
+ * satisfies it).
+ */
+export declare function withTelemetryFastPath(rule: Rule, options?: {
+    patterns?: RegExp[];
+    filePattern?: RegExp;
+}): Rule;
+/**
+ * Marker that declares a write a mutation probe: a deliberate,
+ * temporary break of production behavior made to prove a retrofitted
+ * test can fail (see acceptance-testing's mutation-check step). Put
+ * it in a comment on or near the mutated line:
+ *
+ *   // probity: mutation-probe — proving RetrySpec bites; revert before commit
+ */
+export declare const MUTATION_PROBE_MARKER: RegExp;
+/**
+ * Wraps a TDD rule so that a write carrying the
+ * {@link MUTATION_PROBE_MARKER} passes deterministically — no AI call,
+ * no red-before-green demand. Mutation checks (deliberately breaking
+ * production code to prove a retrofitted test fails) are *mandated* by
+ * the acceptance-testing skill, and an unwrapped `enforceTdd`
+ * correctly denies them: a deliberate regression has no failing test
+ * in front of it and never will. Without this wrapper the only way to
+ * run a mutation check is to override the gate — which trains agents
+ * and humans to ignore deny decisions.
+ *
+ * The bypass is not free: pair this with {@link enforceProbeReversion}
+ * so `git commit` is blocked while any probe marker is still on disk.
+ * The pair converts an override into an enforced round-trip: mark →
+ * watch the test fail → revert (the marker disappears with the
+ * mutation) → commit opens again. Removing just the marker while
+ * keeping the mutation is a fresh unmarked production write, judged by
+ * the wrapped TDD rule as usual.
+ *
+ * Only the TDD rule is bypassed. Deterministic screens (vendor
+ * imports, ambient effects) and the boundary validator still apply to
+ * probe writes — a probe has no business introducing those.
+ *
+ * @param rule — the rule to wrap, normally
+ *   `withKotlinFastPath(enforceTdd())`.
+ */
+export declare function withMutationProbe(rule: Rule): Rule;
+/**
+ * Wraps a TDD rule so that a violation on a write to the project's
+ * test-control layer — acceptance composition roots, fixture/fake
+ * registrations — carries the inverse-scenario escape route in its
+ * deny text.
+ *
+ * Why: on brownfield systems the environment often produces the sad
+ * path for free (a simulator with no backend fails every sign-in), so
+ * a sad-path scenario never goes red and an unwrapped TDD gate appears
+ * to "refuse" the control fixture. The observed failure mode is the
+ * agent resolving that tension in the wrong direction — deleting the
+ * control and letting the environment own the Given. The deny message
+ * is what the agent reads at that decision point, so the correct move
+ * (write the inverse scenario; its red drives the fixture) must be
+ * stated there, not only in the skill prose.
+ *
+ * Pass-through everywhere else: verdicts are unchanged, only the
+ * violation reason on matching paths gains a guidance paragraph — and
+ * only the paragraph that applies. The inverse-scenario note is
+ * appended when the denial is about a missing red (or the write
+ * removes existing content — the deletion temptation); a denial citing
+ * an undefined symbol gets the atomic-fixture hint instead (a
+ * multi-part fixture judged piecewise). Other denials pass through
+ * untouched, so the guidance never reads as boilerplate.
+ *
+ * @param rule — the TDD rule to wrap (already wrapped in fast-paths /
+ *   mutation-probe as usual).
+ * @param options.filePattern — paths that hold test-control
+ *   infrastructure (e.g. /App[/\\]Sources[/\\]Acceptance[/\\]/ or a
+ *   fixtures directory).
+ */
+export declare function withInverseScenarioGuidance(rule: Rule, options: {
+    filePattern: RegExp;
+}): Rule;
+/**
+ * The commit half of the mutation-probe round-trip (see
+ * {@link withMutationProbe}): blocks `git commit` while any source
+ * file under `roots` still contains the probe marker, listing the
+ * files. Reverting the mutation (e.g. `git checkout -- <file>`)
+ * removes the marker with it, so a clean tree needs no bookkeeping.
+ * Deterministic filesystem scan — no AI call.
+ *
+ * Applies to: command actions matching `git commit`.
+ *
+ * @param options.roots — absolute paths to scan (the repo root is
+ *   fine; node_modules/build dirs are skipped).
+ * @param options.filePattern — which files can carry probes
+ *   (default: `.kt`/`.kts`/`.java`).
+ */
+export declare function enforceProbeReversion(options: {
+    roots: string[];
+    filePattern?: RegExp;
+}): Rule;
+/**
+ * Marker that declares a test a characterization test: the first test
+ * for behavior that already exists in production, so no natural red
+ * can precede it (the test is born green). Put it in a comment on or
+ * directly above the test function:
+ *
+ *     // probity: characterization
+ *     func testSignedInUserWithoutAnEntitlementIsOfferedPlans() async { … }
+ */
+export declare const CHARACTERIZATION_MARKER: RegExp;
+/**
+ * Wraps a TDD rule to sanction the **characterization round-trip** —
+ * the only honest way to add the FIRST test for behavior that predates
+ * it (common on brownfield systems). A test for existing behavior is
+ * born green, so no red keyed to it can be observed before it exists;
+ * an unwrapped TDD gate correctly denies it, and a mutation probe
+ * can't help yet because a probe only fails tests that already exist.
+ * Without this wrapper the only ways out are an override or leaving
+ * the behavior unspecified.
+ *
+ * The round-trip, each step enforced:
+ *
+ *   1. Write the test carrying {@link CHARACTERIZATION_MARKER} — this
+ *      wrapper passes it deterministically (test-layer paths only).
+ *   2. Run the suite green, then mutation-probe the production path
+ *      (`// probity: mutation-probe`) and observe the new test FAIL —
+ *      the recorded red is the proof the test bites.
+ *   3. Revert the probe. Remove the characterization marker — this
+ *      wrapper allows the removal only when the session transcript
+ *      records a test run in which the marked test failed.
+ *   4. Commit — {@link enforceCharacterizationResolution} blocks while
+ *      any marker is still on disk, so an unproven characterization
+ *      test can't land.
+ *
+ * The bypass is confined: only writes to paths matching
+ * `options.filePattern` (the test layer) skip the wrapped rule, so a
+ * production write can't borrow the marker. Same inherent limit as
+ * every transcript gate: reds observed in another terminal or CI are
+ * invisible — run the probe in-session.
+ *
+ * @param rule — the TDD rule to wrap (fast-paths/probe wrappers
+ *   included as usual).
+ * @param options.filePattern — paths that hold test code (e.g.
+ *   /AcceptanceTests[/\\]/ or /src[/\\]\w+Test[/\\]/). Required: it is
+ *   the boundary that keeps the marker useless in production files.
+ */
+export declare function withCharacterizationTest(rule: Rule, options: {
+    filePattern: RegExp;
+}): Rule;
+/**
+ * The commit half of the characterization round-trip (see
+ * {@link withCharacterizationTest}): blocks `git commit` while any
+ * test file under `roots` still carries the characterization marker —
+ * the marker only comes off through the proof-checked removal path,
+ * so a characterization test that has never been observed failing
+ * cannot land. Deterministic filesystem scan — no AI call.
+ *
+ * Applies to: command actions matching `git commit`.
+ *
+ * @param options.roots — absolute paths to scan.
+ * @param options.filePattern — which files can carry the marker
+ *   (default: `.kt`/`.kts`/`.java`).
+ */
+export declare function enforceCharacterizationResolution(options: {
+    roots: string[];
+    filePattern?: RegExp;
+}): Rule;
+/**
+ * Kotlin/Android addendum for `enforcePortsBoundary` — pass as
+ * `enforcePortsBoundary({ instructions: (d) => d + KOTLIN_BOUNDARY_ADDENDUM })`
+ * and extend the "Project layout" section with your module/package
+ * conventions.
+ */
+export declare const KOTLIN_BOUNDARY_ADDENDUM = "\n\n### Kotlin/Android specifics\n\n  - Ambient OS access in core code is a violation: `Instant.now()`\n    and friends, `System.currentTimeMillis()`, `Date()`,\n    `UUID.randomUUID()`, `Random()`, `System.getenv` \u2014 clock,\n    randomness, and environment are ports.\n  - Vendor/infrastructure packages (AWS SDK, Amplify, Apollo,\n    Firebase, OkHttp, Retrofit, Room, WorkManager, JDBC) belong in\n    adapter modules only. In core code, their types in signatures are\n    leaked boundaries.\n  - Dagger/DI modules, `@Component` definitions, and `\u2026di` packages\n    are composition roots: they import both core and adapters by\n    design \u2014 always allowed.\n  - In tests, `mockStatic`/`mockkStatic`/`mockkObject`/\n    `mockkConstructor`/PowerMock are always violations. A\n    mockito-kotlin `mock<T>()` where T is a port interface is an\n    acceptable seam (though a shared fake is preferred); `mock<T>()`\n    of a concrete internal class is a violation \u2014 the substitute\n    belongs at a port.\n  - Robolectric in a test signals Android-framework coupling; that is\n    an adapter concern, fine in adapter/UI tests, a smell in tests of\n    core logic.\n  - A port need not be an interface. A function-typed constructor\n    parameter injected at the composition root (e.g.\n    `nowEpochMillis: () -> Long`, `randomIv: () -> ByteArray`) is a\n    valid seam \u2014 but a default value that calls the real OS\n    (`= { System.currentTimeMillis() }`) inside core/common code\n    defeats it; real defaults belong in platform adapters or DI\n    wiring.\n  - Kotlin Multiplatform: `commonMain` core code is the inside of\n    the hexagon; `expect`/`actual` pairs and per-platform source\n    sets (`androidMain`, `iosMain`, `desktopMain`) implementing a\n    common declaration are adapters and may touch platform APIs.";
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/rules/kotlin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../rules/kotlin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAU,IAAI,EAA2B,MAAM,gBAAgB,CAAA;AAE3E,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,QACoV,CAAA;AAE9X;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QACoB,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,QAAqD,CAAA;AAsBrF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAsBxC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;CAAO,GAC7D,IAAI,CAON;AAmDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,EACV,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;CAAO,GACrC,IAAI,CAiCN;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,EAAE,CAAA;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,IAAI,CAWP;AAUD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,IAAI,CAmCN;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,QAA8B,CAAA;AA+BhE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAclD;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAC/B,IAAI,CAqCN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,IAAI,CA6BP;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAAkC,CAAA;AA8BtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAC/B,IAAI,CA4DN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE;IACzD,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,IAAI,CA+BP;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,0zDAkC4B,CAAA"}