pasika 0.3.1 → 0.3.2

package/README.md

@@ -16,9 +16,9 @@ docs/
 enforcement/
   registry.json                   # requirement → enforcement, keyed by content hash
   coverage.ts                     # reconciles the docs against the registry
-  docs-check.ts                   # the documentation guide, mechanically
 eslint/
   pasika/rules/                   # the lint rules, with fixture tests beside them
+  pasika/rules/md/                # the documentation-guide rules, linting docs/ itself
 cli/
   index.ts                        # the `pasika` command
 ```
@@ -48,7 +48,6 @@ The `note` field is where a check's known gap is recorded, so a partial check ne
 | --- | --- |
 | `eslint` | An ESLint rule reports it, and a fixture test titled with the requirement pins it |
 | `doctor` | A `pasika doctor` check reports it |
-| `docs-check` | A `pasika docs` check reports it |
 | `planned` | Mechanically checkable, not written yet; `note` names the intended check |
 | `judgment` | No mechanical check can decide it; `note` says why |
 | `permission` | The requirement grants permission, so there is nothing to check |
@@ -57,9 +56,9 @@ The `note` field is where a check's known gap is recorded, so a partial check ne
 
 ## Commands
 
+The documentation guide itself is linted: the `pasika/*` markdown rules run over `docs/**/*.md` and report title, overview, structure, example-pairing, and RFC 2119 violations at the exact node.
+
 ```bash
-npx pasika docs                # check a docs/ folder against the documentation guide
-npx pasika docs --dir content  # check another folder
 npx pasika coverage            # check that every requirement has recorded enforcement
 npx pasika coverage --accept   # record reworded and removed requirements
 ```
@@ -116,6 +115,10 @@ The ruleset applies to `src/**` only, so a repository without a `src/` tree pass
 | `pasika/component-placement` † | The folder a component's consumers imply |
 | `pasika/support-file-placement` † | The folder a hook, type, schema, constant, or utility belongs in |
 
+### Documentation rules
+
+The `pasika/*` markdown rules enforce the documentation guide over `docs/**/*.md`: file-name suffixes and titles, overview presence and length, guide step structure, Incorrect/Correct pairing, policy document shape, reference block headings, RFC 2119 placement, and template hygiene. They run through `@eslint/markdown` in `eslint.config.ts`; `pasika coverage` verifies each has a test and a registry entry.
+
 Run `pasika coverage --json` for the exact requirement each rule covers.
 
 ### † Cross-file rules
@@ -133,7 +136,6 @@ Both are inert in a repository with no `src/` tree.
 npm run lint
 npm run typecheck
 npm run test
-npm run docs
 npm run coverage
 npm run build
 ```

package/dist/cli/index.js

@@ -4,7 +4,8 @@ import path from "node:path";
 import { Command } from "commander";
 import { buildCoverageReport, classifyRequirement, readRegistry, writeRegistry, } from "../enforcement/coverage.js";
 import { enforcementKindSchema } from "../enforcement/types.js";
-import { checkDocs } from "../enforcement/docs-check.js";
+import { runDoctor } from "../enforcement/doctor.js";
+import { log, error, json } from "./output.js";
 const REGISTRY_RELATIVE_PATH = path.join("enforcement", "registry.json");
 /** Walks up from `startDir` to the directory that holds the enforcement registry. */
 function findRegistryRoot(startDir) {
@@ -30,30 +31,6 @@ function truncate(text, width) {
 }
 const program = new Command();
 program.name("pasika").description("Applies and diagnoses the pasika framework.");
-program
-    .command("docs")
-    .description("Check documentation against the documentation guide.")
-    .option("--dir <path>", "documentation folder to check", "docs")
-    .option("--json", "print findings as JSON")
-    .action((options) => {
-    const docsRoot = path.resolve(options.dir);
-    if (!existsSync(docsRoot)) {
-        console.error(`No documentation folder at ${docsRoot}`);
-        process.exit(1);
-    }
-    const { docs, findings } = checkDocs(docsRoot);
-    if (options.json) {
-        console.log(JSON.stringify({ documents: docs.length, findings }, undefined, 2));
-        process.exit(findings.length > 0 ? 1 : 0);
-    }
-    for (const finding of findings) {
-        console.log(`  ✗ ${finding.doc}:${String(finding.line)}  ${finding.check}  ${finding.message}`);
-    }
-    console.log(findings.length === 0
-        ? `\n✓ ${String(docs.length)} documents pass`
-        : `\n${String(docs.length)} documents checked · ${String(findings.length)} findings`);
-    process.exit(findings.length > 0 ? 1 : 0);
-});
 program
     .command("coverage")
     .description("Check that every documented requirement has recorded enforcement.")
@@ -66,19 +43,19 @@ program
     .action((options) => {
     const root = findRegistryRoot(process.cwd());
     if (!root) {
-        console.error(`No ${REGISTRY_RELATIVE_PATH} found in this directory or any parent.`);
+        error(`No ${REGISTRY_RELATIVE_PATH} found in this directory or any parent.`);
         process.exit(1);
     }
     const docsRoot = path.join(root, "docs");
     if (!existsSync(docsRoot)) {
-        console.error(`No documentation folder at ${docsRoot}. Run coverage inside the pasika repository.`);
+        error(`No documentation folder at ${docsRoot}. Run coverage inside the pasika repository.`);
         process.exit(1);
     }
     const registryPath = path.join(root, REGISTRY_RELATIVE_PATH);
     if (options.classify !== undefined) {
         const kind = enforcementKindSchema.safeParse(options.kind);
         if (!kind.success) {
-            console.error(`✗ --kind must be one of ${enforcementKindSchema.options.join(", ")}.`);
+            error(`✗ --kind must be one of ${enforcementKindSchema.options.join(", ")}.`);
             process.exit(1);
         }
         try {
@@ -91,10 +68,10 @@ program
             const change = result.previousKind === undefined
                 ? `recorded as ${result.requirement.kind}`
                 : `reclassified from ${result.previousKind} to ${result.requirement.kind}`;
-            console.log(`✓ ${change}: ${result.requirement.text}`);
+            log(`✓ ${change}: ${result.requirement.text}`);
         }
-        catch (error) {
-            console.error(`✗ ${error instanceof Error ? error.message : String(error)}`);
+        catch (err) {
+            error(`✗ ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     }
@@ -104,29 +81,46 @@ program
         rulesDir: path.join(root, "eslint", "pasika", "rules"),
     });
     if (options.json) {
-        console.log(JSON.stringify(report, undefined, 2));
+        json(report);
         process.exit(report.issues.length > 0 ? 1 : 0);
     }
     for (const issue of report.issues) {
         const where = issue.line === undefined ? issue.doc : `${issue.doc}:${String(issue.line)}`;
-        console.log(`  ✗ ${ISSUE_LABELS[issue.kind]} ${truncate(issue.text, 76)}`);
-        console.log(`              ${where}${issue.detail ? `\n              ${issue.detail}` : ""}`);
+        log(`  ✗ ${ISSUE_LABELS[issue.kind]} ${truncate(issue.text, 76)}`);
+        log(`              ${where}${issue.detail ? `\n              ${issue.detail}` : ""}`);
     }
     const { counts } = report;
-    console.log([
+    log([
         "",
         `${String(report.total)} requirements · ${String(report.mechanical)} mechanically enforced`,
-        `  eslint ${String(counts.eslint)} · doctor ${String(counts.doctor)} · docs-check ${String(counts["docs-check"])}`,
+        `  eslint ${String(counts.eslint)} · doctor ${String(counts.doctor)}`,
         `  planned ${String(counts.planned)} · judgment ${String(counts.judgment)} · permission ${String(counts.permission)}`,
         `  unclassified ${String(report.issues.filter((issue) => issue.kind === "new").length)}`,
     ].join("\n"));
     if (options.accept) {
         writeRegistry(registryPath, report.nextRegistry);
         const accepted = report.issues.filter((issue) => issue.kind === "changed" || issue.kind === "removed");
-        console.log(`\nAccepted ${String(accepted.length)} change(s) into ${REGISTRY_RELATIVE_PATH}.`);
-        console.log("Requirements reported as new still need a classification.");
+        log(`\nAccepted ${String(accepted.length)} change(s) into ${REGISTRY_RELATIVE_PATH}.`);
+        log("Requirements reported as new still need a classification.");
         process.exit(report.issues.some((issue) => issue.kind === "new") ? 1 : 0);
     }
     process.exit(report.issues.length > 0 ? 1 : 0);
 });
+program
+    .command("doctor")
+    .description("Diagnose gaps between the repository and the pasika framework baseline.")
+    .option("--json", "print findings as JSON")
+    .action((options) => {
+    const findings = runDoctor(process.cwd());
+    if (options.json) {
+        json({ findings });
+        process.exit(findings.some((f) => f.severity === "error") ? 1 : 0);
+    }
+    for (const finding of findings) {
+        const icon = finding.severity === "error" ? "✗" : "⚠";
+        log(`  ${icon} ${finding.check}  ${finding.message}`);
+    }
+    log(findings.length === 0 ? "\n✓ No gaps found" : `\n${String(findings.length)} finding(s)`);
+    process.exit(findings.some((f) => f.severity === "error") ? 1 : 0);
+});
 program.parse();

package/dist/cli/output.d.ts

@@ -0,0 +1,3 @@
+export declare function log(message: string): void;
+export declare function error(message: string): void;
+export declare function json(data: unknown): void;

package/dist/cli/output.js

@@ -0,0 +1,11 @@
+/* eslint-disable no-console -- cli-reports-to-terminal: stdout is the CLI's output channel */
+export function log(message) {
+    console.log(message);
+}
+export function error(message) {
+    console.error(message);
+}
+export function json(data) {
+    console.log(JSON.stringify(data, undefined, 2));
+}
+/* eslint-enable no-console -- re-enable after CLI output block */

package/dist/enforcement/coverage.js

@@ -1,8 +1,7 @@
-import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
-import { pasikaRuleIds } from "../eslint/pasika/index.js";
-import { DOCS_CHECKS } from "./docs-check.js";
+import { allPasikaRuleIds } from "../eslint/pasika/index.js";
 import { parseDocs } from "./parse-docs.js";
 import { MECHANICAL_KINDS, registrySchema } from "./types.js";
 /** Ratio of shared words, used only to guess which stored requirement a reworded bullet came from. */
@@ -13,17 +12,27 @@ function similarity(left, right) {
     const union = new Set([...leftWords, ...rightWords]).size;
     return union === 0 ? 0 : shared / union;
 }
-/** Titles passed to `describe` or `test` in the rule test files. */
+/** Titles passed to `describe` or `test` in the rule test files, recursing into subfolders. */
 function collectTestTitles(rulesDir) {
     const titles = new Set();
-    for (const entry of readdirSync(rulesDir)) {
-        if (!entry.endsWith(".test.ts"))
-            continue;
-        const body = readFileSync(path.join(rulesDir, entry), "utf8");
-        for (const match of body.matchAll(/\b(?:describe|test|it)\(\s*"(?<title>(?:[^"\\]|\\.)*)"/g)) {
-            titles.add((match.groups?.title ?? "").replaceAll('\\"', '"'));
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const entryPath = path.join(dir, entry);
+            if (statSync(entryPath).isDirectory()) {
+                visit(entryPath);
+                continue;
+            }
+            if (!entry.endsWith(".test.ts"))
+                continue;
+            const body = readFileSync(entryPath, "utf8");
+            const titlePattern = /\b(?:describe|test|it)\(\s*(?:"(?<double>(?:[^"\\]|\\.)*)"|'(?<single>(?:[^'\\]|\\.)*)')/g;
+            for (const match of body.matchAll(titlePattern)) {
+                const title = match.groups?.double ?? match.groups?.single ?? "";
+                titles.add(title.replaceAll('\\\\"', '"').replaceAll("\\\\'", "'"));
+            }
         }
-    }
+    };
+    visit(rulesDir);
     return titles;
 }
 /** A requirement several checks cover lists them comma-separated. */
@@ -33,19 +42,16 @@ function refParts(ref) {
         .map((part) => part.trim())
         .filter(Boolean);
 }
-function isRefKnown(requirement, docsChecks) {
+function isRefKnown(requirement) {
     const parts = refParts(requirement.ref);
     if (requirement.kind === "eslint")
-        return parts.length > 0 && parts.every((part) => pasikaRuleIds.includes(part));
-    if (requirement.kind === "docs-check")
-        return parts.length > 0 && parts.every((part) => docsChecks.has(part));
+        return parts.length > 0 && parts.every((part) => allPasikaRuleIds.includes(part));
     // Doctor checks do not exist yet, so a `doctor` entry is a forward reference.
     return true;
 }
 export function buildCoverageReport(options) {
     const { docsRoot, registry, rulesDir } = options;
     const docs = parseDocs(docsRoot);
-    const docsChecks = new Set(DOCS_CHECKS);
     const testTitles = collectTestTitles(rulesDir);
     const byHash = new Map(registry.requirements.map((requirement) => [requirement.hash, requirement]));
     const matched = new Set();
@@ -53,10 +59,9 @@ export function buildCoverageReport(options) {
     const counts = {
         eslint: 0,
         doctor: 0,
-        "docs-check": 0,
+        planned: 0,
         judgment: 0,
         permission: 0,
-        planned: 0,
     };
     const nextRequirements = [];
     const parsed = docs.flatMap((doc) => doc.requirements.map((requirement) => ({ doc: doc.doc, requirement })));
@@ -66,7 +71,7 @@ export function buildCoverageReport(options) {
             matched.add(requirement.hash);
             counts[recorded.kind] += 1;
             nextRequirements.push({ ...recorded, doc });
-            if (!isRefKnown(recorded, docsChecks)) {
+            if (!isRefKnown(recorded)) {
                 issues.push({
                     kind: "unknown-ref",
                     doc,
@@ -150,20 +155,11 @@ export function classifyRequirement(options) {
     if (input.kind === "eslint") {
         if (refs.length === 0)
             throw new Error('Kind "eslint" needs --ref naming the rule that reports it.');
-        const unknown = refs.filter((ref) => !pasikaRuleIds.includes(ref));
+        const unknown = refs.filter((ref) => !allPasikaRuleIds.includes(ref));
         if (unknown.length > 0) {
             throw new Error(`--ref ${unknown.map((ref) => `"${ref}"`).join(", ")} is not a rule in the plugin.`);
         }
     }
-    else if (input.kind === "docs-check") {
-        if (refs.length === 0)
-            throw new Error('Kind "docs-check" needs --ref naming the check that reports it.');
-        const known = new Set(DOCS_CHECKS);
-        const unknown = refs.filter((ref) => !known.has(ref));
-        if (unknown.length > 0) {
-            throw new Error(`--ref ${unknown.map((ref) => `"${ref}"`).join(", ")} is not a documentation check.`);
-        }
-    }
     else if (input.kind !== "doctor" && refs.length > 0) {
         throw new Error(`Kind "${input.kind}" takes no --ref, because nothing reports it.`);
     }

package/dist/enforcement/doctor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `pasika doctor` checks.
+ *
+ * Diagnoses gaps between a consumer repository and the pasika framework
+ * baseline. Scope: dependencies, configuration, managed files, and
+ * source structure. Code-level and path-level rules belong to ESLint.
+ */
+export interface DoctorFinding {
+    /** Which requirement this relates to. */
+    check: string;
+    /** Human-readable description. */
+    message: string;
+    /** Severity: error blocks adoption, warning is informational. */
+    severity: "error" | "warning";
+}
+export declare function runDoctor(cwd: string): DoctorFinding[];

package/dist/enforcement/doctor.js

@@ -0,0 +1,249 @@
+/**
+ * `pasika doctor` checks.
+ *
+ * Diagnoses gaps between a consumer repository and the pasika framework
+ * baseline. Scope: dependencies, configuration, managed files, and
+ * source structure. Code-level and path-level rules belong to ESLint.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+const packageJsonSchema = z.object({
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+});
+function readPackageJson(filePath) {
+    try {
+        const result = packageJsonSchema.safeParse(JSON.parse(fs.readFileSync(filePath, "utf8")));
+        if (result.success)
+            return result.data;
+    }
+    catch {
+        // missing or unparseable
+    }
+    return {};
+}
+/**
+ * Check that pasika and zirka are installed at compatible versions.
+ */
+function checkFrameworkPackages(pkg) {
+    const findings = [];
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!allDeps.pasika) {
+        findings.push({
+            check: "pasika-installed",
+            message: "pasika is not listed in package.json.",
+            severity: "error",
+        });
+    }
+    if (!allDeps.zirka) {
+        findings.push({
+            check: "zirka-installed",
+            message: "zirka is not listed in package.json.",
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that application source lives under src/.
+ */
+function checkSourceRoot(cwd) {
+    const findings = [];
+    const srcDir = path.join(cwd, "src");
+    if (!fs.existsSync(srcDir)) {
+        findings.push({
+            check: "source-under-src",
+            message: "Application source must live under src/.",
+            severity: "error",
+        });
+        return findings;
+    }
+    // Check for common non-src source directories at the project root
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    const suspicious = entries.filter((e) => e.isDirectory() &&
+        !e.name.startsWith(".") &&
+        e.name !== "src" &&
+        e.name !== "node_modules" &&
+        e.name !== "dist" &&
+        e.name !== "build" &&
+        e.name !== ".vulyk" &&
+        e.name !== "docs" &&
+        e.name !== "enforcement" &&
+        e.name !== "eslint" &&
+        e.name !== "cli" &&
+        e.name !== "__tests__" &&
+        e.name !== "test" &&
+        e.name !== "tests" &&
+        e.name !== "coverage" &&
+        e.name !== ".github" &&
+        e.name !== ".agents" &&
+        e.name !== ".husky" &&
+        e.name !== ".next" &&
+        e.name !== ".turbo" &&
+        e.name !== ".vercel" &&
+        e.name !== ".cache" &&
+        e.name !== ".tmp" &&
+        e.name !== "tmp" &&
+        e.name !== "public" &&
+        e.name !== "static" &&
+        e.name !== "assets" &&
+        e.name !== "bin" &&
+        e.name !== "vendor");
+    if (suspicious.length > 0) {
+        const names = suspicious.map((e) => e.name).join(", ");
+        findings.push({
+            check: "source-under-src",
+            message: `Possible source directories outside src/: ${names}.`,
+            severity: "warning",
+        });
+    }
+    return findings;
+}
+/**
+ * Find the global CSS file that registers Tailwind.
+ */
+function findGlobalStylesheet(cwd) {
+    const candidates = ["src/app/globals.css", "src/styles/globals.css", "src/globals.css"];
+    for (const candidate of candidates) {
+        const full = path.join(cwd, candidate);
+        if (fs.existsSync(full))
+            return full;
+    }
+    // Search for any CSS file containing @import "tailwindcss"
+    const srcDir = path.join(cwd, "src");
+    if (!fs.existsSync(srcDir))
+        return undefined;
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".next") {
+                const found = walk(full);
+                if (found)
+                    return found;
+            }
+            if (entry.isFile() && entry.name.endsWith(".css")) {
+                const content = fs.readFileSync(full, "utf8");
+                if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'")) {
+                    return full;
+                }
+            }
+        }
+        return undefined;
+    };
+    return walk(srcDir);
+}
+/**
+ * Check that the repository has a global stylesheet entry point that
+ * registers Tailwind. The stylesheet's contents are the ESLint CSS rules'
+ * concern, so doctor only checks that it exists.
+ */
+function checkGlobalStylesheet(cwd) {
+    const findings = [];
+    const stylesheet = findGlobalStylesheet(cwd);
+    if (!stylesheet) {
+        findings.push({
+            check: "global-stylesheet",
+            message: 'No global stylesheet found. Create src/app/globals.css with @import "tailwindcss".',
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that configuration files follow the pasika baseline.
+ *
+ * Repositories must take their lint, format, and TypeScript configuration
+ * from pasika and zirka rather than restating it locally.
+ */
+function checkConfigBaseline(cwd) {
+    const findings = [];
+    // eslint.config.ts must exist and reference zirka
+    const eslintConfigs = ["eslint.config.ts", "eslint.config.mjs", "eslint.config.js"];
+    const eslintConfig = eslintConfigs.find((name) => fs.existsSync(path.join(cwd, name)));
+    if (!eslintConfig) {
+        findings.push({
+            check: "config-baseline",
+            message: "No eslint config found. Create eslint.config.ts extending the pasika/zirka baseline.",
+            severity: "error",
+        });
+    }
+    else {
+        const content = fs.readFileSync(path.join(cwd, eslintConfig), "utf8");
+        if (!content.includes("zirka")) {
+            findings.push({
+                check: "config-baseline",
+                message: `eslint config does not reference zirka. Use the pasika/zirka baseline configuration.`,
+                severity: "warning",
+            });
+        }
+    }
+    // tsconfig.json must exist
+    if (!fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+        findings.push({
+            check: "config-baseline",
+            message: "No tsconfig.json found. Create one extending the pasika baseline.",
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that vulyk-managed files have not been hand-edited.
+ *
+ * Files listed in the .vulyk manifest are generated by vulyk commands
+ * and must not be edited directly.
+ */
+function checkManagedFiles(cwd) {
+    const findings = [];
+    const vulykDir = path.join(cwd, ".vulyk");
+    if (!fs.existsSync(vulykDir))
+        return findings;
+    const manifestPath = path.join(vulykDir, "manifest.json");
+    if (!fs.existsSync(manifestPath))
+        return findings;
+    try {
+        const manifestEntrySchema = z.looseObject({
+            targets: z.array(z.string()).optional(),
+        });
+        const manifestSchema = z.record(z.string(), manifestEntrySchema);
+        const result = manifestSchema.safeParse(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+        if (!result.success)
+            return findings;
+        for (const [, entry] of Object.entries(result.data)) {
+            const targets = entry.targets ?? [];
+            for (const target of targets) {
+                const targetPath = path.join(cwd, target);
+                if (fs.existsSync(targetPath)) {
+                    // File exists — check it hasn't been modified since vulyk last wrote it
+                    const stat = fs.statSync(targetPath);
+                    const vulykStat = fs.statSync(manifestPath);
+                    // If target is newer than the manifest, it was edited after vulyk wrote it
+                    if (stat.mtimeMs > vulykStat.mtimeMs + 1000) {
+                        findings.push({
+                            check: "managed-file-edit",
+                            message: `File "${target}" appears to have been edited after vulyk wrote it. Use vulyk commands to update managed files.`,
+                            severity: "warning",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // manifest unreadable
+    }
+    return findings;
+}
+export function runDoctor(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    const pkg = readPackageJson(pkgPath);
+    return [
+        ...checkFrameworkPackages(pkg),
+        ...checkConfigBaseline(cwd),
+        ...checkManagedFiles(cwd),
+        ...checkSourceRoot(cwd),
+        ...checkGlobalStylesheet(cwd),
+    ];
+}

package/dist/enforcement/types.d.ts

@@ -11,7 +11,6 @@ import { z } from "zod";
 export declare const enforcementKindSchema: z.ZodEnum<{
     eslint: "eslint";
     doctor: "doctor";
-    "docs-check": "docs-check";
     judgment: "judgment";
     permission: "permission";
     planned: "planned";
@@ -23,7 +22,6 @@ export declare const requirementSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         eslint: "eslint";
         doctor: "doctor";
-        "docs-check": "docs-check";
         judgment: "judgment";
         permission: "permission";
         planned: "planned";
@@ -39,7 +37,6 @@ export declare const registrySchema: z.ZodObject<{
         kind: z.ZodEnum<{
             eslint: "eslint";
             doctor: "doctor";
-            "docs-check": "docs-check";
             judgment: "judgment";
             permission: "permission";
             planned: "planned";

package/dist/enforcement/types.js

@@ -13,8 +13,6 @@ export const enforcementKindSchema = z.enum([
     "eslint",
     /** A `pasika doctor` check reports it. */
     "doctor",
-    /** A `pasika docs` check reports it. */
-    "docs-check",
     /** No mechanical check can decide it; a reviewer or agent applies it. */
     "judgment",
     /** The requirement grants permission, so there is nothing to check. */
@@ -31,8 +29,8 @@ export const requirementSchema = z.object({
     hash: z.string(),
     kind: enforcementKindSchema,
     /**
-     * Identifier of the check that covers this requirement: an ESLint rule id, a
-     * doctor check id, or a docs-check id. Several ids are comma-separated.
+     * Identifier of the check that covers this requirement: an ESLint rule id or
+     * a doctor check id. Several ids are comma-separated.
      * Absent for judgment and permission.
      */
     ref: z.string().optional(),
@@ -47,13 +45,6 @@ export const registrySchema = z.object({
     requirements: z.array(requirementSchema),
 });
 /** Every kind, in the order the coverage summary prints them. */
-export const ENFORCEMENT_KINDS = [
-    "eslint",
-    "doctor",
-    "docs-check",
-    "planned",
-    "judgment",
-    "permission",
-];
+export const ENFORCEMENT_KINDS = ["eslint", "doctor", "planned", "judgment", "permission"];
 /** The kinds that count as mechanically enforced today. */
-export const MECHANICAL_KINDS = ["eslint", "doctor", "docs-check"];
+export const MECHANICAL_KINDS = ["eslint", "doctor"];