pasika 0.3.9 → 0.4.1

package/README.md

@@ -48,9 +48,9 @@ Requirements are identified by a hash of their canonical text, not by a hand-wri
 
 The `text` field is the bullet as written in the document (markdown links and code spans intact), so it is greppable in the doc it came from; the `hash` is computed from the same text with links collapsed to their text and code spans unwrapped, so editing a URL or adding backticks does not read as a change.
 
-Every requirement carries a `note` explaining how it is met: what the ref'd rule or doctor check does and where it falls short, or — with no `ref` — how a reviewer or agent applies it by hand. When a rule governs the requirement's subject without fully deciding it (e.g. its placement), the `ref` still names that rule and the `note` says what stays judgment, so a partial check never reads as a complete one.
+Every requirement carries a `note` explaining how it is met: what the ref'd rule does and where it falls short, or — with no `ref` — how a reviewer or agent applies it by hand. When a rule governs the requirement's subject without fully deciding it (e.g. its placement), the `ref` still names that rule and the `note` says what stays judgment, so a partial check never reads as a complete one.
 
-`npm run coverage` fails when a requirement has no recorded answer, when its text changed, when it disappeared, when its `ref` names a rule or doctor check that does not exist, or when a requirement a rule governs has no test titled with its text. Confirm a reworded requirement with `npx tsx scripts/coverage.ts --accept`.
+`npm run coverage` fails when a requirement has no recorded answer, when its text changed, when it disappeared, when its `ref` names a rule that does not exist, or when a requirement a rule governs has no test titled with its text. Confirm a reworded requirement with `npx tsx scripts/coverage.ts --accept`.
 
 ## Commands
 
@@ -79,38 +79,40 @@ npx tsx scripts/coverage.ts --classify d311a1457a --ref pasika/import-boundaries
 npx tsx scripts/coverage.ts --classify 041b665bd7 --note "no check can compare against the previous state"
 ```
 
-The script refuses a hash no requirement has, a `ref` naming a rule or doctor check that does not exist, and a classification without a note — so a mismatch cannot reach the registry by hand. Re-running it on an already-recorded requirement replaces the earlier entry. All of it reads and writes `scripts/registry.json`.
+The script refuses a hash no requirement has, a `ref` naming a rule that does not exist, and a classification without a note — so a mismatch cannot reach the registry by hand. Re-running it on an already-recorded requirement replaces the earlier entry. All of it reads and writes `scripts/registry.json`.
 
 ## ESLint ruleset
 
 ### With Zirka (recommended)
 
 ```ts
-// eslint.config.ts
+// eslint.config.ts — Next.js application
 import { RuleSeverity, styleguide } from "zirka";
 
 const { eslintConfig } = styleguide({
   next: RuleSeverity.Error,
   node: RuleSeverity.Error,
   typescript: RuleSeverity.Error,
-  pasika: RuleSeverity.Error,
+  pasikaNextjsApp: RuleSeverity.Error,
 });
 
 export default eslintConfig;
 ```
 
-`zirka` composes the full pasika ruleset over four file scopes: TS/TSX under `src/**`, `globals.css` and other stylesheets, `package.json`, and markdown — each with its own ESLint language.
+For a plain TypeScript repository, enable `pasikaTypescriptApp` instead of `pasikaNextjsApp`. `zirka` composes the pasika ruleset over four file scopes: TS/TSX under `src/**`, `globals.css` and other stylesheets, `package.json`, and markdown — each with its own ESLint language.
 
 ### Without Zirka
 
-````ts
-// eslint.config.ts
-import { pasikaNext } from "pasika/eslint";
+```ts
+// eslint.config.ts — plain TypeScript repository
+import { typescriptApp } from "pasika/eslint";
+
+export default typescriptApp;
+```
 
-export default pasikaNext;
-``` `pasikaNext` is the full flat-config array: the `src/**` TS/TSX and Tailwind stylesheet blocks plus everything in `pasikaRepo`. `pasikaRepo` is the repository-level preset — every block that does not touch `src/**` (the package.json manifest, husky hooks, and docs) — and is a strict subset of `pasikaNext`. The granular rule objects (`tailwindRules`, `repoPackageJsonRules`, `documentationRules`) stay exported for manual wiring.
+`typescriptApp` is the plain-TypeScript-repository preset — the package.json manifest, the zirka configuration contract, the `src/**` TypeScript app source, and the docs. `nextjsApp` is the full framework preset: everything in `typescriptApp` plus the Next.js-stack manifest requirement, the Next.js app source rules, and the Tailwind stylesheet blocks. The granular rule objects (`tailwindRules`, `repoPackageJsonRules`, `documentationRules`) stay exported for manual wiring.
 
-Because the preset blocks wire ESLint's language plugins, using `pasikaNext` directly (without `zirka`) requires `@eslint/css`, `@eslint/json`, and `@eslint/markdown` to be installed in the consuming project — they are `peerDependencies` of `pasika`. A `zirka`-based setup gets them automatically.
+Because the preset blocks wire ESLint's language plugins, using them directly (without `zirka`) requires `@eslint/css`, `@eslint/json`, and `@eslint/markdown` to be installed in the consuming project — they are `peerDependencies` of `pasika`. A `zirka`-based setup gets them automatically.
 
 ### TS/TSX rules
 
@@ -153,7 +155,7 @@ Because the preset blocks wire ESLint's language plugins, using `pasikaNext` dir
 | `pasika/shared-style-dedup` †      | A className combo used by two or more components becomes a named utility                                            |
 | `pasika/repeated-structure`        | A block of elements repeated two or more times is extracted as a named component                                    |
 | `pasika/sole-state-owner`          | A contiguous JSX part that is the sole consumer of a useState hook is extracted into a named component              |
-| `pasika/config-baseline`           | `eslint.config.*` references zirka and `tsconfig.json` exists                                                       |
+| `pasika/zirka-baseline`            | eslint, prettier, and TypeScript configuration come from zirka instead of being restated locally                    |
 | `pasika/zod-schema-validation`     | Runtime validation through Zod schemas, not hand-written type guards                                                |
 | `pasika/source-under-src`          | Application source lives under `src/`, not in root-level folders                                                    |
 
@@ -176,17 +178,18 @@ Applied to `src/**/globals.css` (and other stylesheets) through `@eslint/css` wi
 
 ### Package.json rules
 
-Applied to `package.json` through `@eslint/json`. The framework-agnostic subset (`no-vulyk-dependency`, `exact-version`) applies to any repository, including pasika itself; `nextjs-stack` applies to a Next.js/React application.
+Applied to `package.json` through `@eslint/json`. The framework-agnostic subset (`no-vulyk-dependency`, `exact-version`) applies to any repository, including pasika itself; `nextjs-stack` applies to a Next.js/React application, and `vulyk-docs` to a repository adopting the framework.
 
 | Rule                         | Enforces                                                                            |
 | ---------------------------- | ----------------------------------------------------------------------------------- |
 | `pasika/no-vulyk-dependency` | `vulyk` is not in `dependencies`                                                    |
 | `pasika/exact-version`       | Dependency and devDependency versions are pinned exactly, never ranges              |
 | `pasika/nextjs-stack`        | All Tech Stack Reference packages are listed in `package.json` (Next.js/React apps) |
+| `pasika/vulyk-docs`          | `vulyk.config.ts` tracks the framework's docs from pasika and `AGENTS.md` exists    |
 
 ### Documentation rules
 
-The `pasika/*` markdown rules enforce the documentation guide over `docs/**/*.md` (24 rules): file-name suffixes and titles, overview presence and length, guide step structure, Incorrect/Correct pairing, policy document shape, reference block headings, RFC 2119 placement, template hygiene, link anchoring, and glossary-term linking. They run through `@eslint/markdown`; `npm run coverage` verifies each has a test and a registry entry. Pasika's own `docs/` are linted by them in CI (`npm run lint`).
+The `pasika/*` markdown rules enforce the documentation guide over `docs/**/*.md` (22 rules): file-name suffixes and titles, overview shape (presence, sentence count, links), guide step structure, Incorrect/Correct pairing, policy document shape, reference block headings, RFC 2119 placement, template hygiene, link anchoring, and glossary-term linking. They run through `@eslint/markdown`; `npm run coverage` verifies each has a test and a registry entry. Pasika's own `docs/` are linted by them in CI (`npm run lint`).
 
 Run `npx tsx scripts/coverage.ts --json` for the exact requirement each rule covers.
 
@@ -211,4 +214,4 @@ npm run typecheck
 npm run test
 npm run coverage
 npm run build
-````
+```

package/dist/eslint/pasika/index.d.ts

@@ -1,9 +1,9 @@
-import * as eslint from 'eslint';
-import { Rule, Linter } from 'eslint';
-import * as ESTree from 'estree';
 import * as _eslint_markdown from '@eslint/markdown';
 import * as _eslint_css from '@eslint/css';
 import * as _eslint_json from '@eslint/json';
+import * as eslint from 'eslint';
+import { Rule, Linter } from 'eslint';
+import * as ESTree from 'estree';
 
 /**
  * Local AST node types for the parser-specific shapes ESLint's ESTree types
@@ -77,9 +77,7 @@ type JsxOpeningElementNode = Rule.Node & {
 declare const documentationRules: {
     "doc-kind-suffix": _eslint_markdown.MarkdownRuleDefinition;
     "title-matches-file-name": _eslint_markdown.MarkdownRuleDefinition;
-    "overview-present": _eslint_markdown.MarkdownRuleDefinition;
-    "overview-length": _eslint_markdown.MarkdownRuleDefinition;
-    "guide-overview-no-links": _eslint_markdown.MarkdownRuleDefinition;
+    overview: _eslint_markdown.MarkdownRuleDefinition;
     "guide-step-single-sentence": _eslint_markdown.MarkdownRuleDefinition;
     "guide-step-single-link": _eslint_markdown.MarkdownRuleDefinition;
     "guide-states-no-requirement": _eslint_markdown.MarkdownRuleDefinition;
@@ -99,6 +97,7 @@ declare const documentationRules: {
     "guide-link-anchors": _eslint_markdown.MarkdownRuleDefinition;
     "no-nested-how-to": _eslint_markdown.MarkdownRuleDefinition;
     "glossary-term-linking": _eslint_markdown.MarkdownRuleDefinition;
+    "guide-mentions-documents": _eslint_markdown.MarkdownRuleDefinition;
 };
 
 declare const tailwindRules: {
@@ -129,7 +128,11 @@ declare const huskyRules: {
     "husky-hook": _eslint_json.JSONRuleDefinition;
 };
 
-/** Every source rule, merged so the Next preset applies them all. */
+declare const vulykRules: {
+    "vulyk-docs": _eslint_json.JSONRuleDefinition;
+};
+
+/** Every source rule, merged so the Next.js preset applies them all. */
 declare const pasikaRules: {
     "component-placement": eslint.Rule.RuleModule;
     "application-structure": eslint.Rule.RuleModule;
@@ -182,23 +185,126 @@ declare const pasikaRules: {
     "type-extraction": eslint.Rule.RuleModule;
     "zod-schema-validation": eslint.Rule.RuleModule;
     "source-under-src": eslint.Rule.RuleModule;
-    "config-baseline": eslint.Rule.RuleModule;
+    "zirka-baseline": eslint.Rule.RuleModule;
 };
 
+/**
+ * One plugin object every preset block references. ESLint only permits a
+ * plugin name to be redefined across configs when the value is the same
+ * object reference, and several blocks share file scopes (`src/**`, the
+ * manifest, `globals.css`), so a per-block plugin object would collide when
+ * the blocks merge.
+ */
+declare const pasikaPlugin: {
+    rules: {
+        "vulyk-docs": _eslint_json.JSONRuleDefinition;
+        "husky-hook": _eslint_json.JSONRuleDefinition;
+        "nextjs-stack": _eslint_json.JSONRuleDefinition;
+        "no-vulyk-dependency": _eslint_json.JSONRuleDefinition;
+        "exact-version": _eslint_json.JSONRuleDefinition;
+        "theme-reset": _eslint_css.CSSRuleDefinition;
+        "root-variables": _eslint_css.CSSRuleDefinition;
+        "apply-usage": _eslint_css.CSSRuleDefinition;
+        "base-layer-pair": _eslint_css.CSSRuleDefinition;
+        "stylesheet-ordering": _eslint_css.CSSRuleDefinition;
+        "css-variable-naming": _eslint_css.CSSRuleDefinition;
+        "custom-utility-apply": _eslint_css.CSSRuleDefinition;
+        "surface-utility": _eslint_css.CSSRuleDefinition;
+        "theme-variable-namespace": _eslint_css.CSSRuleDefinition;
+        "global-css-location": _eslint_css.CSSRuleDefinition;
+        "global-stylesheet": _eslint_css.CSSRuleDefinition;
+        "doc-kind-suffix": _eslint_markdown.MarkdownRuleDefinition;
+        "title-matches-file-name": _eslint_markdown.MarkdownRuleDefinition;
+        overview: _eslint_markdown.MarkdownRuleDefinition;
+        "guide-step-single-sentence": _eslint_markdown.MarkdownRuleDefinition;
+        "guide-step-single-link": _eslint_markdown.MarkdownRuleDefinition;
+        "guide-states-no-requirement": _eslint_markdown.MarkdownRuleDefinition;
+        "requirement-present": _eslint_markdown.MarkdownRuleDefinition;
+        "rule-paired-examples": _eslint_markdown.MarkdownRuleDefinition;
+        "example-heading-description": _eslint_markdown.MarkdownRuleDefinition;
+        "policy-no-examples": _eslint_markdown.MarkdownRuleDefinition;
+        "no-cross-document-link": _eslint_markdown.MarkdownRuleDefinition;
+        "reference-no-rfc-vocabulary": _eslint_markdown.MarkdownRuleDefinition;
+        "reference-block-headings": _eslint_markdown.MarkdownRuleDefinition;
+        "support-document-placement": _eslint_markdown.MarkdownRuleDefinition;
+        "no-template-prompt": _eslint_markdown.MarkdownRuleDefinition;
+        "guide-folder-entry-point": _eslint_markdown.MarkdownRuleDefinition;
+        "rfc-only-in-bullets": _eslint_markdown.MarkdownRuleDefinition;
+        "rfc-keyword-in-every-bullet": _eslint_markdown.MarkdownRuleDefinition;
+        "policy-subject-headings": _eslint_markdown.MarkdownRuleDefinition;
+        "guide-link-anchors": _eslint_markdown.MarkdownRuleDefinition;
+        "no-nested-how-to": _eslint_markdown.MarkdownRuleDefinition;
+        "glossary-term-linking": _eslint_markdown.MarkdownRuleDefinition;
+        "guide-mentions-documents": _eslint_markdown.MarkdownRuleDefinition;
+        "component-placement": eslint.Rule.RuleModule;
+        "application-structure": eslint.Rule.RuleModule;
+        "data-testid-case": eslint.Rule.RuleModule;
+        "jsx-hygiene": eslint.Rule.RuleModule;
+        "interactive-component": eslint.Rule.RuleModule;
+        "ui-state": eslint.Rule.RuleModule;
+        "no-mixed-concerns": eslint.Rule.RuleModule;
+        "no-arbitrary-tailwind": eslint.Rule.RuleModule;
+        "enforce-cn-merge": {
+            meta: {
+                schema: never[];
+                type: "problem";
+                docs: {
+                    description: string;
+                };
+            };
+            create(context: eslint.Rule.RuleContext): {
+                JSXAttribute(node: JsxAttributeNode): void;
+            };
+        };
+        "cn-helper": eslint.Rule.RuleModule;
+        "enforce-cva-variant-props": eslint.Rule.RuleModule;
+        "cva-appearance-props": eslint.Rule.RuleModule;
+        "cva-boolean-variants": eslint.Rule.RuleModule;
+        "cross-feature-import": eslint.Rule.RuleModule;
+        "pure-function-extract": eslint.Rule.RuleModule;
+        "hook-complexity": eslint.Rule.RuleModule;
+        "locale-dotted-path": eslint.Rule.RuleModule;
+        "locales-location": eslint.Rule.RuleModule;
+        "hook-extraction": eslint.Rule.RuleModule;
+        "component-nesting": eslint.Rule.RuleModule;
+        "stay-flat": eslint.Rule.RuleModule;
+        "locale-placement": eslint.Rule.RuleModule;
+        "sole-state-owner": eslint.Rule.RuleModule;
+        "locale-key-shape": eslint.Rule.RuleModule;
+        "shared-style-dedup": eslint.Rule.RuleModule;
+        "repeated-structure": eslint.Rule.RuleModule;
+        "filename-case": eslint.Rule.RuleModule;
+        "import-boundaries": eslint.Rule.RuleModule;
+        "named-exports": eslint.Rule.RuleModule;
+        "support-file-placement": eslint.Rule.RuleModule;
+        "support-folder-shape": eslint.Rule.RuleModule;
+        "import-through-index": eslint.Rule.RuleModule;
+        "util-file-name": eslint.Rule.RuleModule;
+        "no-util-barrel": eslint.Rule.RuleModule;
+        "enforce-barrel-exports": eslint.Rule.RuleModule;
+        "config-extraction": eslint.Rule.RuleModule;
+        "value-extraction": eslint.Rule.RuleModule;
+        "type-extraction": eslint.Rule.RuleModule;
+        "zod-schema-validation": eslint.Rule.RuleModule;
+        "source-under-src": eslint.Rule.RuleModule;
+        "zirka-baseline": eslint.Rule.RuleModule;
+    };
+};
 /** Every rule id, as they appear in configuration and in lint output. */
 declare const allPasikaRuleIds: string[];
 /**
- * Repository-level preset: every block that does NOT touch `src/**` — the
- * package.json manifest (including husky hook requirements) and the
- * documentation-guide markdown rules. This governs the repository itself,
- * independent of any application source.
+ * TypeScript app preset: the framework-agnostic baseline — the package.json
+ * manifest (incl. husky hook and vulyk requirements), the zirka configuration
+ * contract, the `src/**` TS/TSX source, and the documentation markdown rules.
+ * Use this for a plain TypeScript repository.
  */
-declare const pasikaRepo: Linter.Config[];
+declare const typescriptApp: Linter.Config[];
 /**
- * Framework-wide preset: the full adopted-to-the-framework stack. Anything in
- * `pasikaRepo` plus the `src/**` blocks — TS/TSX source rules and the Tailwind
- * stylesheet rules. `pasikaRepo` is a strict subset of `pasikaNext`.
+ * Next.js app preset: the full adopted-to-the-framework stack. Anything in
+ * `typescriptApp` plus the framework-only blocks — the Next.js-stack manifest
+ * requirement, the Next.js app source rules, and the Tailwind stylesheet
+ * rules. `typescriptApp` is a strict subset of `nextjsApp`.
  */
-declare const pasikaNext: Linter.Config[];
+declare const nextjsApp: Linter.Config[];
 
-export { allPasikaRuleIds, documentationRules, huskyRules, nextPackageJsonRules, pasikaNext, pasikaRepo, pasikaRules, repoPackageJsonRules, tailwindRules };
+export { allPasikaRuleIds, documentationRules, huskyRules, nextPackageJsonRules, nextjsApp, pasikaPlugin, pasikaRules, repoPackageJsonRules, tailwindRules, typescriptApp, vulykRules };

package/dist/eslint/pasika/index.js

@@ -3266,43 +3266,88 @@ var sourceUnderSrcRule = {
   }
 };
 
-// eslint/rules/config-baseline.ts
+// eslint/rules/zirka-baseline.ts
 import fs4 from "fs";
 import path33 from "path";
-var configBaselineRule = {
+var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
+var PRETTIER_CONFIGS = [
+  "prettier.config.mjs",
+  "prettier.config.cjs",
+  "prettier.config.js",
+  "prettier.config.ts",
+  "prettier.config.mts",
+  "prettier.config.cts"
+];
+var zirkaBaselineRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require eslint config to reference zirka and tsconfig.json to exist."
+      description: "Require eslint, prettier, and TypeScript configuration to come from zirka."
     }
   },
   create(context) {
     const filename = path33.resolve(context.filename);
     const basename = path33.basename(filename);
-    if (!/^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/.test(basename)) return {};
+    if (!ESLINT_CONFIG.test(basename)) return {};
+    const projectRoot = path33.dirname(filename);
+    const report3 = (message) => {
+      context.report({
+        node: context.sourceCode.ast,
+        loc: { line: 1, column: 0 },
+        message
+      });
+    };
     return {
-      Program(node) {
-        const content = context.sourceCode.getText();
-        if (!content.includes("zirka")) {
-          context.report({
-            node,
-            loc: { line: 1, column: 0 },
-            message: "ESLint config must reference zirka. Use the pasika/zirka baseline configuration."
-          });
+      Program() {
+        if (!referencesZirka(context.sourceCode)) {
+          report3(
+            'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
+          );
         }
-        const projectRoot = path33.dirname(filename);
-        if (!fs4.existsSync(path33.join(projectRoot, "tsconfig.json"))) {
-          context.report({
-            node,
-            loc: { line: 1, column: 0 },
-            message: "No tsconfig.json found. Create one extending the pasika baseline."
-          });
+        const tsconfigPath = path33.join(projectRoot, "tsconfig.json");
+        if (!fs4.existsSync(tsconfigPath)) {
+          report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
+        } else {
+          let extendsValue;
+          try {
+            const parsed = JSON.parse(fs4.readFileSync(tsconfigPath, "utf8"));
+            extendsValue = typeof parsed === "object" && parsed !== null && "extends" in parsed ? parsed.extends : void 0;
+          } catch {
+            report3(
+              'tsconfig.json must be valid JSON and extend the zirka TypeScript base config ("zirka/typescript").'
+            );
+            return;
+          }
+          if (typeof extendsValue !== "string" || !extendsValue.startsWith("zirka")) {
+            report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
+          }
+        }
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs4.existsSync(path33.join(projectRoot, name)));
+        if (!prettierConfigFile) {
+          report3(
+            "No prettier config found. Create one that takes its configuration from zirka (styleguide({ prettier: true }).prettierConfig)."
+          );
+        } else {
+          const content = fs4.readFileSync(path33.join(projectRoot, prettierConfigFile), "utf8");
+          if (!content.includes("zirka")) {
+            report3(
+              "The prettier config must take its configuration from zirka (styleguide({ prettier: true }).prettierConfig) instead of restating it locally."
+            );
+          }
         }
       }
     };
   }
 };
+function referencesZirka(sourceCode) {
+  for (const statement of sourceCode.ast.body) {
+    if (statement.type === "ImportDeclaration" && typeof statement.source.value === "string" && statement.source.value.startsWith("zirka")) {
+      return true;
+    }
+  }
+  return /require\(\s*["']zirka["']\s*\)/.test(sourceCode.getText());
+}
 
 // constants/rfc2119.ts
 var RFC_2119_KEYWORDS = ["MUST NOT", "MUST", "SHOULD NOT", "SHOULD", "MAY"];
@@ -3391,90 +3436,10 @@ var titleMatchesFileNameRule = {
   }
 };
 
-// eslint/rules/documentation/overview-present.ts
-var overviewPresentRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Overview must follow the title in a documentation file.",
-      recommended: true
-    }
-  },
-  create(context) {
-    return {
-      root(node) {
-        const filename = getFilename(context);
-        if (!filename.endsWith(".md")) return;
-        let titleLine = 0;
-        for (const child of node.children) {
-          if (child.type === "heading" && child.depth === 1) {
-            titleLine = getLine(child);
-            break;
-          }
-        }
-        if (!titleLine) return;
-        let hasOverview = false;
-        for (const child of node.children) {
-          if (child.type === "paragraph" && getLine(child) > titleLine && getTextContent(child).trim()) {
-            hasOverview = true;
-            break;
-          }
-        }
-        if (!hasOverview) {
-          context.report({
-            node,
-            message: "no overview follows the title"
-          });
-        }
-      }
-    };
-  }
-};
-
-// eslint/rules/documentation/overview-length.ts
+// eslint/rules/documentation/overview.ts
 function countSentences(text) {
   return text.split(/[.!?](?:\s+|$)/).filter((part) => part.trim() !== "").length;
 }
-var overviewLengthRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Overview must contain at most two sentences.",
-      recommended: true
-    }
-  },
-  create(context) {
-    return {
-      root(node) {
-        const filename = getFilename(context);
-        if (!filename.endsWith(".md")) return;
-        let titleLine = 0;
-        for (const child of node.children) {
-          if (child.type === "heading" && child.depth === 1) {
-            titleLine = getLine(child);
-            break;
-          }
-        }
-        if (!titleLine) return;
-        for (const child of node.children) {
-          if (child.type !== "paragraph" || getLine(child) <= titleLine) continue;
-          const text = getTextContent(child).trim();
-          if (!text || text.startsWith("#")) continue;
-          const sentenceCount = countSentences(text);
-          if (sentenceCount > 2) {
-            context.report({
-              node: child,
-              message: `overview uses ${String(sentenceCount)} sentences, at most two are allowed`
-            });
-          }
-          break;
-        }
-      }
-    };
-  }
-};
-
-// eslint/rules/documentation/guide-overview-no-links.ts
 function containsLink(node) {
   if (node.type === "link") return true;
   if ("children" in node) {
@@ -3482,11 +3447,11 @@ function containsLink(node) {
   }
   return false;
 }
-var guideOverviewNoLinksRule = {
+var overviewRule = {
   meta: {
     type: "problem",
     docs: {
-      description: "Guide overview must not link to other documents.",
+      description: "Overview must exist, contain at most two sentences, and not link to other documents.",
       recommended: true
     }
   },
@@ -3494,7 +3459,7 @@ var guideOverviewNoLinksRule = {
     return {
       root(node) {
         const filename = getFilename(context);
-        if (!filename.endsWith("-guide.md")) return;
+        if (!filename.endsWith(".md")) return;
         let titleLine = 0;
         for (const child of node.children) {
           if (child.type === "heading" && child.depth === 1) {
@@ -3503,17 +3468,31 @@ var guideOverviewNoLinksRule = {
           }
         }
         if (!titleLine) return;
+        let sentenceCount = 0;
+        let found = false;
         for (const child of node.children) {
+          if (child.type === "heading" && getLine(child) > titleLine) break;
           if (child.type !== "paragraph" || getLine(child) <= titleLine) continue;
           const text = getTextContent(child).trim();
           if (!text || text.startsWith("#")) continue;
+          found = true;
           if (containsLink(child)) {
             context.report({
               node: child,
-              message: "guide overview links another document"
+              message: "overview links another document"
             });
           }
-          break;
+          sentenceCount += countSentences(text);
+          if (sentenceCount > 2) {
+            context.report({
+              node: child,
+              message: `overview uses ${String(sentenceCount)} sentences, at most two are allowed`
+            });
+            break;
+          }
+        }
+        if (!found) {
+          context.report({ node, message: "no overview follows the title" });
         }
       }
     };
@@ -4288,13 +4267,91 @@ var glossaryTermLinkingRule = {
   }
 };
 
+// eslint/rules/documentation/guide-mentions-documents.ts
+import { existsSync } from "fs";
+import path39 from "path";
+function visitSteps3(node, check) {
+  if (node.type === "list" && node.ordered) {
+    for (const child of node.children) check(child);
+  }
+  if ("children" in node) {
+    for (const child of node.children) visitSteps3(child, check);
+  }
+}
+function collectMarkdownLinks(node, out) {
+  if (node.type === "link" && node.url.endsWith(".md")) out.push(node);
+  if ("children" in node) {
+    for (const child of node.children) collectMarkdownLinks(child, out);
+  }
+}
+function linkTarget(url) {
+  return url.split("#")[0] ?? url;
+}
+var guideMentionsDocumentsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A Guide entry point must reference each owned Rule from a How To step, mention every Reference, and not link a missing document.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        const docsRoot = findDocsRoot(filename);
+        if (!docsRoot) return;
+        const guideDir = path39.dirname(filename);
+        if (path39.basename(filename, ".md") !== path39.basename(guideDir)) return;
+        const docs = getProjectDocs(docsRoot);
+        const owned = docs.filter((doc) => {
+          const parent = path39.dirname(doc.filePath);
+          return parent === path39.join(guideDir, "rules") || parent === path39.join(guideDir, "references");
+        });
+        const allLinks = [];
+        collectMarkdownLinks(node, allLinks);
+        const stepLinks = [];
+        visitSteps3(node, (item) => {
+          collectMarkdownLinks(item, stepLinks);
+        });
+        const mentionsOf = (links, fileName) => links.some((link) => link.url.split("/").pop() === fileName);
+        for (const doc of owned) {
+          if (doc.kind === "rule") {
+            if (!mentionsOf(stepLinks, doc.fileName)) {
+              context.report({
+                node,
+                message: `Guide entry point does not reference a Rule it owns from a How To step: ${doc.doc}`
+              });
+            }
+          } else if (!mentionsOf(allLinks, doc.fileName)) {
+            context.report({
+              node,
+              message: `Guide entry point does not mention a document it owns: ${doc.doc}`
+            });
+          }
+        }
+        for (const link of allLinks) {
+          const target = linkTarget(link.url);
+          if (!target.endsWith(".md")) continue;
+          const resolved = path39.normalize(path39.join(guideDir, target));
+          if (!existsSync(resolved)) {
+            context.report({
+              node: link,
+              message: `Guide links a document that does not exist: ${link.url}`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/documentation/index.ts
 var documentationRules = {
   "doc-kind-suffix": docKindSuffixRule,
   "title-matches-file-name": titleMatchesFileNameRule,
-  "overview-present": overviewPresentRule,
-  "overview-length": overviewLengthRule,
-  "guide-overview-no-links": guideOverviewNoLinksRule,
+  overview: overviewRule,
   "guide-step-single-sentence": guideStepSingleSentenceRule,
   "guide-step-single-link": guideStepSingleLinkRule,
   "guide-states-no-requirement": guideStatesNoRequirementRule,
@@ -4313,7 +4370,8 @@ var documentationRules = {
   "policy-subject-headings": policySubjectHeadingsRule,
   "guide-link-anchors": guideLinkAnchorsRule,
   "no-nested-how-to": noNestedHowToRule,
-  "glossary-term-linking": glossaryTermLinkingRule
+  "glossary-term-linking": glossaryTermLinkingRule,
+  "guide-mentions-documents": guideMentionsDocumentsRule
 };
 
 // eslint/rules/tailwind/helpers.ts
@@ -4940,8 +4998,8 @@ var nextPackageJsonRules = {
 };
 
 // eslint/rules/husky/husky-hook.ts
-import { existsSync, readFileSync as readFileSync6 } from "fs";
-import path39 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync6 } from "fs";
+import path40 from "path";
 function memberName4(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -4960,8 +5018,8 @@ var huskyHookRule = {
         if (root.type !== "Object") return;
         const scriptName = context.filename;
         if (!scriptName.endsWith("package.json")) return;
-        const hookPath = path39.join(process.cwd(), ".husky", "pre-commit");
-        if (!existsSync(hookPath)) {
+        const hookPath = path40.join(process.cwd(), ".husky", "pre-commit");
+        if (!existsSync2(hookPath)) {
           context.report({
             node,
             message: "No .husky/pre-commit hook found. Configure husky to run checks before commits."
@@ -4998,8 +5056,57 @@ var huskyRules = {
   "husky-hook": huskyHookRule
 };
 
+// eslint/rules/vulyk/vulyk-docs.ts
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+import path41 from "path";
+var PASIKA_REPO = "Bredansky/pasika";
+var vulykDocsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require vulyk.config.ts to track the framework's docs from pasika and the generated AGENTS.md."
+    }
+  },
+  create(context) {
+    return {
+      Document(node) {
+        if (!context.filename.endsWith("package.json")) return;
+        const projectRoot = path41.dirname(path41.resolve(context.filename));
+        const configPath = path41.join(projectRoot, "vulyk.config.ts");
+        if (!existsSync3(configPath)) {
+          context.report({
+            node,
+            message: "No vulyk.config.ts found. Run npx vulyk@latest init to create one that tracks the framework's docs."
+          });
+          return;
+        }
+        const config = readFileSync7(configPath, "utf8");
+        if (!config.includes(PASIKA_REPO)) {
+          context.report({
+            node,
+            message: "vulyk.config.ts must track the framework's docs from the pasika repository."
+          });
+        }
+        const agentsPath = path41.join(projectRoot, "AGENTS.md");
+        if (!existsSync3(agentsPath)) {
+          context.report({
+            node,
+            message: "No AGENTS.md found. Run npx vulyk@latest agents to generate the agent file that routes to the tracked docs."
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/rules/vulyk/index.ts
+var vulykRules = {
+  "vulyk-docs": vulykDocsRule
+};
+
 // eslint/index.ts
-var repoSourceRules = {
+var typescriptAppRules = {
   "filename-case": filenameCaseRule,
   "import-boundaries": importBoundariesRule,
   "named-exports": namedExportsRule,
@@ -5014,9 +5121,9 @@ var repoSourceRules = {
   "type-extraction": typeExtractionRule,
   "zod-schema-validation": zodSchemaValidationRule,
   "source-under-src": sourceUnderSrcRule,
-  "config-baseline": configBaselineRule
+  "zirka-baseline": zirkaBaselineRule
 };
-var nextSourceRules = {
+var nextjsAppRules = {
   "component-placement": componentPlacementRule,
   "application-structure": applicationStructureRule,
   "data-testid-case": dataTestIdCaseRule,
@@ -5045,38 +5152,61 @@ var nextSourceRules = {
   "repeated-structure": repeatedStructureRule
 };
 var pasikaRules = {
-  ...repoSourceRules,
-  ...nextSourceRules
+  ...typescriptAppRules,
+  ...nextjsAppRules
 };
+var pasikaPlugin = {
+  rules: {
+    ...pasikaRules,
+    ...documentationRules,
+    ...tailwindRules,
+    ...repoPackageJsonRules,
+    ...nextPackageJsonRules,
+    ...huskyRules,
+    ...vulykRules
+  }
+};
+var jsonLanguagePlugin = { languages: { json: jsonPlugin.languages.json } };
 function ruleIds(rules2) {
   return Object.keys(rules2).map((name) => `pasika/${name}`);
 }
+var typescriptAppRuleIds = ruleIds(typescriptAppRules);
+var nextjsAppRuleIds = ruleIds(nextjsAppRules);
 var pasikaRuleIds = ruleIds(pasikaRules);
 var documentationRuleIds = ruleIds(documentationRules);
 var tailwindRuleIds = ruleIds(tailwindRules);
 var repoPackageJsonRuleIds = ruleIds(repoPackageJsonRules);
 var nextPackageJsonRuleIds = ruleIds(nextPackageJsonRules);
 var huskyRuleIds = ruleIds(huskyRules);
+var vulykRuleIds = ruleIds(vulykRules);
 var allPasikaRuleIds = [
   ...pasikaRuleIds,
   ...documentationRuleIds,
   ...tailwindRuleIds,
   ...repoPackageJsonRuleIds,
   ...nextPackageJsonRuleIds,
-  ...huskyRuleIds
+  ...huskyRuleIds,
+  ...vulykRuleIds
 ];
-var nextAppBlock = {
+var typescriptAppBlock = {
+  files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
+  plugins: {
+    pasika: pasikaPlugin
+  },
+  rules: Object.fromEntries(typescriptAppRuleIds.map((id) => [id, "error"]))
+};
+var nextjsAppBlock = {
   files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
   plugins: {
-    pasika: { rules: pasikaRules }
+    pasika: pasikaPlugin
   },
-  rules: Object.fromEntries(pasikaRuleIds.map((id) => [id, "error"]))
+  rules: Object.fromEntries(nextjsAppRuleIds.map((id) => [id, "error"]))
 };
 var tailwindGlobalsBlock = {
   files: ["src/**/globals.css"],
   plugins: {
     css,
-    pasika: { rules: tailwindRules }
+    pasika: pasikaPlugin
   },
   language: "css/css",
   languageOptions: { tolerant: true },
@@ -5088,43 +5218,63 @@ var tailwindAnyCssBlock = {
   files: ["src/**/*.css"],
   plugins: {
     css,
-    pasika: { rules: tailwindRules }
+    pasika: pasikaPlugin
   },
   language: "css/css",
   languageOptions: { tolerant: true },
   rules: { "pasika/global-css-location": "error" }
 };
-var manifestBlock = {
+var repoManifestBlock = {
   files: ["package.json"],
   plugins: {
-    json: { languages: { json: jsonPlugin.languages.json } },
-    pasika: { rules: { ...repoPackageJsonRules, ...nextPackageJsonRules, ...huskyRules } }
+    json: jsonLanguagePlugin,
+    pasika: pasikaPlugin
   },
   language: "json/json",
-  rules: Object.fromEntries(
-    [...repoPackageJsonRuleIds, ...nextPackageJsonRuleIds, ...huskyRuleIds].map((id) => [id, "error"])
-  )
+  rules: Object.fromEntries([...repoPackageJsonRuleIds, ...huskyRuleIds, ...vulykRuleIds].map((id) => [id, "error"]))
+};
+var nextManifestBlock = {
+  files: ["package.json"],
+  plugins: {
+    json: jsonLanguagePlugin,
+    pasika: pasikaPlugin
+  },
+  language: "json/json",
+  rules: Object.fromEntries(nextPackageJsonRuleIds.map((id) => [id, "error"]))
+};
+var zirkaBlock = {
+  files: ["eslint.config.{ts,mts,cts,js,mjs,cjs}"],
+  plugins: { pasika: pasikaPlugin },
+  rules: { "pasika/zirka-baseline": "error" }
 };
 var docsBlock = {
   files: ["docs/**/*.md"],
   ignores: ["**/_*/**"],
   plugins: {
     markdown,
-    pasika: { rules: documentationRules }
+    pasika: pasikaPlugin
   },
   language: "markdown/gfm",
   rules: Object.fromEntries(documentationRuleIds.map((id) => [id, "error"]))
 };
-var pasikaRepo = [manifestBlock, docsBlock];
-var pasikaNext = [...pasikaRepo, nextAppBlock, tailwindGlobalsBlock, tailwindAnyCssBlock];
+var typescriptApp = [repoManifestBlock, zirkaBlock, typescriptAppBlock, docsBlock];
+var nextjsApp = [
+  ...typescriptApp,
+  nextManifestBlock,
+  nextjsAppBlock,
+  tailwindGlobalsBlock,
+  tailwindAnyCssBlock
+];
 export {
   allPasikaRuleIds,
   documentationRules,
   huskyRules,
   nextPackageJsonRules,
-  pasikaNext,
-  pasikaRepo,
+  nextjsApp,
+  pasikaPlugin,
   pasikaRules,
   repoPackageJsonRules,
-  tailwindRules
+  tailwindRules,
+  typescriptApp,
+  vulykRules
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",
@@ -51,7 +51,7 @@
     "tsup": "8.5.1",
     "tsx": "4.23.12",
     "typescript": "6.0.3",
-    "zirka": "0.0.45",
+    "zirka": "0.0.47",
     "zod": "4.4.3"
   },
   "peerDependencies": {