mewkit 1.16.1 → 1.18.0

package/dist/core/check-gate-authority.js

@@ -0,0 +1,313 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Suppression marker for prose that legitimately QUOTES the anti-pattern. */
+const ALLOW_MARKER = "lint-allow-gate-authority";
+/**
+ * Statements that grant automated gate approval. Each entry is scoped to an
+ * explicit `Gate 1` / `Gate 2` reference (or an unambiguous euphemism) so that
+ * unrelated vocabulary — a skill's own "HARD GATE", a domain "gate" metaphor —
+ * cannot trip the check.
+ */
+const PATTERNS = [
+    {
+        name: "auto-approve → gate",
+        // The digit is REQUIRED. Without it this matches the bare word "gate" and
+        // fires on every domain metaphor ("the quality gate stays manual").
+        //
+        // The gap is deliberately TIGHT. In every real instance the verb and its
+        // gate are adjacent ("auto-approves Gate 2"). A wide gap lets one match
+        // span two clauses, so a negated first clause swallows the gate reference
+        // belonging to an asserting second clause — and the violation vanishes.
+        re: /auto[-\s]?approv\w*[^.\n]{0,20}\bgates?\s*[12]\b/gi,
+        expected: "automation executes between gates; a human approves the gate",
+    },
+    {
+        name: "gate → auto-approved",
+        re: /\bgate\s*[12]\b[^.\n]{0,30}auto[-\s]?approv\w*/gi,
+        expected: "automation executes between gates; a human approves the gate",
+    },
+    {
+        name: "gate bound to an auto value",
+        re: /\bgate\s*[12]\s*:\s*auto/gi,
+        expected: "Gate 1 / Gate 2 are human in every mode",
+    },
+    {
+        name: "gate offering an auto alternative",
+        re: /\bgate\s*[12]\b[^.\n]{0,30}\[[^\]\n]*auto[^\]\n]*\]/gi,
+        expected: "the only gate outcome is human approval — drop the auto alternative",
+    },
+    {
+        name: "stamp treated as authority",
+        re: /\bstamp\s+counts\b/gi,
+        expected: "an evaluator stamp is evidence presented at the gate, never the approval",
+    },
+    {
+        name: "gate prompt skipped",
+        re: /\bskips?\s+gate\s*[12]\b[^.\n]{0,30}(prompt|user)/gi,
+        expected: "present the gate; a passing pre-check is evidence, not approval",
+    },
+];
+/**
+ * Words that flip a claim from ASSERTING automated approval to FORBIDDING it.
+ * "Gate 2 is never auto-approved" states the contract — it must not be flagged.
+ */
+const NEGATION_RE = /\b(never|not|n't|no|none|cannot|can't|forbidden|prohibited|non-negotiable|mandatory|requires?\s+human|human\s+approval|explicitly\s+typed)\b/i;
+/**
+ * How far back from a match to look for the word that negates it. A negation
+ * governs the clause it introduces, so it sits immediately before the claim
+ * ("but never auto-approves Gate 2"), not in some unrelated later clause.
+ */
+const NEGATION_LOOKBEHIND = 48;
+/**
+ * True when the matched claim is negated rather than asserted.
+ *
+ * Scope matters enormously here. Testing the WHOLE line lets any incidental
+ * negation elsewhere in the sentence disarm a real violation — e.g.
+ * "auto-approves Gate 2 ... so no separate human click is required" is a
+ * genuine violation whose "no" belongs to a different clause entirely. A safety
+ * lint that misses its own threat model because of a distant "no" is worse than
+ * no lint: it reports green over the exact regression it exists to catch.
+ */
+function isNegated(line, matchStart, matchText) {
+    const before = line.slice(Math.max(0, matchStart - NEGATION_LOOKBEHIND), matchStart);
+    return NEGATION_RE.test(before) || NEGATION_RE.test(matchText);
+}
+/** True when the line is nothing but the suppression comment. */
+function isStandaloneMarker(line) {
+    return /^\s*<!--\s*lint-allow-gate-authority\s*-->\s*$/.test(line);
+}
+/** Scan one file's prose for statements granting automated gate authority. */
+export function scanForGateAuthority(root, relPath) {
+    const abs = path.join(root, relPath);
+    if (!fs.existsSync(abs))
+        return [];
+    const violations = [];
+    const lines = fs.readFileSync(abs, "utf-8").split("\n");
+    lines.forEach((text, idx) => {
+        // A marker on the offending line suppresses that line. A marker on its own
+        // line above suppresses the line below — the form used where a trailing
+        // comment would render into prose (table rows, list items).
+        //
+        // The standalone requirement matters: an INLINE marker must not leak onto
+        // the next line, or one suppressed line silently disarms its neighbour.
+        if (text.includes(ALLOW_MARKER))
+            return;
+        if (idx > 0 && isStandaloneMarker(lines[idx - 1]))
+            return;
+        // Negation is evaluated per MATCH, and EVERY match is examined — not just
+        // the first. A line may state the contract and then carve an exception out
+        // of it ("Gate 2 is never auto-approved, but fast mode auto-approves Gate 2
+        // when tests pass"): the negated first clause must not excuse the second.
+        for (const { re, expected } of PATTERNS) {
+            for (const m of text.matchAll(re)) {
+                if (isNegated(text, m.index, m[0]))
+                    continue;
+                violations.push({ file: relPath, line: idx + 1, found: text.trim(), expected });
+                return; // one finding per line is enough to locate and fix it
+            }
+        }
+    });
+    return violations;
+}
+/** Collect every `.md` file under `dir`, relative to `root`. */
+function collectMarkdown(root, dir, acc = []) {
+    const abs = path.join(root, dir);
+    if (!fs.existsSync(abs))
+        return acc;
+    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+        const rel = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name.startsWith(".git"))
+                continue;
+            collectMarkdown(root, rel, acc);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            acc.push(rel);
+        }
+    }
+    return acc;
+}
+// ─── Command-vs-skill drift ──────────────────────────────────────────────────
+//
+// A slash command and its same-named skill are two descriptions of one behavior,
+// and two descriptions drift. The rule (skill-authoring-rules.md → Commands vs
+// Skills): the command is a DISPATCHER — usage, flags, dispatch, and a concise
+// safety note pointing at the authority. The skill owns the procedure.
+//
+// When a command re-states the workflow, the two copies disagree the moment
+// either changes, and an agent reading the command follows a stale procedure it
+// has no reason to distrust. That is exactly the `/mk:fix` defect this lint
+// exists to keep closed: the command described a Simple path that skipped the
+// scout its own skill marked MANDATORY.
+//
+// Gate semantics are NOT re-detected here — `checkGateAuthority` above is the
+// one gate-phrase detector, deliberately shared. Two blacklists drift apart, and
+// the weaker one becomes the de-facto contract.
+/**
+ * The dispatchers this check contracts.
+ *
+ * Deliberately an allowlist, not "every same-name pair". Calibrating against all
+ * paired commands surfaced 7 REAL drift findings (0 false positives) in six
+ * commands outside this contract — autobuild, docs-init, help, retro, review,
+ * ship — e.g. `review.md` carries a full "### Execution Steps" procedure that
+ * duplicates its skill's. Those are pre-existing and each needs a considered
+ * rewrite, not a lint flip; widening this set is the follow-up that does them.
+ *
+ * So this set is a floor that holds the line where it was drawn, not a claim
+ * that the rest are clean. They are not. Widen it as each is thinned.
+ */
+const GOVERNED_DISPATCHERS = new Set(["fix", "cook", "plan", "advise"]);
+/** Governed same-name command/skill pairs — the only files this drift check reads. */
+function pairedCommands(root) {
+    const cmdDir = path.join(root, ".claude", "commands", "mk");
+    const skillsDir = path.join(root, ".claude", "skills");
+    if (!fs.existsSync(cmdDir) || !fs.existsSync(skillsDir))
+        return [];
+    return fs
+        .readdirSync(cmdDir)
+        .filter((f) => f.endsWith(".md"))
+        .filter((f) => GOVERNED_DISPATCHERS.has(f.replace(/\.md$/, "")))
+        // A command with no same-name skill has nowhere to delegate its procedure to,
+        // so the same prose there is correct (skill-authoring-rules.md: "not every
+        // command has a matching SKILL.md, and that is intentional").
+        .filter((f) => fs.existsSync(path.join(skillsDir, f.replace(/\.md$/, ""), "SKILL.md")))
+        .map((f) => path.join(".claude", "commands", "mk", f));
+}
+/**
+ * Prose that belongs to the SKILL, found in a command file.
+ *
+ * Scoped tightly on purpose. A command legitimately carries usage, flags, a
+ * dispatch line, and a safety note — flagging those would make the lint noise,
+ * and a noisy lint gets disabled. These patterns target the two things a
+ * dispatcher can never own: step-by-step procedure, and memory writes.
+ */
+const COMMAND_DRIFT_PATTERNS = [
+    {
+        name: "numbered workflow steps",
+        // "1. Do X" / "2. Then Y" — a procedure. One numbered line is a list; the
+        // pattern needs a SECOND step on a later line to fire, so a lone "1." in a
+        // safety note stays clean.
+        //
+        // `[ \t]*`, never `\s*`: `\s` matches newlines, so with `m` the match could
+        // begin on the preceding blank line and report a line number one too low —
+        // which silently pointed the allow-marker lookup at the wrong line.
+        re: /^[ \t]*2\.[ \t]+\S/gm,
+        expected: "the skill owns the procedure — the command dispatches to it",
+    },
+    {
+        name: "memory-write instruction",
+        re: /\b(Edit|write|append|update)\b[^.\n]{0,40}\.claude\/memory\//gi,
+        expected: "memory writes belong to the skill's capture step, not the command",
+    },
+    {
+        name: "memory store schema",
+        re: /\b(fixes|review-patterns|architecture-decisions|security-findings)\.(json|md)\b/gi,
+        expected: "the store's schema is the skill's business; the command must not restate it",
+    },
+    {
+        name: "complexity classification table",
+        re: /\|\s*(Simple|Standard|Complex|Moderate|Parallel)\s*\|/gi,
+        expected: "classification is the skill's routing decision, not the command's",
+    },
+];
+/** Scan one command file for skill-owned prose. */
+export function scanCommandForDrift(root, relPath) {
+    const abs = path.join(root, relPath);
+    if (!fs.existsSync(abs))
+        return [];
+    const findings = [];
+    const lines = fs.readFileSync(abs, "utf-8").split("\n");
+    const body = lines.join("\n");
+    for (const { re, expected } of COMMAND_DRIFT_PATTERNS) {
+        re.lastIndex = 0;
+        const m = re.exec(body);
+        if (!m)
+            continue;
+        // Locate the match's line for an actionable file:line.
+        const line = body.slice(0, m.index).split("\n").length;
+        if (lines[line - 1]?.includes(ALLOW_MARKER))
+            continue;
+        findings.push({ file: relPath, line, found: m[0].trim().slice(0, 80), expected });
+    }
+    return findings;
+}
+/**
+ * Command-vs-skill drift for every same-name pair.
+ *
+ * Scoped to PAIRED commands only. A standalone command (no matching skill) has
+ * nowhere to delegate its procedure to, so the same prose there is correct —
+ * per skill-authoring-rules.md, "not every command has a matching SKILL.md, and
+ * that is intentional".
+ */
+export function checkCommandDrift(root) {
+    const commands = pairedCommands(root);
+    if (commands.length === 0) {
+        return [{ name: "Command-vs-skill drift", status: "pass", detail: "no same-name command/skill pairs", section: "Gates" }];
+    }
+    const findings = commands.flatMap((rel) => scanCommandForDrift(root, rel));
+    if (findings.length === 0) {
+        return [
+            {
+                name: "No command-vs-skill drift",
+                status: "pass",
+                detail: `${commands.length} paired command(s) are dispatchers: ${commands.map((c) => path.basename(c, ".md")).join(", ")}`,
+                section: "Gates",
+            },
+        ];
+    }
+    return [
+        {
+            name: `Command-vs-skill drift (${findings.length})`,
+            status: "fail",
+            detail: findings
+                .map((f) => `${f.file}:${f.line} found "${f.found}" — expected "${f.expected}"`)
+                .join("\n         "),
+            section: "Gates",
+        },
+    ];
+}
+/**
+ * Run the gate-authority check over a tree of prose.
+ *
+ * `root` is the directory the scan is relative to; `scanDirs` are subtrees
+ * within it. Defaults to the canonical `.claude` tree, and is reused verbatim
+ * against the generated `plugin/` tree to prove canonical↔plugin parity.
+ */
+export function checkGateAuthority(root, opts = {}) {
+    const scanDirs = opts.scanDirs ?? [".claude"];
+    const present = scanDirs.filter((dir) => fs.existsSync(path.join(root, dir)));
+    if (present.length === 0) {
+        return [
+            {
+                name: "Gate-authority scan target",
+                status: opts.missingRootSeverity ?? "fail",
+                detail: `No scan target found under ${root}: ${scanDirs.join(", ")}`,
+                section: "Gates",
+            },
+        ];
+    }
+    const files = present.flatMap((dir) => collectMarkdown(root, dir));
+    const violations = files.flatMap((rel) => scanForGateAuthority(root, rel));
+    if (violations.length === 0) {
+        return [
+            {
+                name: "No automated gate-approval claims",
+                status: "pass",
+                detail: `${files.length} prose files scanned across ${present.join(", ")}`,
+                section: "Gates",
+            },
+        ];
+    }
+    const detail = violations
+        .map((v) => `${v.file}:${v.line} found "${v.found}" — expected "${v.expected}"`)
+        .join("\n         ");
+    return [
+        {
+            name: `Automated gate-approval claims (${violations.length})`,
+            status: "fail",
+            detail,
+            section: "Gates",
+        },
+    ];
+}
+//# sourceMappingURL=check-gate-authority.js.map

package/dist/core/check-gate-authority.js.map

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

package/dist/core/check-generic-core-tokens.d.ts

@@ -0,0 +1,12 @@
+export type GenericCoreTokenCategory = "provider-tool" | "model-or-tier" | "context-window" | "brand";
+export interface GenericCoreTokenFinding {
+    file: string;
+    line: number;
+    token: string;
+    category: GenericCoreTokenCategory;
+}
+/** Finds provider-specific prose in canonical skill bodies. Initial callers report, not block. */
+export declare function findGenericCoreTokens(root: string, scanDir?: string): GenericCoreTokenFinding[];
+/** Compact deterministic baseline for validation output and future cleanup tracking. */
+export declare function summarizeGenericCoreTokens(findings: readonly GenericCoreTokenFinding[]): string;
+//# sourceMappingURL=check-generic-core-tokens.d.ts.map

package/dist/core/check-generic-core-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-generic-core-tokens.d.ts","sourceRoot":"","sources":["../../src/core/check-generic-core-tokens.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,wBAAwB,GAAG,eAAe,GAAG,eAAe,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAEtG,MAAM,WAAW,uBAAuB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,wBAAwB,CAAC;CACnC;AA8CD,kGAAkG;AAClG,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAW,GAAG,uBAAuB,EAAE,CAejG;AAED,wFAAwF;AACxF,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,GAAG,MAAM,CAM/F"}

package/dist/core/check-generic-core-tokens.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+const TOKEN_RULES = [
+    { category: "provider-tool", pattern: /\bAskUserQuestion\b|\bAgent\s*\(|\bTask\s*\(/g },
+    { category: "model-or-tier", pattern: /\b(?:haiku|sonnet|opus|claude-[a-z0-9.-]+)\b/gi },
+    { category: "context-window", pattern: /\b\d{2,3}K\b|\b(?:[5-9]\d|100)%\s+(?:of\s+)?(?:the\s+)?(?:context|token)\b/gi },
+    { category: "brand", pattern: /\bmeowkit\b/gi },
+];
+function markdownFiles(root, dir = "skills", files = []) {
+    const absolute = path.join(root, dir);
+    if (!fs.existsSync(absolute))
+        return files;
+    for (const entry of fs.readdirSync(absolute, { withFileTypes: true })) {
+        const relative = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            markdownFiles(root, relative, files);
+        else if (dir !== "skills" && entry.isFile() && entry.name.endsWith(".md"))
+            files.push(relative);
+    }
+    return files.sort();
+}
+function bodyLines(content) {
+    const lines = content.split(/\r?\n/);
+    const bodyStart = lines[0] === "---" ? lines.indexOf("---", 1) + 1 : 0;
+    let codeFence = false;
+    return lines.slice(bodyStart).map((text, index) => {
+        if (/^\s*```/.test(text))
+            codeFence = !codeFence;
+        return { text, line: bodyStart + index + 1, codeFence };
+    });
+}
+function isCliBrandMention(line, index, token, codeFence) {
+    const before = line.slice(0, index);
+    const after = line.slice(index + token.length);
+    const lowercaseCommand = token === "mewkit" && /^\s+\S+/.test(after);
+    return ((lowercaseCommand && /\bnpx\s+$/i.test(before)) ||
+        (lowercaseCommand && (before.match(/\`/g)?.length ?? 0) % 2 === 1) ||
+        (codeFence && /^\s*(?:[$>]\s*)?(?:npx\s+)?mewkit\b/.test(line)));
+}
+/** Finds provider-specific prose in canonical skill bodies. Initial callers report, not block. */
+export function findGenericCoreTokens(root, scanDir = "skills") {
+    const findings = [];
+    for (const file of markdownFiles(root, scanDir)) {
+        const lines = bodyLines(fs.readFileSync(path.join(root, file), "utf-8"));
+        for (const line of lines) {
+            for (const rule of TOKEN_RULES) {
+                rule.pattern.lastIndex = 0;
+                for (const match of line.text.matchAll(rule.pattern)) {
+                    if (rule.category === "brand" && isCliBrandMention(line.text, match.index ?? 0, match[0], line.codeFence))
+                        continue;
+                    findings.push({ file, line: line.line, token: match[0], category: rule.category });
+                }
+            }
+        }
+    }
+    return findings;
+}
+/** Compact deterministic baseline for validation output and future cleanup tracking. */
+export function summarizeGenericCoreTokens(findings) {
+    const counts = new Map();
+    for (const finding of findings)
+        counts.set(finding.category, (counts.get(finding.category) ?? 0) + 1);
+    return ["provider-tool", "model-or-tier", "context-window", "brand"]
+        .map((category) => `${category}=${counts.get(category) ?? 0}`)
+        .join(", ");
+}
+//# sourceMappingURL=check-generic-core-tokens.js.map

package/dist/core/check-generic-core-tokens.js.map

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

package/dist/core/check-operation-conformance.d.ts

@@ -0,0 +1,27 @@
+import { type LogicalOperation, type OperationSupport } from "./provider-operations.js";
+/**
+ * Claude Code host tool → the logical operation it realizes. Trusted constant; a unit
+ * test asserts every value is a real `LogicalOperation`, so it can never drift from the
+ * operation set. Keys are BASE tool names (scoped forms like `Bash(git:*)` are normalized
+ * to `Bash` before lookup).
+ */
+export declare const TOOL_TO_OPERATION: Record<string, LogicalOperation>;
+export interface OperationConformanceFinding {
+    skill: string;
+    operation: LogicalOperation;
+    provider: string;
+    support: OperationSupport;
+}
+/**
+ * For every installed skill, resolve the operations it references (via declared tools)
+ * and record, per advertised provider, each operation whose support is not `supported`.
+ * Disclosed degradation (`local-fallback`) and hard gaps (`unsupported`/`unknown`) are all
+ * surfaced so a cross-harness projection never advertises an operation the host cannot honor.
+ */
+export declare function findOperationConformance(claudeDir: string): OperationConformanceFinding[];
+/** `unsupported`/`unknown` = the operation genuinely fails or is untested on that provider;
+ * `local-fallback` = disclosed graceful degradation. Only the former are blocking-worthy. */
+export declare function isBlockingGap(finding: OperationConformanceFinding): boolean;
+/** Compact deterministic per-provider summary for validate output. */
+export declare function summarizeOperationConformance(findings: readonly OperationConformanceFinding[]): string;
+//# sourceMappingURL=check-operation-conformance.d.ts.map

package/dist/core/check-operation-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-operation-conformance.d.ts","sourceRoot":"","sources":["../../src/core/check-operation-conformance.ts"],"names":[],"mappings":"AAYA,OAAO,EAAqB,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE3G;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAS9D,CAAC;AAyBF,MAAM,WAAW,2BAA2B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,2BAA2B,EAAE,CAczF;AAED;6FAC6F;AAC7F,wBAAgB,aAAa,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAE3E;AAED,sEAAsE;AACtE,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,SAAS,2BAA2B,EAAE,GAAG,MAAM,CAOtG"}

package/dist/core/check-operation-conformance.js

@@ -0,0 +1,91 @@
+// Operation-level conformance: which logical operations does each installed skill
+// reference, and are they honored on every advertised provider? Without this, a
+// cross-harness payload can silently ship a skill whose operation the target host
+// cannot perform — the exact "silent degrade" the portability work exists to prevent.
+//
+// The reference signal is a skill's `allowed-tools` frontmatter: the host tools its
+// author declared. That is DESCRIPTIVE metadata, not a runnable string — each tool
+// maps to a LOGICAL operation through a trusted constant, exactly as `invocation.id`
+// does. Frontmatter still cannot NAME a logical operation (see provider-operations.ts):
+// it names a host tool; the adapter, not the author, resolves the operation.
+import { enumerateArtifacts, readFrontmatter } from "./build-inventory.js";
+import { ADAPTED_PROVIDERS } from "./provider-adapter.js";
+import { getOperationShape } from "./provider-operations.js";
+/**
+ * Claude Code host tool → the logical operation it realizes. Trusted constant; a unit
+ * test asserts every value is a real `LogicalOperation`, so it can never drift from the
+ * operation set. Keys are BASE tool names (scoped forms like `Bash(git:*)` are normalized
+ * to `Bash` before lookup).
+ */
+export const TOOL_TO_OPERATION = {
+    AskUserQuestion: "ask_user",
+    Bash: "run_shell",
+    Agent: "delegate_agent",
+    Task: "delegate_agent",
+    TaskCreate: "manage_plan",
+    TaskUpdate: "manage_plan",
+    TaskList: "manage_plan",
+    TaskGet: "manage_plan",
+};
+/** `Bash(git:*)` → `Bash`, `Task(Explore)` → `Task`, ` Read ` → `Read`. */
+function baseToolName(raw) {
+    return raw.trim().replace(/\(.*$/, "").trim();
+}
+/** Read a skill's declared host tools from `allowed-tools` (YAML array or comma scalar). */
+function declaredTools(meta) {
+    const value = meta["allowed-tools"];
+    if (Array.isArray(value))
+        return value.filter((tool) => typeof tool === "string");
+    if (typeof value === "string")
+        return value.split(",").map((tool) => tool.trim()).filter(Boolean);
+    return [];
+}
+/** The distinct logical operations a set of declared tools references. */
+function operationsForTools(tools) {
+    const operations = new Set();
+    for (const tool of tools) {
+        const operation = TOOL_TO_OPERATION[baseToolName(tool)];
+        if (operation)
+            operations.add(operation);
+    }
+    return [...operations];
+}
+/**
+ * For every installed skill, resolve the operations it references (via declared tools)
+ * and record, per advertised provider, each operation whose support is not `supported`.
+ * Disclosed degradation (`local-fallback`) and hard gaps (`unsupported`/`unknown`) are all
+ * surfaced so a cross-harness projection never advertises an operation the host cannot honor.
+ */
+export function findOperationConformance(claudeDir) {
+    const { refs } = enumerateArtifacts(claudeDir);
+    const findings = [];
+    for (const ref of refs) {
+        if (ref.type !== "skill")
+            continue;
+        const operations = operationsForTools(declaredTools(readFrontmatter(ref.abs)));
+        for (const operation of operations) {
+            for (const provider of ADAPTED_PROVIDERS) {
+                const support = getOperationShape(provider, operation).support;
+                if (support !== "supported")
+                    findings.push({ skill: ref.id, operation, provider, support });
+            }
+        }
+    }
+    return findings;
+}
+/** `unsupported`/`unknown` = the operation genuinely fails or is untested on that provider;
+ * `local-fallback` = disclosed graceful degradation. Only the former are blocking-worthy. */
+export function isBlockingGap(finding) {
+    return finding.support === "unsupported" || finding.support === "unknown";
+}
+/** Compact deterministic per-provider summary for validate output. */
+export function summarizeOperationConformance(findings) {
+    const byProvider = new Map();
+    for (const finding of findings)
+        byProvider.set(finding.provider, (byProvider.get(finding.provider) ?? 0) + 1);
+    return [...byProvider.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([provider, count]) => `${provider}=${count}`)
+        .join(", ");
+}
+//# sourceMappingURL=check-operation-conformance.js.map

package/dist/core/check-operation-conformance.js.map

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

package/dist/core/check-plugin-parity.d.ts

@@ -0,0 +1,15 @@
+import type { CheckResult } from "../commands/validate.js";
+export interface ParityDivergence {
+    file: string;
+    kind: "missing-in-plugin" | "stale-in-plugin" | "extra-in-plugin";
+}
+/**
+ * Regenerate the payload into a temp dir and diff it against `plugin/`.
+ *
+ * Returns every divergence. The caller decides severity — `validate` fails, so
+ * that a stale plugin cannot reach a release.
+ */
+export declare function diffPluginParity(projectRoot: string): ParityDivergence[];
+/** Parity as a validate CheckResult. */
+export declare function checkPluginParity(projectRoot: string): CheckResult[];
+//# sourceMappingURL=check-plugin-parity.d.ts.map

package/dist/core/check-plugin-parity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-plugin-parity.d.ts","sourceRoot":"","sources":["../../src/core/check-plugin-parity.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAqC3D,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;CAClE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAuCxE;AAED,wCAAwC;AACxC,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE,CA6CpE"}