katman-mcp 0.1.0 → 0.2.0

package/dist/tools/crawl/index.js

@@ -1,4 +1,4 @@
-// Crawl module: katman_scan_code, katman_audit_site, katman_indexnow, katman_keywords.
+// Crawl module: katman_scan_code, katman_audit_site, katman_keywords (Audit Week or Pro) and katman_indexnow (Pro).
 // Registration only; the engines live in scan/, audit/, indexnow.ts and keywords.ts (pure or fetcher-injected).
 import { stat } from "node:fs/promises";
 import os from "node:os";
@@ -7,7 +7,7 @@ import { z } from "zod";
 import { resolveRoot, rootWarning } from "../../context.js";
 import { loadConfig, loadResearch, logEvent, readJson, saveConfig, saveResearch, stamp, writeJson, writeText } from "../../state.js";
 import { fail, ok } from "../../util.js";
-import { PRO_NOTE, withPro } from "../../license.js";
+import { tierNote, withPlan } from "../../license.js";
 import { topIssues, auditMarkdown } from "./audit/report.js";
 import { runAudit } from "./audit/index.js";
 import { countBySeverity } from "./common/findings.js";
@@ -87,13 +87,14 @@ function auditSummary(result, top, jsonPath) {
 export function registerCrawlTools(server, ctx) {
     server.registerTool("katman_scan_code", {
         title: "Scan the codebase (framework, rendering, SEO files)",
-        description: "Read-only scan of the project's code (no network). Detects framework and builder (Lovable/Bolt/v0/Replit), the rendering verdict (SSR/SSG/CSR + evidence), hosting and preview-URL patterns, public vs app/auth routes, robots/sitemap/llms.txt/404 (static or generated), head-tag source, JSON-LD, i18n, analytics/AI-channel tracking, onClick navigation, hash routing and images without alt. Never opens .env*, keys or secret files. Writes .katman/scan.json; returns findings with gate, P-code and acceptance criterion. Run it first, and after big code changes.",
+        description: "Read-only scan of the project's code (no network). Detects framework and builder (Lovable/Bolt/v0/Replit), the rendering verdict (SSR/SSG/CSR + evidence), hosting and preview-URL patterns, public vs app/auth routes, robots/sitemap/llms.txt/404 (static or generated), head-tag source, JSON-LD, i18n, analytics/AI-channel tracking, onClick navigation, hash routing and images without alt. Never opens .env*, keys or secret files. Writes .katman/scan.json; returns findings with gate, P-code and acceptance criterion. Run it first, and after big code changes." +
+            tierNote("scan"),
         inputSchema: {
             project_root: z.string().optional().describe("Absolute path of the website's codebase (default: KATMAN_PROJECT_ROOT, MCP roots, or cwd)."),
             max_files: z.number().int().min(50).max(50000).optional().describe("Max files to list (default 5000)."),
         },
         annotations: { readOnlyHint: true, openWorldHint: false, destructiveHint: false, idempotentHint: true },
-    }, async ({ project_root, max_files }) => {
+    }, withPlan(ctx, "scan", async ({ project_root, max_files }) => {
         try {
             const root = await resolveRoot(ctx, project_root);
             if (unsafeRoot(root))
@@ -115,10 +116,11 @@ export function registerCrawlTools(server, ctx) {
         catch (e) {
             return fail(`katman_scan_code failed: ${errText(e)}`);
         }
-    });
+    }));
     server.registerTool("katman_audit_site", {
         title: "Audit the live site like AI crawlers see it",
-        description: "Fetches the live site without JavaScript, like AI crawlers: robots.txt, sitemap, http→https, www/apex, HSTS, compression, soft 404, llms.txt, AI-bot access through the CDN/firewall (GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot…), and per page: status, noindex, title/description, canonical, H1, JS-off words and first paragraph, JSON-LD, og:image, hreflang, internal links. Returns gates, top-10 issues (P-codes + acceptance criteria) and the P14 table. Network: the site only, ≤4 requests at a time. Pass urls to re-verify a fix. Writes .katman/audits/<stamp>.json + .katman/audit.md.",
+        description: "Fetches the live site without JavaScript, like AI crawlers: robots.txt, sitemap, http→https, www/apex, HSTS, compression, soft 404, llms.txt, AI-bot access through the CDN/firewall (GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot…), and per page: status, noindex, title/description, canonical, H1, JS-off words and first paragraph, JSON-LD, og:image, hreflang, internal links. Returns gates, top-10 issues (P-codes + acceptance criteria) and the P14 table. Network: the site only, ≤4 requests at a time. Pass urls to re-verify a fix. Writes .katman/audits/<stamp>.json + .katman/audit.md." +
+            tierNote("audit"),
         inputSchema: {
             site_url: z.string().optional().describe("Site to audit, e.g. https://example.com (default: .katman/config.json siteUrl or research site.url)."),
             project_root: z.string().optional().describe("Absolute project path (where .katman/ lives)."),
@@ -128,7 +130,7 @@ export function registerCrawlTools(server, ctx) {
             preview_urls: z.array(z.string()).optional().describe("Preview/staging copies (e.g. https://proj.vercel.app) that must 301 to the main host or send noindex."),
         },
         annotations: { readOnlyHint: true, openWorldHint: true, destructiveHint: false, idempotentHint: true },
-    }, async (args, extra) => {
+    }, withPlan(ctx, "audit", async (args, extra) => {
         try {
             const root = await resolveRoot(ctx, args.project_root);
             const token = extra?._meta?.progressToken;
@@ -144,10 +146,10 @@ export function registerCrawlTools(server, ctx) {
         catch (e) {
             return fail(`katman_audit_site failed: ${errText(e)}`);
         }
-    });
+    }));
     server.registerTool("katman_indexnow", {
         title: "Notify search engines of new/changed pages (IndexNow)",
-        description: "Tells Bing (→ Copilot, ChatGPT search, DuckDuckGo), Yandex, Seznam, Naver and Yep about new or changed URLs via IndexNow. Creates a 32-hex key (saved in .katman/config.json), checks https://<host>/<key>.txt serves it, and selects only new/changed URLs (sitemap lastmod, else a hash of the page text) against .katman/indexnow.json. dry_run (default true) sends nothing; dry_run:false POSTs to api.indexnow.org and records the URLs. Always returns the manual checklist for Google Search Console, Bing Webmaster Tools and Brave." + PRO_NOTE,
+        description: "Tells Bing (→ Copilot, ChatGPT search, DuckDuckGo), Yandex, Seznam, Naver and Yep about new or changed URLs via IndexNow. Creates a 32-hex key (saved in .katman/config.json), checks https://<host>/<key>.txt serves it, and selects only new/changed URLs (sitemap lastmod, else a hash of the page text) against .katman/indexnow.json. dry_run (default true) sends nothing; dry_run:false POSTs to api.indexnow.org and records the URLs. Always returns the manual checklist for Google Search Console, Bing Webmaster Tools and Brave." + tierNote("indexnow"),
         inputSchema: {
             project_root: z.string().optional().describe("Absolute project path (where .katman/ lives)."),
             site_url: z.string().optional().describe("Site, e.g. https://example.com (default: config siteUrl)."),
@@ -156,7 +158,7 @@ export function registerCrawlTools(server, ctx) {
             dry_run: z.boolean().optional().describe("Default true: plan only. false = submit to api.indexnow.org."),
         },
         annotations: { readOnlyHint: false, openWorldHint: true, destructiveHint: false, idempotentHint: false },
-    }, withPro(ctx, "indexnow", async ({ project_root, site_url, urls, key, dry_run }) => {
+    }, withPlan(ctx, "indexnow", async ({ project_root, site_url, urls, key, dry_run }) => {
         try {
             const root = await resolveRoot(ctx, project_root);
             if (unsafeRoot(root))
@@ -185,7 +187,8 @@ export function registerCrawlTools(server, ctx) {
     }));
     server.registerTool("katman_keywords", {
         title: "Google autocomplete keyword ideas",
-        description: "Expands a seed phrase with Google autocomplete (seed + a–z/0–9; ≤40 requests, 350 ms apart; network: suggestqueries.google.com only) into real search phrases, clustered, and marks single-question, situation and comparison page candidates (English and Turkish question words). Use during research to find the customer's own words. save:true merges them into .katman/research.json keywords (source \"autocomplete\"); otherwise nothing is written.",
+        description: "Expands a seed phrase with Google autocomplete (seed + a–z/0–9; ≤40 requests, 350 ms apart; network: suggestqueries.google.com only) into real search phrases, clustered, and marks single-question, situation and comparison page candidates (English and Turkish question words). Use during research to find the customer's own words. save:true merges them into .katman/research.json keywords (source \"autocomplete\"); otherwise nothing is written." +
+            tierNote("keywords"),
         inputSchema: {
             seed: z.string().min(2).describe("Seed phrase in the customer's words, e.g. \"import invoices into accounting\"."),
             lang: z.string().optional().describe("Interface language (hl), default en; tr uses the Turkish alphabet."),
@@ -195,7 +198,7 @@ export function registerCrawlTools(server, ctx) {
             project_root: z.string().optional().describe("Absolute project path (needed with save)."),
         },
         annotations: { readOnlyHint: false, openWorldHint: true, destructiveHint: false, idempotentHint: true },
-    }, async ({ seed, lang, country, expand, save, project_root }) => {
+    }, withPlan(ctx, "keywords", async ({ seed, lang, country, expand, save, project_root }) => {
         try {
             const r = await runKeywords({ seed, lang, country, expand });
             let saved;
@@ -222,5 +225,5 @@ export function registerCrawlTools(server, ctx) {
         catch (e) {
             return fail(`katman_keywords failed: ${errText(e)}`);
         }
-    });
+    }));
 }

package/dist/tools/method/core/start.js

@@ -17,7 +17,7 @@ export function firstRunText(root) {
         "**First run in this project. What happens next:**",
         `1. Katman keeps its notes in \`${root}/.katman/\` (safe to commit, never secrets). It writes nowhere else unless you call katman_generate or katman_setup_monitoring with write: true, and it never overwrites without overwrite: true.`,
         "2. It reads your code (skipping node_modules, .git and build output; never .env*, keys or secrets) and, when you run the audit tools, your own live site.",
-        "3. Network only when a tool needs it: your site, openrouter.ai with YOUR key after a cost estimate (dry run first), api.indexnow.org on request, and katman.pro only to check KATMAN_KEY (at most once a day, only when it is set) or when you call katman_sync. No telemetry.",
+        "3. Network only when a tool needs it: your site, openrouter.ai with YOUR key after a cost estimate (dry run first), api.indexnow.org on request, and katman.pro only to check KATMAN_KEY (at most once a day, and again when a plan ends) or when you call katman_sync. No telemetry.",
         "4. The order: research (who you are, your customers' own sentences) → plan → build with prompts P0–P14 → verify, then re-measure every 14 days.",
         "5. It never invents facts: unknowns stay [FILL] and you'll be asked.",
     ].join("\n");

package/dist/tools/method/index.js

@@ -1,10 +1,13 @@
 // Method module: the Katman book as tools (katman_start, katman_research, katman_plan, katman_prompt,
 // katman_page_brief, katman_generate, katman_lint_content, katman_report), MCP prompts and resources.
+// Every tool needs a plan (withPlan); katman_start without one explains Katman and the plans instead of running.
 import { z } from "zod";
 import { resolveRoot, rootWarning } from "../../context.js";
 import { fail, ok } from "../../util.js";
-import { PRO_NOTE, startLicense, withPro } from "../../license.js";
+import { startLicense, tierNote, withPlan } from "../../license.js";
+import { startIntro, upsellStructured } from "../account/upsell.js";
 import { hasOpenRouterKey } from "./lib/calls.js";
+import { loadConfigSafe } from "./lib/state.js";
 import { runStart } from "./core/start.js";
 import { runResearch } from "./core/research-run.js";
 import { runPlan } from "./core/plan.js";
@@ -113,7 +116,8 @@ function wrap(ctx, fn, opts = {}) {
 export function registerMethodTools(server, ctx) {
     server.registerTool("katman_start", {
         title: "Katman: start here",
-        description: "Call this FIRST, and again after every step. Shows the Katman method (gates Read / Quote / Fit; steps Research → Plan → Build → Verify), the status of each step from .katman/ (research %, scan, audit, plan tasks, visibility runs, 14-day re-measure) and the NEXT STEP as an exact tool call with arguments — do that next. Pass project_root (absolute path of the site's codebase) and site_url when known; site_url is saved to .katman/config.json. Writes nothing else.",
+        description: "Call this FIRST, and again after every step. Shows the Katman method (gates Read / Quote / Fit; steps Research → Plan → Build → Verify), the status of each step from .katman/ (research %, scan, audit, plan tasks, visibility runs, 14-day re-measure) and the NEXT STEP as an exact tool call with arguments — do that next. Pass project_root (absolute path of the site's codebase) and site_url when known; site_url is saved to .katman/config.json. Writes nothing else. Without a plan it only explains Katman, the plans and how to set the key." +
+            tierNote("start"),
         inputSchema: {
             project_root: projectRoot,
             site_url: z.string().optional().describe("The live site URL, e.g. https://example.com (saved to .katman/config.json)"),
@@ -122,8 +126,13 @@ export function registerMethodTools(server, ctx) {
         annotations: { title: "Katman: start here", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async (args) => {
         try {
+            const license = await startLicense(ctx);
             const root = await resolveRoot(ctx, args.project_root);
-            const out = await runStart(root, { siteUrl: args.site_url, hasOpenRouterKey: hasOpenRouterKey(), warning: rootWarning(root), lang: args.lang, license: await startLicense(ctx) });
+            if (!license.allowed) {
+                const intro = startIntro(license.status, args.lang ?? (await loadConfigSafe(root)).lang);
+                return ok(intro, upsellStructured("katman_start", "start", license.status));
+            }
+            const out = await runStart(root, { siteUrl: args.site_url, hasOpenRouterKey: hasOpenRouterKey(), warning: rootWarning(root), lang: args.lang, license });
             return out.isError ? fail(out.text) : ok(out.text, out.structured);
         }
         catch (e) {
@@ -132,7 +141,8 @@ export function registerMethodTools(server, ctx) {
     });
     server.registerTool("katman_research", {
         title: "Katman: research (step 1)",
-        description: "Step 1. Creates and maintains .katman/research.json + research.md: brand, category, the one sentence in 4 parts (brings → weDo → gets → fear), not-X note, 10–12 unbranded customer situations, competitors (url + checkedAt), proof (with source), keywords, question set. mode template = skeleton; update = merge data (lists merge by id/name/sentence; replace_lists replaces); show = print with completeness % and warnings. generate_questions builds the question set per site language (12+2 for the primary). Fill from the codebase, ask the user for customer sentences; never invent.",
+        description: "Step 1. Creates and maintains .katman/research.json + research.md: brand, category, the one sentence in 4 parts (brings → weDo → gets → fear), not-X note, 10–12 unbranded customer situations, competitors (url + checkedAt), proof (with source), keywords, question set. mode template = skeleton; update = merge data (lists merge by id/name/sentence; replace_lists replaces); show = print with completeness % and warnings. generate_questions builds the question set per site language (12+2 for the primary). Fill from the codebase, ask the user for customer sentences; never invent." +
+            tierNote("research"),
         inputSchema: {
             project_root: projectRoot,
             mode: z.enum(["template", "update", "show"]).optional().describe("Default: update when data/generate_questions is given, else show (or template when there's no research)"),
@@ -142,16 +152,16 @@ export function registerMethodTools(server, ctx) {
             lang,
         },
         annotations: { title: "Katman: research", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-    }, wrap(ctx, (root, a) => runResearch(root, { mode: a.mode, data: a.data, replaceLists: a.replace_lists, generateQuestions: a.generate_questions, lang: a.lang })));
+    }, withPlan(ctx, "research", wrap(ctx, (root, a) => runResearch(root, { mode: a.mode, data: a.data, replaceLists: a.replace_lists, generateQuestions: a.generate_questions, lang: a.lang }))));
     server.registerTool("katman_plan", {
         title: "Katman: plan (step 2)",
-        description: "Step 2. Builds .katman/plan.md + plan.json from research, scan.json, the latest audit and runs: the page plan (existing vs missing pages), what stays out of the index (noindex vs robots.txt Disallow), and the first-30-days task list (P-code, files, acceptance criterion, verifying tool; critical findings first). Ticks in plan.md are kept when it regenerates. Show the plan to the user and get approval before changing code. Re-run after new scans or audits." + PRO_NOTE,
+        description: "Step 2. Builds .katman/plan.md + plan.json from research, scan.json, the latest audit and runs: the page plan (existing vs missing pages), what stays out of the index (noindex vs robots.txt Disallow), and the first-30-days task list (P-code, files, acceptance criterion, verifying tool; critical findings first). Ticks in plan.md are kept when it regenerates. Show the plan to the user and get approval before changing code. Re-run after new scans or audits." + tierNote("plan"),
         inputSchema: { project_root: projectRoot, lang },
         annotations: { title: "Katman: plan", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "plan", wrap(ctx, (root, a) => runPlan(root, { lang: a.lang }))));
+    }, withPlan(ctx, "plan", wrap(ctx, (root, a) => runPlan(root, { lang: a.lang }))));
     server.registerTool("katman_prompt", {
         title: "Katman: prompt P0–P14 (step 3)",
-        description: "Step 3. Returns prompt P0–P14 from the Katman prompt book filled with this project's research (brand, domain, one sentence, not-X, competitors, situation) plus Accept (acceptance criterion), Why, how Katman verifies it (exact tool call) and framework notes from scan.json. Do the prompt, list the changed files, run the check; tick the task in .katman/plan.md only when it passes. P6 takes situation_id. Unknown values stay [FILL] — ask, don't guess. Read-only." + PRO_NOTE,
+        description: "Step 3. Returns prompt P0–P14 from the Katman prompt book filled with this project's research (brand, domain, one sentence, not-X, competitors, situation) plus Accept (acceptance criterion), Why, how Katman verifies it (exact tool call) and framework notes from scan.json. Do the prompt, list the changed files, run the check; tick the task in .katman/plan.md only when it passes. P6 takes situation_id. Unknown values stay [FILL] — ask, don't guess. Read-only." + tierNote("prompts"),
         inputSchema: {
             id: z.string().describe("Prompt id: P0–P14 (P0 context, P1 audit, P2 text in HTML, P3 head tags, P4 robots/sitemap, P5 schema, P6 situation page, P7 comparison guide, P8 llms.txt, P9 images, P10 links, P11 404/redirects, P12 speed, P13 measurement, P14 pre-release check)"),
             project_root: projectRoot,
@@ -159,10 +169,10 @@ export function registerMethodTools(server, ctx) {
             lang,
         },
         annotations: { title: "Katman: prompt", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "prompts", wrap(ctx, (root, a) => runPrompt(root, { id: a.id, situationId: a.situation_id, lang: a.lang }))));
+    }, withPlan(ctx, "prompts", wrap(ctx, (root, a) => runPrompt(root, { id: a.id, situationId: a.situation_id, lang: a.lang }))));
     server.registerTool("katman_page_brief", {
         title: "Katman: page brief",
-        description: "Filled page brief before writing a page: URL, title (situation first, ≈60 chars), H1, first sentence, action, proof, not-for, alternatives, FAQ candidates, related pages, the 11-block anatomy, the JSON-LD to include (only information visible on the page) and where the file goes in this framework. type: situation | comparison | pricing | faq | about | single-question | glossary | tool | home. Use it before P6 / P7. Read-only." + PRO_NOTE,
+        description: "Filled page brief before writing a page: URL, title (situation first, ≈60 chars), H1, first sentence, action, proof, not-for, alternatives, FAQ candidates, related pages, the 11-block anatomy, the JSON-LD to include (only information visible on the page) and where the file goes in this framework. type: situation | comparison | pricing | faq | about | single-question | glossary | tool | home. Use it before P6 / P7. Read-only." + tierNote("briefs"),
         inputSchema: {
             type: z.enum(BRIEF_TYPES).describe("Page type"),
             project_root: projectRoot,
@@ -171,10 +181,10 @@ export function registerMethodTools(server, ctx) {
             lang,
         },
         annotations: { title: "Katman: page brief", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "briefs", wrap(ctx, (root, a) => runBrief(root, { type: a.type, situationId: a.situation_id, topic: a.topic, lang: a.lang }))));
+    }, withPlan(ctx, "briefs", wrap(ctx, (root, a) => runBrief(root, { type: a.type, situationId: a.situation_id, topic: a.topic, lang: a.lang }))));
     server.registerTool("katman_generate", {
         title: "Katman: generate files from research",
-        description: "Generates from research (single source of truth): robots.txt (a group per AI bot, app paths closed with trailing slashes, auth pages left to noindex), llms.txt, Organization / WebSite / SoftwareApplication / FAQPage / BreadcrumbList JSON-LD, the AI-channel analytics snippet, a server-side bot counter, the IndexNow key file. Returns content + target path. write: true writes static files into the site's static dir (never over an existing file without overwrite: true) and code/JSON-LD into .katman/generated/; refuses while [FILL] remains." + PRO_NOTE,
+        description: "Generates from research (single source of truth): robots.txt (a group per AI bot, app paths closed with trailing slashes, auth pages left to noindex), llms.txt, Organization / WebSite / SoftwareApplication / FAQPage / BreadcrumbList JSON-LD, the AI-channel analytics snippet, a server-side bot counter, the IndexNow key file. Returns content + target path. write: true writes static files into the site's static dir (never over an existing file without overwrite: true) and code/JSON-LD into .katman/generated/; refuses while [FILL] remains." + tierNote("generate"),
         inputSchema: {
             artifact: z.enum(ARTIFACTS).describe("What to generate"),
             project_root: projectRoot,
@@ -183,10 +193,10 @@ export function registerMethodTools(server, ctx) {
             overwrite: z.boolean().optional().describe("Allow replacing an existing file (review the diff first)"),
         },
         annotations: { title: "Katman: generate", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "generate", wrap(ctx, (root, a) => runGenerate(root, { artifact: a.artifact, options: a.options, write: a.write, overwrite: a.overwrite }))));
+    }, withPlan(ctx, "generate", wrap(ctx, (root, a) => runGenerate(root, { artifact: a.artifact, options: a.options, write: a.write, overwrite: a.overwrite }))));
     server.registerTool("katman_lint_content", {
         title: "Katman: check a page's content",
-        description: "Checks one page against the Katman content rules before shipping: first 1–3 sentences answer (≤35 words, no preamble), key claim in the first ~200 chars, one sentence consistent with research + llms.txt, hype words, unsourced numbers, placeholders, \"free\" on a paid product, update date, FAQ 5–8, not-for and alternatives sections, ≥3 internal links, title/description length; comparison pages: sources + dates, own gaps, brand not first. Pass file (project path), url (live page, fetched without JS) or text. Read-only." + PRO_NOTE,
+        description: "Checks one page against the Katman content rules before shipping: first 1–3 sentences answer (≤35 words, no preamble), key claim in the first ~200 chars, one sentence consistent with research + llms.txt, hype words, unsourced numbers, placeholders, \"free\" on a paid product, update date, FAQ 5–8, not-for and alternatives sections, ≥3 internal links, title/description length; comparison pages: sources + dates, own gaps, brand not first. Pass file (project path), url (live page, fetched without JS) or text. Read-only." + tierNote("lint"),
         inputSchema: {
             project_root: projectRoot,
             file: z.string().optional().describe("Page source in the project (.md, .mdx, .html, .astro, .tsx, .jsx, .vue, .svelte, llms.txt), relative to project_root"),
@@ -197,13 +207,13 @@ export function registerMethodTools(server, ctx) {
             lang,
         },
         annotations: { title: "Katman: lint content", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, withPro(ctx, "lint", wrap(ctx, (root, a) => runLint(root, { file: a.file, url: a.url, text: a.text, pageType: a.page_type, situationId: a.situation_id, lang: a.lang }))));
+    }, withPlan(ctx, "lint", wrap(ctx, (root, a) => runLint(root, { file: a.file, url: a.url, text: a.text, pageType: a.page_type, situationId: a.situation_id, lang: a.lang }))));
     server.registerTool("katman_report", {
         title: "Katman: report",
-        description: "Writes .katman/report.md, a shareable summary: research completeness, the latest audit's gate pass rates (Read / Quote / Fit), AI visibility rates with changes vs the previous comparable run, the competitors named instead and the cited domains (off-site targets), plan progress, the top 10 open issues and the next 7 days. Use after a measurement or at the end of a work session." + PRO_NOTE,
+        description: "Writes .katman/report.md, a shareable summary: research completeness, the latest audit's gate pass rates (Read / Quote / Fit), AI visibility rates with changes vs the previous comparable run, the competitors named instead and the cited domains (off-site targets), plan progress, the top 10 open issues and the next 7 days. Use after a measurement or at the end of a work session." + tierNote("report"),
         inputSchema: { project_root: projectRoot, lang },
         annotations: { title: "Katman: report", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "report", wrap(ctx, (root, a) => runReport(root, { lang: a.lang }))));
+    }, withPlan(ctx, "report", wrap(ctx, (root, a) => runReport(root, { lang: a.lang }))));
     registerMethodPrompts(server);
     registerMethodResources(server, ctx);
 }

package/dist/tools/method/mcp/prompts.js

@@ -1,5 +1,7 @@
 // MCP prompts (slash commands): katman-start, katman-audit, katman-situation-page, katman-measure.
-// Each returns user-role messages that walk the agent through the tools step by step.
+// Each returns user-role messages that walk the agent through the tools step by step. None of them carries the text
+// of the prompt book P0–P14 (Katman Pro content, served by katman_prompt): they only call tools, and every tool
+// checks the plan itself.
 import { z } from "zod";
 const user = (text) => ({ role: "user", content: { type: "text", text } });
 const RULES = `Rules (Katman method):
@@ -22,14 +24,12 @@ Do this now:
 ${RULES}`;
 }
 export function auditPromptText(siteUrl) {
-    return `Audit this site the way AI crawlers see it (Katman prompt P1). REPORT ONLY: do not create, modify or delete any file in the project.
+    return `Audit this site the way AI crawlers see it. REPORT ONLY: do not create, modify or delete any file in the project.
 
 1. Call katman_start (project_root = the absolute path of this workspace${siteUrl ? `, site_url = "${siteUrl}"` : ""}) to load the state and the site URL. If no site URL is known, ask me for it.
 2. Call katman_scan_code.
 3. Call katman_audit_site with the site URL.
-4. From their output, write the P1 report: one row per public page — URL | SSR/SSG/CSR | title + length | meta description + length | canonical | robots meta | H1 count | images without alt | og:image | JSON-LD types | pages linking to it.
-5. Answer: do robots.txt and sitemap.xml exist and how are they generated? Does /this-page-does-not-exist return 404? Are links <a href> or onClick? Is the site also live at a preview/staging address? Do GPTBot, OAI-SearchBot, ClaudeBot and PerplexityBot get 200?
-6. Finish with the 10 most important problems ranked by traffic impact, each with the file that would change and the Katman prompt (P-code) that fixes it.
+4. From their output, give me the 10 most important problems ranked by traffic impact, each with the file that would change, the P-code Katman gives for it and its acceptance criterion.
 
 Don't fix anything yet. When I approve, call katman_plan.`;
 }
@@ -63,7 +63,7 @@ export function registerMethodPrompts(server) {
         argsSchema: { site_url: z.string().optional().describe("The live site URL, if known (e.g. https://example.com)") },
     }, ({ site_url }) => ({ messages: [user(startPromptText(site_url))] }));
     server.registerPrompt("katman-audit", {
-        title: "Katman: audit (P1, report only)",
+        title: "Katman: audit (report only)",
         description: "Audit the site like AI crawlers see it — codebase scan + live audit — and report the top 10 problems without changing code.",
         argsSchema: { site_url: z.string().optional().describe("The live site URL, if known") },
     }, ({ site_url }) => ({ messages: [user(auditPromptText(site_url))] }));

package/dist/tools/method/mcp/resources.js

@@ -1,11 +1,14 @@
 // MCP resources: the method, checklists, content rules, raw prompts and the current project's research.md.
+// Each needs a plan like the tools do: the method texts need "start" (Audit Week or Pro), research.md "research",
+// the prompt bodies "prompts" (Katman Pro). The resource list itself stays visible.
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { resolveRoot } from "../../../context.js";
 import { PROMPTS, getPrompt } from "../data/prompts.js";
 import { contentRulesMd, methodOverviewMd, prepublishChecklistMd, rawPromptMd, siteAuditChecklistMd } from "../data/render.js";
 import { loadConfigSafe, loadResearchSafe, loadRuns } from "../lib/state.js";
 import { renderResearchMd } from "../core/research.js";
-import { licenseOf, requirePro } from "../../../license.js";
+import { licenseOf, requireFeature } from "../../../license.js";
+import { resourcePaywall } from "../../account/upsell.js";
 const MD = "text/markdown";
 function md(uri, text) {
     return { contents: [{ uri: uri.href, mimeType: MD, text }] };
@@ -18,11 +21,17 @@ export async function researchResourceText(root) {
     const [runs, config] = await Promise.all([loadRuns(root), loadConfigSafe(root)]);
     return renderResearchMd(research, runs, config.lang ?? "en");
 }
+/** The resource text when the plan includes the feature, else a short paywall under the same title. */
+async function gated(ctx, uri, feature, title, then, text) {
+    const gate = await requireFeature(feature, licenseOf(ctx));
+    return md(uri, gate.allowed ? await text() : resourcePaywall(title, feature, gate.status, then));
+}
+const AGAIN = "Then read this resource again.";
 export function registerMethodResources(server, ctx) {
-    server.registerResource("katman-method", "katman://method", { title: "The Katman method", description: "3 gates (Read / Quote / Fit), 4 steps, the evidence, the 6 traps, the prompt book P0–P14, the first 30 days.", mimeType: MD }, async (uri) => md(uri, methodOverviewMd("en")));
-    server.registerResource("katman-checklist-prepublish", "katman://checklist/prepublish", { title: "Pre-publish checklist", description: "The one-page checklist before publishing (book ch. 19), each line with the Katman check that proves it.", mimeType: MD }, async (uri) => md(uri, prepublishChecklistMd("en")));
-    server.registerResource("katman-checklist-site-audit", "katman://checklist/site-audit", { title: "Full site audit checklist", description: "Per-URL and site-wide checks (book appendix E) that katman_audit_site runs.", mimeType: MD }, async (uri) => md(uri, siteAuditChecklistMd("en")));
-    server.registerResource("katman-content-rules", "katman://content-rules", { title: "Content rules", description: "Content rules (appendix D), how content is produced without spam, the 11-block situation page anatomy, and the words katman_lint_content flags.", mimeType: MD }, async (uri) => md(uri, contentRulesMd("en")));
+    server.registerResource("katman-method", "katman://method", { title: "The Katman method", description: "3 gates (Read / Quote / Fit), 4 steps, the evidence, the 6 traps, the prompt book P0–P14, the first 30 days.", mimeType: MD }, async (uri) => gated(ctx, uri, "start", "The Katman method", AGAIN, () => methodOverviewMd("en")));
+    server.registerResource("katman-checklist-prepublish", "katman://checklist/prepublish", { title: "Pre-publish checklist", description: "The one-page checklist before publishing (book ch. 19), each line with the Katman check that proves it.", mimeType: MD }, async (uri) => gated(ctx, uri, "start", "Pre-publish checklist", AGAIN, () => prepublishChecklistMd("en")));
+    server.registerResource("katman-checklist-site-audit", "katman://checklist/site-audit", { title: "Full site audit checklist", description: "Per-URL and site-wide checks (book appendix E) that katman_audit_site runs.", mimeType: MD }, async (uri) => gated(ctx, uri, "start", "Full site audit checklist", AGAIN, () => siteAuditChecklistMd("en")));
+    server.registerResource("katman-content-rules", "katman://content-rules", { title: "Content rules", description: "Content rules (appendix D), how content is produced without spam, the 11-block situation page anatomy, and the words katman_lint_content flags.", mimeType: MD }, async (uri) => gated(ctx, uri, "start", "Content rules", AGAIN, () => contentRulesMd("en")));
     server.registerResource("katman-prompt", new ResourceTemplate("katman://prompts/{id}", {
         list: async () => ({
             resources: PROMPTS.map((p) => ({ uri: `katman://prompts/${p.id}`, name: `${p.id} ${p.title.en}`, title: `${p.id} · ${p.title.en}`, mimeType: MD })),
@@ -35,16 +44,10 @@ export function registerMethodResources(server, ctx) {
         const p = getPrompt(String(raw ?? ""));
         if (!p)
             return md(uri, `Unknown prompt "${raw}". Valid ids: ${PROMPTS.map((x) => x.id).join(", ")}.`);
-        // The prompt book is Pro content, like the katman_prompt tool: titles and acceptance criteria stay listed,
-        // the prompt bodies need a Pro or trial license.
-        const gate = await requirePro("prompts", licenseOf(ctx));
-        if (!gate.allowed) {
-            return md(uri, `# ${p.id} · ${p.title.en}\n\nThe prompt text is part of Katman Pro (needs KATMAN_KEY). Start the 7-day free trial at https://katman.pro/app, add the key to your MCP config as KATMAN_KEY, then read this resource again or call katman_prompt {"id": "${p.id}"} to get it filled with this project's data.`);
-        }
-        return md(uri, rawPromptMd(p, "en"));
-    });
-    server.registerResource("katman-research", "katman://research", { title: "This project's research.md", description: "The current project's research (brand, one sentence, not-X, situations, competitors, proof, question set, latest measurement), rendered from .katman/research.json.", mimeType: MD }, async (uri) => {
-        const root = await resolveRoot(ctx);
-        return md(uri, await researchResourceText(root));
+        // The prompt book is Katman Pro content, like the katman_prompt tool: the titles stay listed, the prompt bodies
+        // need Pro (the Audit Week doesn't include them).
+        const then = `Then read this resource again, or call katman_prompt {"id": "${p.id}"} to get it filled with this project's data.`;
+        return gated(ctx, uri, "prompts", `${p.id} · ${p.title.en}`, then, () => rawPromptMd(p, "en"));
     });
+    server.registerResource("katman-research", "katman://research", { title: "This project's research.md", description: "The current project's research (brand, one sentence, not-X, situations, competitors, proof, question set, latest measurement), rendered from .katman/research.json.", mimeType: MD }, async (uri) => gated(ctx, uri, "research", "research.md", AGAIN, async () => researchResourceText(await resolveRoot(ctx))));
 }

package/dist/tools/visibility/index.js

@@ -1,10 +1,10 @@
 // Visibility module: measures whether AI assistants name, recommend and cite the brand.
-// Tools: katman_visibility_run (OpenRouter, user's key, dry run first), katman_manual_check
-// (no API cost: the user pastes consumer-app answers), katman_setup_monitoring (GitHub Actions).
+// Tools: katman_visibility_run (OpenRouter, user's key, dry run first) and katman_manual_check (no API cost: the user
+// pastes consumer-app answers), both Audit Week or Pro; katman_setup_monitoring (GitHub Actions, Pro).
 import { z } from "zod";
 import { resolveRoot, rootWarning } from "../../context.js";
 import { fail, ok } from "../../util.js";
-import { PRO_NOTE, withPro } from "../../license.js";
+import { tierNote, withPlan } from "../../license.js";
 import { ASSISTANTS, manualCheck } from "./manual.js";
 import { setupMonitoring } from "./monitoring.js";
 import { redact } from "./openrouter.js";
@@ -22,7 +22,7 @@ function crash(tool, e) {
 export function registerVisibilityTools(server, ctx) {
     server.registerTool("katman_visibility_run", {
         title: "Measure AI visibility (ChatGPT, Claude, Gemini, Perplexity, Grok)",
-        description: "Asks the research question set (12 unbranded + 2 diagnostic) to ChatGPT, Claude, Gemini, Perplexity and Grok via OpenRouter with live web search and the user's own key, then records who is named, recommended first and cited. SPENDS THE USER'S CREDITS: always call with dry_run: true first (the default), show the estimate, and get the user's explicit yes before dry_run: false. Default panel \"economy\" (5 assistants, smaller models, ≈$1–4 per run); \"full\" ≈$2–7; \"probe\" ≈$1–3. Refuses to start above max_cost_usd (default 3). A full run takes minutes. API answers are a proxy for the consumer apps. Saves .katman/runs/ and measurements.md." + PRO_NOTE,
+        description: "Asks the research question set (12 unbranded + 2 diagnostic) to ChatGPT, Claude, Gemini, Perplexity and Grok via OpenRouter with live web search and the user's own key, then records who is named, recommended first and cited. SPENDS THE USER'S CREDITS: always call with dry_run: true first (the default), show the estimate, and get the user's explicit yes before dry_run: false. Default panel \"economy\" (5 assistants, smaller models, ≈$1–4 per run); \"full\" ≈$2–7; \"probe\" ≈$1–3. Refuses to start above max_cost_usd (default 3). A full run takes minutes. API answers are a proxy for the consumer apps. Saves .katman/runs/ and measurements.md." + tierNote("visibility"),
         inputSchema: {
             project_root: projectRoot,
             dry_run: z.boolean().optional().describe("Default true: estimate only, nothing is spent. false = real run, only after the user agreed to the estimate."),
@@ -40,7 +40,7 @@ export function registerVisibilityTools(server, ctx) {
             allow_google_grounding: z.boolean().optional().describe("Gemini uses Exa search by default. true = Google's own grounding; Google's terms restrict storing and analysing grounded results, and the user is responsible."),
         },
         annotations: { title: "Measure AI visibility", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    }, withPro(ctx, "visibility", async (args, extra) => {
+    }, withPlan(ctx, "visibility", async (args, extra) => {
         let root = "";
         try {
             root = await resolveRoot(ctx, args.project_root);
@@ -60,7 +60,7 @@ export function registerVisibilityTools(server, ctx) {
     }));
     server.registerTool("katman_manual_check", {
         title: "Record a consumer-app answer (no API cost)",
-        description: "No API cost, terms-safe measurement: the user asks ChatGPT, Claude, Gemini, Perplexity, Copilot, Grok or Google AI Mode in a private, logged-out window with web search on and pastes the answer. Without answer_text: returns exact instructions and the questions to ask (verbatim). With answer_text (+ question_id or question, sources): detects whether the brand is named, its position, who was recommended, competitors and cited pages, saves a manual run in .katman/runs/ and updates measurements.md. Makes one tiny judge call only if an OpenRouter key is set." + PRO_NOTE,
+        description: "No API cost, terms-safe measurement: the user asks ChatGPT, Claude, Gemini, Perplexity, Copilot, Grok or Google AI Mode in a private, logged-out window with web search on and pastes the answer. Without answer_text: returns exact instructions and the questions to ask (verbatim). With answer_text (+ question_id or question, sources): detects whether the brand is named, its position, who was recommended, competitors and cited pages, saves a manual run in .katman/runs/ and updates measurements.md. Makes one tiny judge call only if an OpenRouter key is set." + tierNote("manual_check"),
         inputSchema: {
             project_root: projectRoot,
             assistant: z.enum(ASSISTANTS).describe("The consumer app the user asked."),
@@ -72,7 +72,7 @@ export function registerVisibilityTools(server, ctx) {
             web_search: z.boolean().optional().describe("Was web search on? Default true."),
         },
         annotations: { title: "Record a consumer-app answer", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    }, withPro(ctx, "manual_check", async (args) => {
+    }, withPlan(ctx, "manual_check", async (args) => {
         let root = "";
         try {
             root = await resolveRoot(ctx, args.project_root);
@@ -84,7 +84,7 @@ export function registerVisibilityTools(server, ctx) {
     }));
     server.registerTool("katman_setup_monitoring", {
         title: "Schedule AI visibility checks (GitHub Actions)",
-        description: "Generates a GitHub Actions workflow that re-runs the visibility check (and optionally the live site audit) on a schedule with the user's OPENROUTER_API_KEY repository secret, commits .katman/ changes and opens an issue when the mention rate drops. Returns the YAML, the estimated cost per run and month, and the steps to add the secret and site variable. Makes no network calls. write: true writes .github/workflows/katman.yml (refuses to replace an existing file unless overwrite: true)." + PRO_NOTE,
+        description: "Generates a GitHub Actions workflow that re-runs the visibility check (and optionally the live site audit) on a schedule with the user's OPENROUTER_API_KEY repository secret, commits .katman/ changes and opens an issue when the mention rate drops. Returns the YAML, the estimated cost per run and month, and the steps to add the secret and site variable. Makes no network calls. write: true writes .github/workflows/katman.yml (refuses to replace an existing file unless overwrite: true)." + tierNote("monitoring"),
         inputSchema: {
             project_root: projectRoot,
             schedule: z.string().optional().describe('Cron (UTC), default "0 6 * * 1" (Mondays 06:00). The book re-measures every 14 days: "0 6 1,15 * *".'),
@@ -95,7 +95,7 @@ export function registerVisibilityTools(server, ctx) {
             models: z.string().optional().describe('Preset or comma list for the scheduled check, e.g. "economy" or "probe".'),
         },
         annotations: { title: "Schedule AI visibility checks", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, withPro(ctx, "monitoring", async (args) => {
+    }, withPlan(ctx, "monitoring", async (args) => {
         let root = "";
         try {
             root = await resolveRoot(ctx, args.project_root);

package/dist/tools/visibility/monitoring.js

@@ -35,7 +35,7 @@ export function buildWorkflowYaml(o) {
         "# Katman AI visibility monitoring (generated by katman-mcp; safe to edit).",
         "# Re-asks your question set through OpenRouter with YOUR key (capped per run), commits .katman/",
         `# and opens an issue when the share of answers that name you drops by ${DROP_POINTS}+ points.`,
-        "# `katman-mcp check` is a Katman Pro command: it needs the KATMAN_KEY repository secret (katman.pro/app).",
+        `# \`katman-mcp check\`${o.includeAudit ? " and `katman-mcp audit` need" : " needs"} the KATMAN_KEY repository secret (a Katman key with an active plan).`,
         "name: Katman AI visibility",
         "",
         "on:",
@@ -72,7 +72,7 @@ export function buildWorkflowYaml(o) {
         y.push("", "      - name: Live site audit (as AI crawlers see it)");
         if (!site)
             y.push("        if: ${{ vars.KATMAN_SITE_URL != '' }}");
-        y.push("        continue-on-error: true", "        env:", site ? `          KATMAN_SITE_URL: \${{ vars.KATMAN_SITE_URL || '${site}' }}` : "          KATMAN_SITE_URL: ${{ vars.KATMAN_SITE_URL }}", '        run: npx -y katman-mcp audit "$KATMAN_SITE_URL" --root .');
+        y.push("        continue-on-error: true", "        env:", "          KATMAN_KEY: ${{ secrets.KATMAN_KEY }}", site ? `          KATMAN_SITE_URL: \${{ vars.KATMAN_SITE_URL || '${site}' }}` : "          KATMAN_SITE_URL: ${{ vars.KATMAN_SITE_URL }}", '        run: npx -y katman-mcp audit "$KATMAN_SITE_URL" --root .');
     }
     y.push("", "      - name: Commit .katman changes", "        run: |", '          git config user.name "katman-bot"', '          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"', "          git add -A .katman ':(exclude).katman/cache'", "          if git diff --cached --quiet; then", '            echo "No .katman changes."', "          else", '            git commit -m "katman: AI visibility check $(date -u +%F)"', "            git pull --rebase --autostash", "            git push", "          fi", "", "      - name: Compare the last two runs", "        if: always()", "        id: drop", "        run: |", "          node <<'EOF'", "          const fs = require('fs');", "          const path = require('path');", "          const dir = '.katman/runs';", "          const out = (k, v) => fs.appendFileSync(process.env.GITHUB_OUTPUT, `${k}=${v}\\n`);", "          let files = [];", "          try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.json') && !f.startsWith('manual-')).sort(); } catch {}", "          const runs = files", "            .map((f) => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')); } catch { return null; } })", "            .filter((r) => r && r.summary && r.summary.answered >= 5);", "          if (runs.length < 2) { out('dropped', 'false'); process.exit(0); }", "          const [prev, cur] = runs.slice(-2);", "          const before = Math.round(prev.summary.mentionRate * 100);", "          const after = Math.round(cur.summary.mentionRate * 100);", "          out('before', before);", "          out('after', after);", "          out('run', cur.id);", "          // Only a run made by this workflow run counts; otherwise the same drop would open an issue every week.", "          const fresh = Date.now() - Date.parse(cur.ts) < 36 * 3600 * 1000;", `          out('dropped', String(fresh && before - after >= ${DROP_POINTS}));`, "          EOF", "", "      - name: Open an issue when the mention rate dropped", "        if: always() && steps.drop.outputs.dropped == 'true'", "        env:", "          GH_TOKEN: ${{ github.token }}", "          BEFORE: ${{ steps.drop.outputs.before }}", "          AFTER: ${{ steps.drop.outputs.after }}", "          RUN_ID: ${{ steps.drop.outputs.run }}", "        run: |", "          cat > katman-issue.md <<EOF", "          AI assistants named you in ${AFTER}% of the unbranded answers in run ${RUN_ID}, down from ${BEFORE}% in the run before.", "", "          - Who was recommended instead and which sources the assistants used: .katman/measurements.md", "          - One run is a small sample; check whether the drop holds in the next run before changing course.", "          - Confirm key questions by hand with katman_manual_check (logged out, web search on).", "          EOF", '          gh issue create --title "Katman: AI assistants name you less often (${BEFORE}% → ${AFTER}%)" --body-file katman-issue.md');
     return y.join("\n") + "\n";
@@ -143,7 +143,7 @@ export async function setupMonitoring(root, args) {
         "",
         "## Setup steps",
         "",
-        "1. Add your keys as repository secrets: GitHub → Settings → Secrets and variables → Actions → New repository secret, name `OPENROUTER_API_KEY` (or `gh secret set OPENROUTER_API_KEY`), and `KATMAN_KEY` with your Katman Pro key from https://katman.pro/app → MCP (`gh secret set KATMAN_KEY`; `katman-mcp check` is a Pro command and stops without it). Give the OpenRouter key its own credit limit at https://openrouter.ai/keys, e.g. your monthly budget.",
+        "1. Add your keys as repository secrets: GitHub → Settings → Secrets and variables → Actions → New repository secret, name `OPENROUTER_API_KEY` (or `gh secret set OPENROUTER_API_KEY`), and `KATMAN_KEY` with your Katman key from https://katman.pro/app/mcp (`gh secret set KATMAN_KEY`; every katman-mcp command except account needs it and stops without an active plan). Give the OpenRouter key its own credit limit at https://openrouter.ai/keys, e.g. your monthly budget.",
         includeAudit
             ? `2. Add a repository variable \`KATMAN_SITE_URL\` = your live URL (Variables tab, or \`gh variable set KATMAN_SITE_URL --body https://…\`)${siteUrl ? `; without it the workflow audits ${siteUrl}` : "; without it the audit step is skipped"}.`
             : "2. (Audit step off.)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katman-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Katman MCP: makes your vibe-coded site readable, quotable and recommendable by ChatGPT, Claude, Gemini and Perplexity. Scans your codebase, audits your live site like AI crawlers do, measures AI visibility with your own OpenRouter key.",
   "type": "module",
   "bin": {

package/server.json

@@ -3,21 +3,21 @@
   "name": "pro.katman/mcp",
   "title": "Katman",
   "description": "Get your vibe-coded site read, quoted and recommended by ChatGPT, Claude, Gemini and Perplexity.",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "websiteUrl": "https://katman.pro/mcp",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "katman-mcp",
-      "version": "0.1.0",
+      "version": "0.2.0",
       "runtimeHint": "npx",
       "transport": { "type": "stdio" },
       "environmentVariables": [
         {
           "name": "KATMAN_KEY",
-          "description": "Optional. Your Katman Pro key from katman.pro/app (7-day free trial, no card). Unlocks the Pro tools; the free diagnosis tools work without it.",
-          "isRequired": false,
+          "description": "Required. Your Katman licence key (km_live_…) from katman.pro/app/mcp. Every tool except katman_account needs it with an active plan: Audit Week ($3 for 7 days: audit and recommendations) or Katman Pro ($29/month founding price: everything). Plans: katman.pro/pricing.",
+          "isRequired": true,
           "isSecret": true,
           "format": "string"
         },