patdown 0.4.0 → 0.5.0

package/README.md

@@ -19,22 +19,29 @@ Node.js **>=22.22.2** and pnpm **11.8.0**. CI runs checks and built-CLI smoke te
 
 ## Commands
 
+From this repo, prefer the workspace script. It builds `patdown` through Turborepo (`dependsOn: build`) and then runs the CLI from your current directory:
+
 ```
 pnpm -w patdown
 pnpm -w patdown -- --rules ./rules.md
+pnpm -w patdown -- --rules ./packs/typescript --verbose
 pnpm -w patdown -- rules
 pnpm -w patdown -- ask "Is this markdown heading title case?" --input-text "# Hello World"
 pnpm -w patdown -- ask "Is this urgent?" --input-text "ASAP" --verbose
 pnpm -w patdown -- --yes-threshold 0.9
+pnpm -w patdown -- --files src/cli.ts --files README.md
+pnpm -w patdown -- --files-from changed.txt --verbose
 ```
 
+Do not run `pnpm build` by hand just to exercise the CLI, and do not use bare `npx patdown` against an unpublished branch (that installs the last registry version). After a release, consumers use `npx patdown` / `pnpm add -D patdown` as usual.
+
 Default command lints from the current directory. `rules` prints what it loaded. `ask` answers a yes/no question, no files involved. It prints `yes` or `no`; `--verbose` also shows a P(yes) shade bar, the cutoff, and how long the judge call took. The old `--noul` and `--state` flags have been replaced by a positional question and `--input-text`.
 
-To judge piped output, use `--stdin`. For example, after building with `pnpm -w build` or running any `pnpm -w patdown` command:
+To judge piped output, use `--stdin`:
 
 ```sh
-git diff --cached | node apps/patdown/dist/patdown-cli-bin.js ask "Does this diff introduce debugging statements?" --stdin
-printf 'ASAP: production is down\n' | node apps/patdown/dist/patdown-cli-bin.js ask "Is this urgent?" --stdin
+git diff --cached | pnpm -w patdown -- ask "Does this diff introduce debugging statements?" --stdin
+printf 'ASAP: production is down\n' | pnpm -w patdown -- ask "Is this urgent?" --stdin
 ```
 
 These send the piped content to the configured judge. Do not pipe secrets. `--stdin` reads UTF-8 text through EOF, preserving newlines; it cannot be combined with `--input-text`. Without either option, the input is an empty string. `ask` reports yes/no without treating yes as a failing exit status.
@@ -94,6 +101,22 @@ await Effect.runPromise(runPatdownCli(PatdownRuleSourceLive))
 
 See [the adapter guide](docs/rule-source-adapters.md) for the interface, a multi-file parser, resolution rules, resource lifetimes, and local development setup. Adapters execute trusted local code. Install the CLI from npm as `patdown`; adapters import `@patdown/rules` and may import `patdown` for types.
 
+## Packs
+
+Optional rule bundles live under [`packs/`](packs/README.md). The CLI only runs rules; packs are content you can take all of, some of, or skip:
+
+- [`packs/typescript`](packs/typescript/) — type-safety crimes and type laundering
+- [`packs/effect`](packs/effect/) — Effect v4 services, schemas, errors, time, HTTP, tests
+- [`packs/anti-slop`](packs/anti-slop/) — fuzzy counterpart to [Dillon Mulroy's anti-slop](https://github.com/dmmulroy/anti-slop)
+
+```sh
+# whole pack, or a single rule file from a pack
+patdown --rules ./packs/effect --files-from changed.txt --verbose
+patdown --rules ./packs/typescript/do-not-launder-types-with-casts.md
+```
+
+`--rules` accepts a markdown file or a directory of rule files (every `*.md` except `README.md`). Prefer stacked, backtick-wrapped `globs:` lines; commas inside one `globs:` value are separators.
+
 ## Rules
 
 One `# heading` per rule. Optional `globs:` and `yes-threshold:` lines sit immediately under the heading, in either order. Commas or spaces, extra `globs:` lines stack. A second `yes-threshold:` line is an error. Text above the first heading is ignored. Headings inside fenced code are ignored. Only `#` headings start rules; `##` and deeper headings stay in the rule body, so sections like `## Not allowed` and `## Exceptions` are fine.
@@ -119,12 +142,22 @@ FAIL README.md: No title case
 patdown: failed
 ```
 
-Exit 1 on a violation, a missing rules file, a read error, an invalid cutoff, or a judge error. Add `--verbose` to show a P(yes) shade bar, the numeric probability, the cutoff, and elapsed judge time. Lint totals that time across every rule/file pair.
+Exit 1 on a violation, a missing rules file, a read error, an invalid cutoff, or a judge error. Add `--verbose` to group local lint output into per-rule console blocks (file, shade bar, P(yes), elapsed). Quiet mode stays one `PASS`/`FAIL` line per judgment. Lint totals elapsed time across every rule/file pair.
+
+```
+┌ Do not launder types with casts ───────────────────────── 1✗ / 1
+│
+├─ apps/foo
+│
+│  ✗  ▓▓▓▓▓▓▓▓▒░  0.86  312ms  service.ts
+└
 
-````
-FAIL service.ts: explicit-actor (▓▓▓▓▓▓▓▓▒░ estimated P(yes): 0.86; cutoff: >0.85; elapsed: 312ms)
 patdown: failed (elapsed: 1840ms)
-``` Patdown counts estimated P(yes) strictly above the cutoff as yes; for lint, yes means violation. Default cutoff is 0.85. Override it with `--yes-threshold`, package.json `patdown.yesThreshold`, or a per-rule `yes-threshold:` line. The flag wins over package.json; a per-rule value wins for that rule only. `1` is rejected because nothing can exceed it. This cutoff belongs to patdown, not the provider.
+```
+
+`--files` (repeatable) and `--files-from` restrict lint to an explicit path list intersected with each rule's globs. That is how CI should run over a pull request. See [GitHub Actions](docs/github-actions.md).
+
+Patdown counts estimated P(yes) strictly above the cutoff as yes; for lint, yes means violation. Default cutoff is 0.85. Override it with `--yes-threshold`, package.json `patdown.yesThreshold`, or a per-rule `yes-threshold:` line. The flag wins over package.json; a per-rule value wins for that rule only. `1` is rejected because nothing can exceed it. This cutoff belongs to patdown, not the provider.
 
 See [judge providers](docs/judge-providers.md) for custom layers and the planned Effect Decision integration.
 
@@ -155,8 +188,8 @@ const JsonOutputLive = Layer.succeed(PatdownOutput, {
 	writeLintResult: (result, _verbose) => Console.log(JSON.stringify(result)),
 	writeRulesDocument: (document) => Console.log(JSON.stringify(document)),
 	writeNoFilesMatched: (ruleTitle) => Console.log(JSON.stringify({ skipped: ruleTitle })),
-	writeLintOk: Console.log(JSON.stringify({ status: 'ok' })),
-	writeLintFailed: Console.log(JSON.stringify({ status: 'failed' })),
+	writeLintOk: () => Console.log(JSON.stringify({ status: 'ok' })),
+	writeLintFailed: () => Console.log(JSON.stringify({ status: 'failed' })),
 })
 
 await Effect.runPromise(
@@ -167,7 +200,7 @@ await Effect.runPromise(
 		JsonOutputLive,
 	),
 )
-````
+```
 
 The output service receives structured judgments and lint results, including probabilities even when `--verbose` is off. Your layer decides what to print, collect, or omit. Formatting does not change the cutoff or exit status. The example emits one JSON object per output event, not a single JSON document for the entire run.
 
@@ -177,7 +210,7 @@ This is an embedding API, not a `--format` flag or dynamically discovered output
 
 With the default TypeSafe backend, `TYPESAFE_API_KEY` is required for lint and `ask`. Optional `TYPESAFE_BASE_URL` (default `https://api.typesafe.ai`) and `TYPESAFE_DEFAULT_MODEL` (default `jev-latest`).
 
-`pnpm -w patdown` forwards `TYPESAFE_*` through Turbo.
+`pnpm -w patdown` inherits `TYPESAFE_*` from your environment.
 
 ## Release
 
@@ -203,6 +236,8 @@ Inspired by [pi-warden](https://github.com/DevMortimer/pi-warden). Same idea, in
 
 [Jev Review](https://github.com/devagrawal09/jev-review) is a Jev-backed diff/codebase reviewer with a local dashboard of those judgments. Patdown stays in the terminal; `--verbose` draws a P(yes) shade bar instead of a GUI.
 
+[Dillon Mulroy's anti-slop](https://github.com/dmmulroy/anti-slop) is the Oxlint ruleset that [`packs/anti-slop`](packs/anti-slop/) rephrases for fuzzy judging. Keep the static rules for exact AST hits; use the pack for paraphrases and type-laundering that still looks clean to a linter.
+
 Name inspired by It's Always Sunny in Philadelphia
 
 <img width="511" height="415" alt="image" src="https://github.com/user-attachments/assets/f7c73138-3914-4fbd-9e6b-7a37d161334a" />

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,iBAAiB,EAKjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAU,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAA;AAE7D,OAAO,EAAE,YAAY,EAAuC,MAAM,oBAAoB,CAAA;AAEtF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AA8BnD,KAAK,mBAAmB,GACrB,UAAU,CAAC,UAAU,GACrB,KAAK,CAAC,KAAK,GACX,YAAY,GACZ,IAAI,CAAC,IAAI,GACT,aAAa,GACb,iBAAiB,CAAA;AAuBpB,4EAA4E;AAC5E,wBAAgB,kBAAkB,CACjC,gBAAgB,GAAE,OAAc,GAC9B,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CA6GvE;AAED,uEAAuE;AACvE,eAAO,MAAM,cAAc,uEAAuB,CAAA"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,iBAAiB,EAKjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAU,UAAU,EAAU,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAChE,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAA;AAE7D,OAAO,EAAE,YAAY,EAAuC,MAAM,oBAAoB,CAAA;AAGtF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AA8CnD,KAAK,mBAAmB,GACrB,UAAU,CAAC,UAAU,GACrB,KAAK,CAAC,KAAK,GACX,YAAY,GACZ,IAAI,CAAC,IAAI,GACT,aAAa,GACb,iBAAiB,CAAA;AA+IpB,4EAA4E;AAC5E,wBAAgB,kBAAkB,CACjC,gBAAgB,GAAE,OAAc,GAC9B,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CA6BvE;AAED,uEAAuE;AACvE,eAAO,MAAM,cAAc,uEAAuB,CAAA"}

package/dist/cli.js

@@ -1,8 +1,9 @@
 import { PatdownRuleSource, PatdownRulesFileMissing, PatdownRulesReadFailed, PatdownRulesLoadFailed, PatdownYesThresholdInvalid, } from '@patdown/rules';
-import { Effect, FileSystem, Path, Stdio } from 'effect';
+import { Effect, FileSystem, Option, Path, Stdio } from 'effect';
 import { Argument, Command, Flag } from 'effect/unstable/cli';
 import { PatdownJudge, PatdownJudgeFailed, askPatdownJudge } from '#src/patdown-judge';
 import { runPatdownLint } from '#src/patdown-lint';
+import { resolvePatdownLintFileSelection } from '#src/patdown-lint-files';
 import { PatdownOutput } from '#src/patdown-output';
 import { readPatdownQuestionInput } from '#src/patdown-question-input';
 import { loadConfiguredPatdownRules } from '#src/patdown-rule-source-adapter';
@@ -11,10 +12,13 @@ const failPatdown = (message) => Effect.sync(() => {
     process.exitCode = 1;
     process.stderr.write(`${message}\n`);
 });
-const rulesFileFlag = Flag.optional(Flag.string('rules')).pipe(Flag.withDescription('Path passed to the rule source. Markdown skips the AGENTS.PATDOWN.md walk'));
+const rulesFileFlag = Flag.optional(Flag.string('rules')).pipe(Flag.withDescription('Rules markdown file or directory of rule files. Skips the AGENTS.PATDOWN.md walk'));
 const verboseFlag = Flag.boolean('verbose').pipe(Flag.withDefault(false), Flag.withDescription('Show estimated yes probabilities, the decision cutoff, and elapsed judge time'));
-const adapterFlag = Flag.optional(Flag.string('adapter')).pipe(Flag.withDescription('Module exporting PatdownRuleSourceLive, replacingkdown rule parsing'));
+const adapterFlag = Flag.optional(Flag.string('adapter')).pipe(Flag.withDescription('Module exporting PatdownRuleSourceLive, replacing markdown rule parsing'));
 const yesThresholdFlag = Flag.optional(Flag.float('yes-threshold')).pipe(Flag.withDescription('Minimum exclusive P(yes) for yes; default 0.85, overridable per rule'));
+const filesFlag = Flag.string('files').pipe(Flag.between(0, 10_000), Flag.withDescription('Restrict lint to these paths; intersects each rule glob'));
+const filesFromFlag = Flag.optional(Flag.string('files-from')).pipe(Flag.withDescription('Newline-separated paths to lint; intersects each rule glob'));
+const noGitHubFlag = Flag.boolean('no-github').pipe(Flag.withDefault(false), Flag.withDescription('Disable GitHub Actions summary and annotations'));
 function finishPatdownLint(failed, verbose, elapsedMs) {
     return Effect.gen(function* () {
         const output = yield* PatdownOutput;
@@ -28,9 +32,8 @@ function finishPatdownLint(failed, verbose, elapsedMs) {
         yield* output.writeLintOk(verbose ? elapsedMs : undefined);
     });
 }
-/** Builds commands with optional adapter discovery for embedded callers. */
-export function makePatdownCommand(discoverAdapters = true) {
-    const rulesCommand = Command.make('rules', { adapter: adapterFlag, rules: rulesFileFlag }, ({ rules, adapter, }) => Effect.gen(function* () {
+function makePatdownRulesCommand(discoverAdapters) {
+    return Command.make('rules', { adapter: adapterFlag, rules: rulesFileFlag }, ({ rules, adapter, }) => Effect.gen(function* () {
         const patdownRuleSource = yield* PatdownRuleSource;
         const output = yield* PatdownOutput;
         const document = yield* discoverAdapters
@@ -43,7 +46,9 @@ export function makePatdownCommand(discoverAdapters = true) {
         PatdownRulesLoadFailed: (error) => failPatdown(error.message),
         PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
     }))).pipe(Command.withDescription('Load and print patdown rules'));
-    const askCommand = Command.make('ask', {
+}
+function makePatdownAskCommand() {
+    return Command.make('ask', {
         question: Argument.string('question'),
         verbose: verboseFlag,
         yesThreshold: yesThresholdFlag,
@@ -59,27 +64,47 @@ export function makePatdownCommand(discoverAdapters = true) {
         PatdownJudgeFailed: (error) => failPatdown(error.message),
         PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
     }))).pipe(Command.withDescription('Ask a yes/no question about text'));
-    /** Root Effect CLI command for patdown. Default action lints files against AGENTS.PATDOWN.md. */
-    return Command.make('patdown', {
-        adapter: adapterFlag,
-        rules: rulesFileFlag,
-        verbose: verboseFlag,
-        yesThreshold: yesThresholdFlag,
-    }, ({ rules, adapter, verbose, yesThreshold }) => Effect.gen(function* () {
+}
+function runPatdownRootLint(discoverAdapters, options) {
+    return Effect.gen(function* () {
         const patdownRuleSource = yield* PatdownRuleSource;
-        const cutoff = yield* resolvePatdownYesThreshold(yesThreshold);
+        const path = yield* Path.Path;
+        const cutoff = yield* resolvePatdownYesThreshold(options.yesThreshold);
+        const cwd = path.resolve('.');
+        const selection = yield* resolvePatdownLintFileSelection(cwd, options.files, options.filesFrom);
         const document = yield* discoverAdapters
-            ? loadConfiguredPatdownRules(adapter, rules)
-            : patdownRuleSource.loadPatdownRules(rules);
-        const linted = yield* runPatdownLint(document, verbose, cutoff);
-        yield* finishPatdownLint(linted.failed, verbose, linted.elapsedMs);
+            ? loadConfiguredPatdownRules(options.adapter, options.rules)
+            : patdownRuleSource.loadPatdownRules(options.rules);
+        const linted = yield* runPatdownLint(document, options.verbose, cutoff, selection);
+        yield* finishPatdownLint(linted.failed, options.verbose, linted.elapsedMs);
     }).pipe(Effect.catchTags({
         PatdownRulesLoadFailed: (error) => failPatdown(error.message),
         PatdownJudgeFailed: (error) => failPatdown(error.message),
         PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
         PatdownRulesFileMissing: (error) => failPatdown(error.message),
         PatdownRulesReadFailed: (error) => failPatdown(error.message),
-    }))).pipe(Command.withDescription('Lint a tree against fuzzykdown rules'), Command.withShortDescription('Patdown CLI'), Command.withSubcommands([askCommand, rulesCommand]));
+    }));
+}
+/** Builds commands with optional adapter discovery for embedded callers. */
+export function makePatdownCommand(discoverAdapters = true) {
+    const rulesCommand = makePatdownRulesCommand(discoverAdapters);
+    const askCommand = makePatdownAskCommand();
+    return Command.make('patdown', {
+        adapter: adapterFlag,
+        files: filesFlag,
+        filesFrom: filesFromFlag,
+        noGitHub: noGitHubFlag,
+        rules: rulesFileFlag,
+        verbose: verboseFlag,
+        yesThreshold: yesThresholdFlag,
+    }, ({ rules, adapter, verbose, yesThreshold, files, filesFrom, noGitHub: _noGitHub }) => runPatdownRootLint(discoverAdapters, {
+        rules,
+        adapter,
+        verbose,
+        yesThreshold,
+        files,
+        filesFrom,
+    })).pipe(Command.withDescription('Lint a tree against fuzzy markdown rules'), Command.withShortDescription('Patdown CLI'), Command.withSubcommands([askCommand, rulesCommand]));
 }
 /** Default commands use explicit or package.json adapter discovery. */
 export const patdownCommand = makePatdownCommand();

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 export { patdownCommand, makePatdownCommand } from '#src/cli';
 export { PatdownOutput, PatdownOutputLive, type PatdownLintResult } from '#src/patdown-output';
+export { PatdownGitHubActionsOutputLive } from '#src/patdown-github-actions-output';
+export { formatPatdownGitHubActionsAnnotations, formatPatdownGitHubActionsSummary, formatPatdownRuleGuidance, patdownLintResultIsNearMiss, } from '#src/patdown-github-actions-summary';
+export { patdownGitHubActionsIsEnabled, readPatdownGitHubStepSummaryPath, } from '#src/patdown-github-actions-env';
+export type { PatdownLintFileSelection } from '#src/patdown-lint-files';
 export type { PatdownRuleSourceLayer } from '#src/patdown-rule-source-adapter';
 export { runPatdownCli } from '#src/run-patdown-cli';
-export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, patdownJudgmentIsYes, patdownYesThreshold, type PatdownJudgment, type PatdownTimedJudgment, } from '#src/patdown-judge';
+export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, locatePatdownEvidence, patdownJudgmentIsYes, patdownYesThreshold, type PatdownEvidenceChoice, type PatdownEvidenceLocation, type PatdownJudgment, type PatdownTimedJudgment, } from '#src/patdown-judge';
 export { defaultPatdownYesThreshold, decodePatdownYesThreshold, PatdownYesThresholdInvalid, type PatdownYesThreshold, } from '@patdown/rules';
 export { TypeSafeJudgeLive } from '#src/typesafe-judge';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE9F,YAAY,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAE9E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GACzB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACN,0BAA0B,EAC1B,yBAAyB,EACzB,0BAA0B,EAC1B,KAAK,mBAAmB,GACxB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE9F,OAAO,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAA;AAEnF,OAAO,EACN,qCAAqC,EACrC,iCAAiC,EACjC,yBAAyB,EACzB,2BAA2B,GAC3B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,EACN,6BAA6B,EAC7B,gCAAgC,GAChC,MAAM,iCAAiC,CAAA;AAExC,YAAY,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,YAAY,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAE9E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,oBAAoB,GACzB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACN,0BAA0B,EAC1B,yBAAyB,EACzB,0BAA0B,EAC1B,KAAK,mBAAmB,GACxB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -1,6 +1,9 @@
 export { patdownCommand, makePatdownCommand } from '#src/cli';
 export { PatdownOutput, PatdownOutputLive } from '#src/patdown-output';
+export { PatdownGitHubActionsOutputLive } from '#src/patdown-github-actions-output';
+export { formatPatdownGitHubActionsAnnotations, formatPatdownGitHubActionsSummary, formatPatdownRuleGuidance, patdownLintResultIsNearMiss, } from '#src/patdown-github-actions-summary';
+export { patdownGitHubActionsIsEnabled, readPatdownGitHubStepSummaryPath, } from '#src/patdown-github-actions-env';
 export { runPatdownCli } from '#src/run-patdown-cli';
-export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, patdownJudgmentIsYes, patdownYesThreshold, } from '#src/patdown-judge';
+export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, locatePatdownEvidence, patdownJudgmentIsYes, patdownYesThreshold, } from '#src/patdown-judge';
 export { defaultPatdownYesThreshold, decodePatdownYesThreshold, PatdownYesThresholdInvalid, } from '@patdown/rules';
 export { TypeSafeJudgeLive } from '#src/typesafe-judge';

package/dist/patdown-console-rule-blocks.d.ts

@@ -0,0 +1,13 @@
+import type { PatdownLintResult } from '#src/patdown-output';
+/** Soft cap so extreme directory labels do not dominate the header line. */
+export declare const patdownConsolePathMaxWidth = 48;
+/** Keep the basename side of long paths: `…/src/patdown-github-actions-summary.ts`. */
+export declare function formatPatdownConsolePath(filePath: string, maxWidth?: number): string;
+/** Quiet one-line lint result. */
+export declare function formatPatdownLintResultLine(result: PatdownLintResult): string;
+/**
+ * Verbose local console: one box per rule, files grouped by directory with ├─ headers. Empty
+ * results mean the rule matched no files.
+ */
+export declare function formatPatdownRuleBlock(ruleTitle: string, results: ReadonlyArray<PatdownLintResult>): string;
+//# sourceMappingURL=patdown-console-rule-blocks.d.ts.map

package/dist/patdown-console-rule-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-console-rule-blocks.d.ts","sourceRoot":"","sources":["../src/patdown-console-rule-blocks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D,4EAA4E;AAC5E,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAc5C,uFAAuF;AACvF,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,MAAmC,GAC3C,MAAM,CAaR;AA0BD,kCAAkC;AAClC,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAI7E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,aAAa,CAAC,iBAAiB,CAAC,GACvC,MAAM,CA4CR"}

package/dist/patdown-console-rule-blocks.js

@@ -0,0 +1,80 @@
+import { dirname, basename } from 'node:path';
+import { formatPatdownProbabilityBar } from '#src/patdown-probability-bar';
+const patdownRuleBlockWidth = 64;
+/** Soft cap so extreme directory labels do not dominate the header line. */
+export const patdownConsolePathMaxWidth = 48;
+function formatPatdownConsoleElapsed(elapsedMs) {
+    return `${String(elapsedMs)}ms`;
+}
+function padPatdownRuleBlockTitle(title, failCount, judgedCount) {
+    const suffix = ` ${String(failCount)}✗ / ${String(judgedCount)}`;
+    const prefix = `┌ ${title} `;
+    const fill = Math.max(2, patdownRuleBlockWidth - prefix.length - suffix.length);
+    return `${prefix}${'─'.repeat(fill)}${suffix}`;
+}
+/** Keep the basename side of long paths: `…/src/patdown-github-actions-summary.ts`. */
+export function formatPatdownConsolePath(filePath, maxWidth = patdownConsolePathMaxWidth) {
+    if (filePath.length <= maxWidth)
+        return filePath;
+    const ellipsis = '…';
+    const keep = Math.max(1, maxWidth - ellipsis.length);
+    const tail = filePath.slice(-keep);
+    const slash = tail.indexOf('/');
+    if (slash > 0 && slash < tail.length - 1) {
+        return `${ellipsis}${tail.slice(slash)}`;
+    }
+    return `${ellipsis}${tail}`;
+}
+function patdownConsoleDirectoryLabel(filePath) {
+    const directory = dirname(filePath);
+    return directory === '.' ? '.' : directory;
+}
+function formatPatdownDirectoryHeader(directory) {
+    return `├─ ${formatPatdownConsolePath(directory)}`;
+}
+function formatPatdownRuleBlockRow(result, timeWidth, nameWidth) {
+    const mark = result.violated ? '✗' : '✓';
+    const bar = formatPatdownProbabilityBar(result.violationProbability);
+    const score = result.violationProbability.toFixed(2).padStart(4, ' ');
+    const time = formatPatdownConsoleElapsed(result.elapsedMs).padStart(timeWidth, ' ');
+    const name = formatPatdownConsolePath(basename(result.filePath)).padEnd(nameWidth, ' ');
+    return `│  ${mark}  ${bar}  ${score}  ${time}  ${name}`.trimEnd();
+}
+/** Quiet one-line lint result. */
+export function formatPatdownLintResultLine(result) {
+    const verdict = result.violated ? 'FAIL' : 'PASS';
+    return `${verdict} ${result.filePath}: ${result.ruleTitle}`;
+}
+/**
+ * Verbose local console: one box per rule, files grouped by directory with ├─ headers. Empty
+ * results mean the rule matched no files.
+ */
+export function formatPatdownRuleBlock(ruleTitle, results) {
+    const failCount = results.filter((result) => result.violated).length;
+    const lines = [padPatdownRuleBlockTitle(ruleTitle, failCount, results.length)];
+    lines.push('│');
+    if (results.length === 0) {
+        lines.push('│  (no files matched)');
+    }
+    else {
+        const ordered = [...results].toSorted((left, right) => left.filePath.localeCompare(right.filePath));
+        const timeWidth = Math.max(...ordered.map((result) => formatPatdownConsoleElapsed(result.elapsedMs).length));
+        const nameWidth = Math.max(...ordered.map((result) => formatPatdownConsolePath(basename(result.filePath)).length));
+        let currentDirectory = null;
+        for (const result of ordered) {
+            const directory = patdownConsoleDirectoryLabel(result.filePath);
+            const startingNewDirectory = directory !== currentDirectory;
+            if (startingNewDirectory && currentDirectory !== null) {
+                lines.push('│');
+            }
+            if (startingNewDirectory) {
+                lines.push(formatPatdownDirectoryHeader(directory));
+                lines.push('│');
+                currentDirectory = directory;
+            }
+            lines.push(formatPatdownRuleBlockRow(result, timeWidth, nameWidth));
+        }
+    }
+    lines.push('└');
+    return lines.join('\n');
+}

package/dist/patdown-evidence-regions.d.ts

@@ -0,0 +1,44 @@
+/** One Choice candidate with a known 1-based line span. */
+export type PatdownEvidenceCandidate = {
+    readonly id: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly content: string;
+};
+/** Prefer one Choice label per source line while the file stays under this size. */
+export declare const patdownEvidencePerLineMaxCount = 500;
+/** Chunk height when the file is too large for per-line Choice. */
+export declare const patdownEvidenceChunkLineCount = 80;
+/** Cap chunked candidates so the second pass stays bounded. */
+export declare const patdownEvidenceChunkMaxCount = 24;
+/** Truncate long line text used as Choice descriptions. */
+export declare const patdownEvidenceDescriptionMaxChars = 160;
+/** Minimum Choice confidence before a FAIL annotation uses the selected span. */
+export declare const patdownEvidenceMinConfidence = 0.55;
+/** Label returned when no candidate is strong enough. */
+export declare function patdownEvidenceNoMatchChoice(): string;
+/**
+ * Build FAIL-only Choice candidates. Prefer one label per line. Past
+ * {@link patdownEvidencePerLineMaxCount}, fall back to chunks. Smarter units (functions, headings,
+ * hunks) can replace this later without changing the Choice pass.
+ */
+export declare function splitPatdownEvidenceCandidates(contents: string, perLineMaxCount?: number, chunkLineCount?: number, chunkMaxCount?: number): ReadonlyArray<PatdownEvidenceCandidate>;
+/** Choice criteria: candidate ids plus noMatch. Descriptions stay short. */
+export type PatdownEvidenceChoiceCriteria = {
+    readonly [label: string]: string;
+};
+export declare function patdownEvidenceChoiceCriteria(candidates: ReadonlyArray<PatdownEvidenceCandidate>): PatdownEvidenceChoiceCriteria;
+/** Inputs for FAIL-only evidence Choice state. */
+export type PatdownEvidenceChoiceStateInput = {
+    readonly relativePath: string;
+    readonly ruleTitle: string;
+    readonly ruleBody: string;
+    readonly violationProbability: number;
+    readonly contents: string;
+    readonly candidates: ReadonlyArray<PatdownEvidenceCandidate>;
+};
+/** State for the evidence Choice: original FAIL, full file, and candidate index. */
+export declare function formatPatdownEvidenceChoiceState(input: PatdownEvidenceChoiceStateInput): string;
+/** Instructions for selecting the strongest violating candidate. */
+export declare function patdownEvidenceChoiceInstructions(): string;
+//# sourceMappingURL=patdown-evidence-regions.d.ts.map

package/dist/patdown-evidence-regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-evidence-regions.d.ts","sourceRoot":"","sources":["../src/patdown-evidence-regions.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,MAAM,MAAM,wBAAwB,GAAG;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,8BAA8B,MAAM,CAAA;AAEjD,mEAAmE;AACnE,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,+DAA+D;AAC/D,eAAO,MAAM,4BAA4B,KAAK,CAAA;AAE9C,2DAA2D;AAC3D,eAAO,MAAM,kCAAkC,MAAM,CAAA;AAErD,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAIhD,yDAAyD;AACzD,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAiED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC7C,QAAQ,EAAE,MAAM,EAChB,eAAe,GAAE,MAAuC,EACxD,cAAc,GAAE,MAAsC,EACtD,aAAa,GAAE,MAAqC,GAClD,aAAa,CAAC,wBAAwB,CAAC,CAQzC;AAED,4EAA4E;AAC5E,MAAM,MAAM,6BAA6B,GAAG;IAC3C,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAChC,CAAA;AAED,wBAAgB,6BAA6B,CAC5C,UAAU,EAAE,aAAa,CAAC,wBAAwB,CAAC,GACjD,6BAA6B,CAkB/B;AAED,kDAAkD;AAClD,MAAM,MAAM,+BAA+B,GAAG;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAA;CAC5D,CAAA;AAED,oFAAoF;AACpF,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,+BAA+B,GAAG,MAAM,CA+B/F;AAED,oEAAoE;AACpE,wBAAgB,iCAAiC,IAAI,MAAM,CAO1D"}

package/dist/patdown-evidence-regions.js

@@ -0,0 +1,124 @@
+/** Prefer one Choice label per source line while the file stays under this size. */
+export const patdownEvidencePerLineMaxCount = 500;
+/** Chunk height when the file is too large for per-line Choice. */
+export const patdownEvidenceChunkLineCount = 80;
+/** Cap chunked candidates so the second pass stays bounded. */
+export const patdownEvidenceChunkMaxCount = 24;
+/** Truncate long line text used as Choice descriptions. */
+export const patdownEvidenceDescriptionMaxChars = 160;
+/** Minimum Choice confidence before a FAIL annotation uses the selected span. */
+export const patdownEvidenceMinConfidence = 0.55;
+const patdownEvidenceNoMatchLabel = 'noMatch';
+/** Label returned when no candidate is strong enough. */
+export function patdownEvidenceNoMatchChoice() {
+    return patdownEvidenceNoMatchLabel;
+}
+function normalizePatdownEvidenceLines(contents) {
+    const normalized = contents.replace(/\r\n/gu, '\n');
+    if (normalized.length === 0)
+        return [''];
+    // Trailing newline must not create a phantom empty line / endLine past EOF.
+    const withoutTrailingNewline = normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+    return withoutTrailingNewline.length === 0 ? [''] : withoutTrailingNewline.split('\n');
+}
+function truncatePatdownEvidenceDescription(text) {
+    const collapsed = text.replace(/\s+/gu, ' ').trim();
+    if (collapsed.length === 0)
+        return '(empty line)';
+    if (collapsed.length <= patdownEvidenceDescriptionMaxChars)
+        return collapsed;
+    return `${collapsed.slice(0, patdownEvidenceDescriptionMaxChars - 1)}…`;
+}
+function splitPatdownEvidenceChunks(lines, lineCount, maxChunks) {
+    const candidates = [];
+    const step = Math.max(1, lineCount);
+    for (let startIndex = 0; startIndex < lines.length; startIndex += step) {
+        if (candidates.length >= maxChunks)
+            break;
+        const endIndex = Math.min(lines.length, startIndex + step);
+        const startLine = startIndex + 1;
+        const endLine = endIndex;
+        const id = `c${String(candidates.length + 1)}`;
+        candidates.push({
+            id,
+            startLine,
+            endLine,
+            content: lines.slice(startIndex, endIndex).join('\n'),
+        });
+    }
+    return candidates;
+}
+function splitPatdownEvidenceLines(lines) {
+    return lines.map((content, index) => {
+        const startLine = index + 1;
+        return {
+            id: `L${String(startLine)}`,
+            startLine,
+            endLine: startLine,
+            content,
+        };
+    });
+}
+/**
+ * Build FAIL-only Choice candidates. Prefer one label per line. Past
+ * {@link patdownEvidencePerLineMaxCount}, fall back to chunks. Smarter units (functions, headings,
+ * hunks) can replace this later without changing the Choice pass.
+ */
+export function splitPatdownEvidenceCandidates(contents, perLineMaxCount = patdownEvidencePerLineMaxCount, chunkLineCount = patdownEvidenceChunkLineCount, chunkMaxCount = patdownEvidenceChunkMaxCount) {
+    const lines = normalizePatdownEvidenceLines(contents);
+    if (lines.length <= perLineMaxCount) {
+        return splitPatdownEvidenceLines(lines);
+    }
+    return splitPatdownEvidenceChunks(lines, chunkLineCount, chunkMaxCount);
+}
+export function patdownEvidenceChoiceCriteria(candidates) {
+    const entries = [
+        [patdownEvidenceNoMatchLabel, 'No candidate provides clear, direct evidence of the violation'],
+    ];
+    for (const candidate of candidates) {
+        const span = candidate.startLine === candidate.endLine
+            ? `Line ${String(candidate.startLine)}`
+            : `Lines ${String(candidate.startLine)}-${String(candidate.endLine)}`;
+        entries.push([
+            candidate.id,
+            `${span}: ${truncatePatdownEvidenceDescription(candidate.content)}`,
+        ]);
+    }
+    return Object.fromEntries(entries);
+}
+/** State for the evidence Choice: original FAIL, full file, and candidate index. */
+export function formatPatdownEvidenceChoiceState(input) {
+    const mode = input.candidates.length > 0 && input.candidates[0]?.startLine === input.candidates[0]?.endLine
+        ? 'per-line'
+        : 'chunked';
+    const parts = [
+        `path: ${input.relativePath}`,
+        `noul P(yes): ${String(input.violationProbability)}`,
+        `candidate mode: ${mode}`,
+        '',
+        `# ${input.ruleTitle}`,
+        '',
+        input.ruleBody,
+        '',
+        'Full file:',
+        input.contents,
+        '',
+        'Candidates (choose the strongest direct evidence of the violation):',
+    ];
+    for (const candidate of input.candidates) {
+        const span = candidate.startLine === candidate.endLine
+            ? `line ${String(candidate.startLine)}`
+            : `lines ${String(candidate.startLine)}-${String(candidate.endLine)}`;
+        parts.push(`- ${candidate.id}: ${span}`);
+    }
+    return parts.join('\n');
+}
+/** Instructions for selecting the strongest violating candidate. */
+export function patdownEvidenceChoiceInstructions() {
+    return [
+        'Which candidate provides the strongest direct evidence that this file violates the rule?',
+        'When candidates are single lines, pick the specific line that contains the violation.',
+        'Select noMatch when no candidate provides sufficient evidence.',
+        'Prefer the clearest violation, not merely related text.',
+    ].join(' ');
+}

package/dist/patdown-github-actions-env.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from 'effect';
+/** True when GitHub Actions exposes a step summary file. */
+export declare const patdownGitHubActionsIsEnabled: Effect.Effect<boolean>;
+/** Absolute path of the step summary file when Actions is active. */
+export declare const readPatdownGitHubStepSummaryPath: Effect.Effect<string | null>;
+//# sourceMappingURL=patdown-github-actions-env.d.ts.map

package/dist/patdown-github-actions-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-github-actions-env.d.ts","sourceRoot":"","sources":["../src/patdown-github-actions-env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAU,MAAM,QAAQ,CAAA;AAE/C,4DAA4D;AAC5D,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAiB/D,CAAA;AAEF,qEAAqE;AACrE,eAAO,MAAM,gCAAgC,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAWzE,CAAA"}

package/dist/patdown-github-actions-env.js

@@ -0,0 +1,17 @@
+import { Config, Effect, Option } from 'effect';
+/** True when GitHub Actions exposes a step summary file. */
+export const patdownGitHubActionsIsEnabled = Effect.gen(function* () {
+    const actions = yield* Config.string('GITHUB_ACTIONS').pipe(Config.option, Effect.orElseSucceed(() => Option.none()));
+    const summary = yield* Config.string('GITHUB_STEP_SUMMARY').pipe(Config.option, Effect.orElseSucceed(() => Option.none()));
+    return (Option.isSome(actions) &&
+        actions.value === 'true' &&
+        Option.isSome(summary) &&
+        summary.value.length > 0);
+});
+/** Absolute path of the step summary file when Actions is active. */
+export const readPatdownGitHubStepSummaryPath = Effect.gen(function* () {
+    if (!(yield* patdownGitHubActionsIsEnabled))
+        return null;
+    const summary = yield* Config.string('GITHUB_STEP_SUMMARY').pipe(Config.option, Effect.orElseSucceed(() => Option.none()));
+    return Option.getOrNull(summary);
+});

package/dist/patdown-github-actions-output.d.ts

@@ -0,0 +1,8 @@
+import { FileSystem, Layer } from 'effect';
+import { PatdownOutput } from '#src/patdown-output';
+/**
+ * Human stdout plus GitHub annotations and a step-summary heatmap. Intended when GITHUB_ACTIONS and
+ * GITHUB_STEP_SUMMARY are set.
+ */
+export declare const PatdownGitHubActionsOutputLive: Layer.Layer<PatdownOutput, never, FileSystem.FileSystem>;
+//# sourceMappingURL=patdown-github-actions-output.d.ts.map

package/dist/patdown-github-actions-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-github-actions-output.d.ts","sourceRoot":"","sources":["../src/patdown-github-actions-output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,KAAK,EAAO,MAAM,QAAQ,CAAA;AAOhE,OAAO,EACN,aAAa,EAIb,MAAM,qBAAqB,CAAA;AAM5B;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,KAAK,CAAC,KAAK,CACvD,aAAa,EACb,KAAK,EACL,UAAU,CAAC,UAAU,CAsErB,CAAA"}