vigiles 4.0.2 → 4.1.0

package/dist/adapter-registry.d.ts

@@ -31,12 +31,56 @@ export interface DetectResult {
 export declare function detectAdapterResult(root: string): DetectResult;
 /** The detected adapter (highest specificity), else the default (Claude Code). */
 export declare function detectAdapter(root: string): HarnessAdapter;
-/** Look up a registered adapter by `name` (e.g. for a `--harness` override). */
+/** Lower-case, trim, and map a short alias to its canonical adapter name. */
+export declare function normalizeHarnessName(name: string): string;
+/** Look up a registered adapter by `name` (alias-aware, e.g. `claude`). */
 export declare function getAdapter(name: string): HarnessAdapter | undefined;
+/**
+ * The adapter whose instruction file is `filename` (e.g. `AGENTS.md` → codex,
+ * `CLAUDE.md` → claude-code), if any. The per-spec disambiguation signal: a
+ * `<file>.spec.ts` compiles a `<file>` instruction file, so the filename names
+ * the harness more specifically than config/detect for THAT spec.
+ */
+export declare function adapterForInstructionFile(filename: string): HarnessAdapter | undefined;
 /**
  * Resolve the adapter for a command: an explicit `--harness <name>` wins (throws
  * if unknown); otherwise auto-detect from `root`. The single entry point the CLI
  * uses so detection + override live in one place.
  */
 export declare function resolveAdapter(root: string, harness?: string): HarnessAdapter;
+/** Normalize a config `harness` value (string | string[]) to a canonical list. */
+export declare function normalizeHarnessList(harness?: string | readonly string[]): string[];
+/**
+ * The adapter chosen for a single-dialect operation. A discriminated union so an
+ * invalid state — a "notice" with no message, or a clean pick carrying a stray
+ * string — is unrepresentable: `kind: "ok"` has no `notice`, `kind: "notice"`
+ * always carries a non-empty one. Both variants carry the `adapter`.
+ */
+export type HarnessSelection = {
+    readonly kind: "ok";
+    readonly adapter: HarnessAdapter;
+} | {
+    readonly kind: "notice";
+    readonly adapter: HarnessAdapter;
+    readonly notice: string;
+};
+/**
+ * Resolve the single harness a compile/lint operation should use, with explicit
+ * precedence — the deterministic replacement for sniffing the cwd:
+ *
+ *   1. `--harness=` flag (wins; throws if unknown).
+ *   2. config `harness` resolving to a single entry → use it.
+ *   3. config `harness` with multiple entries → use the first, with a loud notice.
+ *   4. no config → auto-detect, with a loud notice when the repo is ambiguous.
+ *
+ * `configHarness` is parsed once (alias-normalized) at the call site and passed
+ * in; this function re-normalizes idempotently so it's safe either way. Pure
+ * (besides reading `root`'s layout for detection) so the precedence is
+ * unit-testable without a real compile. See research/multi-harness-compile.md.
+ */
+export declare function resolveHarnessSelection(opts: {
+    root: string;
+    flag?: string;
+    configHarness?: string | readonly string[];
+}): HarnessSelection;
 //# sourceMappingURL=adapter-registry.d.ts.map

package/dist/adapter-registry.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ADAPTERS = exports.defaultAdapter = void 0;
 exports.detectAdapterResult = detectAdapterResult;
 exports.detectAdapter = detectAdapter;
+exports.normalizeHarnessName = normalizeHarnessName;
 exports.getAdapter = getAdapter;
+exports.adapterForInstructionFile = adapterForInstructionFile;
 exports.resolveAdapter = resolveAdapter;
+exports.normalizeHarnessList = normalizeHarnessList;
+exports.resolveHarnessSelection = resolveHarnessSelection;
 const adapter_js_1 = require("./adapters/claude-code/adapter.js");
 const adapter_js_2 = require("./adapters/codex/adapter.js");
 /** The default adapter when detection finds no harness markers. */
@@ -32,9 +36,32 @@ function detectAdapterResult(root) {
 function detectAdapter(root) {
     return detectAdapterResult(root).adapter;
 }
-/** Look up a registered adapter by `name` (e.g. for a `--harness` override). */
+/**
+ * Short-name aliases accepted anywhere a harness name is supplied (config,
+ * `--harness=`). `init` historically uses `"claude"`; the canonical adapter name
+ * is `"claude-code"`. Normalizing here keeps selection and the registry in sync.
+ */
+const HARNESS_ALIASES = {
+    claude: "claude-code",
+};
+/** Lower-case, trim, and map a short alias to its canonical adapter name. */
+function normalizeHarnessName(name) {
+    const n = name.trim().toLowerCase();
+    return HARNESS_ALIASES[n] ?? n;
+}
+/** Look up a registered adapter by `name` (alias-aware, e.g. `claude`). */
 function getAdapter(name) {
-    return exports.ADAPTERS.find((a) => a.name === name);
+    const canonical = normalizeHarnessName(name);
+    return exports.ADAPTERS.find((a) => a.name === canonical);
+}
+/**
+ * The adapter whose instruction file is `filename` (e.g. `AGENTS.md` → codex,
+ * `CLAUDE.md` → claude-code), if any. The per-spec disambiguation signal: a
+ * `<file>.spec.ts` compiles a `<file>` instruction file, so the filename names
+ * the harness more specifically than config/detect for THAT spec.
+ */
+function adapterForInstructionFile(filename) {
+    return exports.ADAPTERS.find((a) => a.layout.instructionFile === filename);
 }
 /**
  * Resolve the adapter for a command: an explicit `--harness <name>` wins (throws
@@ -42,7 +69,7 @@ function getAdapter(name) {
  * uses so detection + override live in one place.
  */
 function resolveAdapter(root, harness) {
-    if (harness !== undefined) {
+    if (harness !== undefined && harness !== "") {
         const a = getAdapter(harness);
         if (!a) {
             const known = exports.ADAPTERS.map((x) => x.name).join(", ");
@@ -52,4 +79,52 @@ function resolveAdapter(root, harness) {
     }
     return detectAdapter(root);
 }
+/** Normalize a config `harness` value (string | string[]) to a canonical list. */
+function normalizeHarnessList(harness) {
+    if (harness === undefined)
+        return [];
+    const arr = Array.isArray(harness) ? harness : [harness];
+    return arr.map(normalizeHarnessName).filter(Boolean);
+}
+/**
+ * Resolve the single harness a compile/lint operation should use, with explicit
+ * precedence — the deterministic replacement for sniffing the cwd:
+ *
+ *   1. `--harness=` flag (wins; throws if unknown).
+ *   2. config `harness` resolving to a single entry → use it.
+ *   3. config `harness` with multiple entries → use the first, with a loud notice.
+ *   4. no config → auto-detect, with a loud notice when the repo is ambiguous.
+ *
+ * `configHarness` is parsed once (alias-normalized) at the call site and passed
+ * in; this function re-normalizes idempotently so it's safe either way. Pure
+ * (besides reading `root`'s layout for detection) so the precedence is
+ * unit-testable without a real compile. See research/multi-harness-compile.md.
+ */
+function resolveHarnessSelection(opts) {
+    const { root, flag, configHarness } = opts;
+    if (flag !== undefined && flag !== "") {
+        return { kind: "ok", adapter: resolveAdapter(root, flag) };
+    }
+    const list = normalizeHarnessList(configHarness);
+    if (list.length === 1) {
+        return { kind: "ok", adapter: resolveAdapter(root, list[0]) };
+    }
+    if (list.length > 1) {
+        const adapter = resolveAdapter(root, list[0]);
+        return {
+            kind: "notice",
+            adapter,
+            notice: `repo targets ${list.join(", ")} — compiling for ${adapter.name}; override with --harness=`,
+        };
+    }
+    const det = detectAdapterResult(root);
+    if (det.ambiguousWith.length > 0) {
+        return {
+            kind: "notice",
+            adapter: det.adapter,
+            notice: `repo matches ${[det.adapter.name, ...det.ambiguousWith].join(", ")} — set "harness" in .vigilesrc.json or use --harness=`,
+        };
+    }
+    return { kind: "ok", adapter: det.adapter };
+}
 //# sourceMappingURL=adapter-registry.js.map

package/dist/cli.js

@@ -21,9 +21,9 @@ const types_js_1 = require("./core/types.js");
 const test_coverage_js_1 = require("./test-coverage.js");
 const scan_js_1 = require("./scan.js");
 const adapter_registry_js_1 = require("./adapter-registry.js");
+const skill_harness_js_1 = require("./skill-harness.js");
 const leaderboard_js_1 = require("./leaderboard.js");
 const compile_js_1 = require("./core/compile.js");
-const dialect_js_1 = require("./adapters/claude-code/dialect.js");
 const proofs_js_1 = require("./core/proofs.js");
 const inline_js_1 = require("./core/inline.js");
 const frontmatter_js_1 = require("./core/frontmatter.js");
@@ -140,12 +140,12 @@ function compileGeneratorSkillToFile(specPath, source) {
     return false;
 }
 /** Compile a ClaudeSpec → its primary + any additional targets. */
-function compileClaudeToFile(spec, specPath, config) {
+function compileClaudeToFile(spec, specPath, config, dialect) {
     const basePath = process.cwd();
     const { markdown, errors, linterResults, targets } = (0, compile_js_1.compileClaude)(spec, {
         basePath,
         specFile: specPath,
-        dialect: dialect_js_1.claudeCodeDialect,
+        dialect,
         maxRules: config.maxRules,
         maxTokens: config.maxTokens,
         maxSectionLines: config.maxSectionLines,
@@ -175,15 +175,54 @@ function compileClaudeToFile(spec, specPath, config) {
     console.log(`  ${String(Object.keys(spec.rules).length)} rules (${String(linterCount)} linter-verified)`);
     return true;
 }
+/**
+ * Branch 3 of the mirror story (research/multi-harness-compile.md): when a repo
+ * declares ≥2 harnesses and nothing else fans out the instruction file, write a
+ * byte-identical copy to each other harness's instruction file (e.g. CLAUDE.md →
+ * AGENTS.md). A copy — not a symlink — because it works everywhere and carries
+ * the source's embedded integrity hash by construction, so a hand-edit of the
+ * mirror trips the existing `integrity` check. Never fights a sync tool or
+ * clobbers a target that owns its own spec.
+ */
+function writeInstructionMirrors(primaryOutput, harnesses) {
+    if (harnesses.length < 2)
+        return;
+    const cwd = process.cwd();
+    // A sync tool (Ruler/rulesync) owns fan-out — don't fight it.
+    if ((0, compose_js_1.detectSyncTools)(cwd).length > 0)
+        return;
+    const primaryName = (0, node_path_1.basename)(primaryOutput);
+    const primaryAbs = (0, node_path_1.resolve)(cwd, primaryOutput);
+    if (!(0, node_fs_1.existsSync)(primaryAbs))
+        return;
+    const content = (0, node_fs_1.readFileSync)(primaryAbs, "utf-8");
+    for (const name of harnesses) {
+        const adapter = (0, adapter_registry_js_1.getAdapter)(name);
+        if (!adapter)
+            continue;
+        const target = adapter.layout.instructionFile;
+        if (target === primaryName)
+            continue; // the file we just compiled
+        // Never clobber a target that has its own spec (a genuinely separate file).
+        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, `${target}.spec.ts`)))
+            continue;
+        const targetAbs = (0, node_path_1.resolve)(cwd, target);
+        if ((0, node_fs_1.existsSync)(targetAbs) && (0, node_fs_1.readFileSync)(targetAbs, "utf-8") === content) {
+            continue; // already byte-identical
+        }
+        (0, node_fs_1.writeFileSync)(targetAbs, content);
+        console.log(`  ↳ mirrored ${primaryName} → ${target} (byte-identical)`);
+    }
+}
 /** Compile a declarative SkillSpec → SKILL.md. */
-function compileSkillToFile(spec, specPath) {
+function compileSkillToFile(spec, specPath, dialect) {
     const outputPath = specPath.replace(/\.spec\.ts$/, "");
     const { markdown, errors } = (0, compile_js_1.compileSkill)(spec, {
         basePath: process.cwd(),
         specFile: specPath,
-        // Pick the SKILL.md frontmatter profile from the detected harness — a Codex
+        // The SKILL.md frontmatter profile comes from the resolved harness — a Codex
         // repo gets a minimal (name + description) SKILL.md; CC gets the full set.
-        dialect: (0, adapter_registry_js_1.detectAdapter)(process.cwd()).dialect,
+        dialect,
     });
     (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(process.cwd(), outputPath), markdown);
     if (errors.length === 0) {
@@ -195,12 +234,12 @@ function compileSkillToFile(spec, specPath) {
     return false;
 }
 /** Compile a subagent spec → agents/<name>.md (with its result-contract section). */
-function compileAgentToFile(spec, specPath) {
+function compileAgentToFile(spec, specPath, dialect) {
     const outputPath = specPath.replace(/\.spec\.ts$/, "");
     const { markdown, errors } = (0, compile_js_1.compileAgent)(spec, {
         basePath: process.cwd(),
         specFile: specPath,
-        dialect: (0, adapter_registry_js_1.detectAdapter)(process.cwd()).dialect,
+        dialect,
     });
     (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(process.cwd(), outputPath), markdown);
     if (errors.length === 0) {
@@ -241,8 +280,21 @@ async function collectAgentNames() {
     }
     return names;
 }
-async function compile(specPaths, config) {
+async function compile(specPaths, config, opts = {}) {
     let allValid = true;
+    // Parse the declared harness set ONCE (alias-normalized) and feed both the
+    // dialect pick and the mirror from it — no re-parsing, no cwd-sniffing in the
+    // helpers. A loud notice (never a silent guess) on a multi-harness or
+    // ambiguous-detection pick.
+    const declaredHarnesses = (0, adapter_registry_js_1.normalizeHarnessList)(config.harness);
+    const selection = (0, adapter_registry_js_1.resolveHarnessSelection)({
+        root: process.cwd(),
+        flag: opts.harnessFlag,
+        configHarness: declaredHarnesses,
+    });
+    if (selection.kind === "notice")
+        console.log(`⚠ ${selection.notice}`);
+    const dialect = selection.adapter.dialect;
     // Resolved lazily on the first railway spec — every delegate() target is
     // checked against the agents defined anywhere in the project.
     let knownAgents = null;
@@ -262,15 +314,36 @@ async function compile(specPaths, config) {
             continue;
         }
         if (spec._specType === "claude") {
-            if (!compileClaudeToFile(spec, specPath, config))
+            // Spec-target disambiguation: a CLAUDE.md.spec.ts is a claude-code file, an
+            // AGENTS.md.spec.ts a codex one — the strongest dialect signal for THIS
+            // spec. The flag still overrides; absent one, the spec's own target wins
+            // over config/detect. (Skill/agent targets don't name a harness, so they
+            // keep the run-level dialect.)
+            const targetFile = (0, node_path_1.basename)(specPath).replace(/\.spec\.ts$/, "");
+            const specDialect = opts.harnessFlag === undefined
+                ? ((0, adapter_registry_js_1.adapterForInstructionFile)(targetFile)?.dialect ?? dialect)
+                : dialect;
+            if (compileClaudeToFile(spec, specPath, config, specDialect)) {
+                writeInstructionMirrors(specPath.replace(/\.spec\.ts$/, ""), declaredHarnesses);
+            }
+            else {
                 allValid = false;
+            }
         }
         else if (spec._specType === "skill") {
-            if (!compileSkillToFile(spec, specPath))
+            // Cross-harness verify: flag CC-only frontmatter a declared minimal-profile
+            // harness (Codex/OpenCode) would silently drop.
+            const forHarnesses = declaredHarnesses.length > 0
+                ? declaredHarnesses
+                : [selection.adapter.name];
+            for (const w of (0, skill_harness_js_1.skillFrontmatterDropWarnings)(spec, forHarnesses)) {
+                console.log(`⚠ ${w}`);
+            }
+            if (!compileSkillToFile(spec, specPath, dialect))
                 allValid = false;
         }
         else if (spec._specType === "agent") {
-            if (!compileAgentToFile(spec, specPath))
+            if (!compileAgentToFile(spec, specPath, dialect))
                 allValid = false;
         }
         else if (spec._specType === "railway") {
@@ -1735,16 +1808,44 @@ async function setup(args) {
         console.log("\n  Non-markdown agent configs detected. Use a sync tool to convert:");
         console.log("    npm install -D rule-porter");
     }
-    // Strict config.
-    if (strict) {
-        const configPath = (0, node_path_1.resolve)(process.cwd(), ".vigilesrc.json");
-        if (!(0, node_fs_1.existsSync)(configPath)) {
-            (0, node_fs_1.writeFileSync)(configPath, JSON.stringify({ rules: { "require-spec": "error", "require-skill-spec": "error" } }, null, 2) + "\n");
-            console.log("✓ Created .vigilesrc.json with strict rules");
-            written.push(".vigilesrc.json");
+    // Project config — record the harness(es) so compile/lint select the dialect
+    // deterministically (no cwd sniffing), plus strict rule severities on --strict.
+    writeProjectConfig({ harnesses, strict, written });
+    printSetupSummary({ plan, strict, targets, needsMigration, written });
+}
+/** Canonical, de-duplicated harness list → a config value (string when one). */
+function harnessConfigValue(harnesses) {
+    const canon = [...new Set(harnesses.map(adapter_registry_js_1.normalizeHarnessName))];
+    return canon.length === 1 ? canon[0] : canon;
+}
+/**
+ * Merge the resolved harness(es) (and strict rule severities) into
+ * `.vigilesrc.json` without clobbering existing keys — an existing `harness`
+ * stays, a missing one is added, a malformed file is left untouched.
+ */
+function writeProjectConfig(opts) {
+    const configPath = (0, node_path_1.resolve)(process.cwd(), ".vigilesrc.json");
+    const existed = (0, node_fs_1.existsSync)(configPath);
+    let existing = {};
+    if (existed) {
+        try {
+            existing = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        }
+        catch {
+            return; // user-owned malformed config — never clobber it
         }
     }
-    printSetupSummary({ plan, strict, targets, needsMigration, written });
+    const merged = (0, setup_plan_js_1.mergeProjectConfig)(existing, {
+        harness: harnessConfigValue(opts.harnesses),
+        strict: opts.strict,
+    });
+    if (!merged)
+        return;
+    (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(merged, null, 2) + "\n");
+    console.log(`✓ ${existed ? "Updated" : "Created"} .vigilesrc.json`);
+    if (!opts.written.includes(".vigilesrc.json")) {
+        opts.written.push(".vigilesrc.json");
+    }
 }
 // ---------------------------------------------------------------------------
 // Strengthen: guidance() → enforce() suggestions
@@ -2367,7 +2468,10 @@ async function main() {
                 console.log("Run `vigiles init` to create one.");
                 process.exit(0);
             }
-            const valid = await compile(specs, config);
+            const harnessFlag = args
+                .find((a) => a.startsWith("--harness="))
+                ?.slice("--harness=".length);
+            const valid = await compile(specs, config, { harnessFlag });
             console.log("");
             if (valid) {
                 console.log("Compilation complete.");

package/dist/core/types.d.ts

@@ -127,6 +127,16 @@ export interface VigilesConfig {
     }>;
     /** Orphan-docs check configuration. Include/exclude globs, tsconfig-style. */
     orphans?: OrphansConfig;
+    /**
+     * The harness(es) this repo targets — selects the compile dialect / skill
+     * frontmatter profile / instruction-file shape, instead of sniffing the cwd.
+     * A single name (`"codex"`) for the common single-harness repo, or an array
+     * (`["claude-code", "codex"]`) declaring the supported set. Written by
+     * `vigiles init`. Omitted → the CLI auto-detects (backwards-compatible).
+     * Canonical adapter names; `"claude"` is accepted as an alias for
+     * `"claude-code"`. See research/multi-harness-compile.md.
+     */
+    harness?: string | string[];
 }
 /** Valid marker types for rule detection. */
 export type MarkerType = "headings" | "checkboxes";

package/dist/setup-plan.d.ts

@@ -44,6 +44,17 @@ export interface ParsedSetupArgs {
 export declare function parseSetupArgs(args: readonly string[]): ParsedSetupArgs;
 /** The non-interactive defaults: both pillars, CI, and the plugin. */
 export declare function defaultPlan(strict?: boolean): SetupPlan;
+/**
+ * Pure config-merge for what `vigiles init` writes to `.vigilesrc.json`: record
+ * the `harness` if absent, add strict rule severities if `--strict`, NEVER
+ * clobber an existing key. Returns the merged config, or `null` when nothing
+ * changed (so the IO layer skips the write). The IO (read/parse/write + the
+ * malformed-file guard) stays in cli.ts.
+ */
+export declare function mergeProjectConfig(existing: Record<string, unknown>, opts: {
+    harness: string | string[];
+    strict: boolean;
+}): Record<string, unknown> | null;
 /**
  * Whether to drop into interactive prompts: a human at a TTY who passed neither
  * `--yes` nor an explicit `--target`, and who hasn't already pinned every choice

package/dist/setup-plan.js

@@ -12,6 +12,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSetupArgs = parseSetupArgs;
 exports.defaultPlan = defaultPlan;
+exports.mergeProjectConfig = mergeProjectConfig;
 exports.shouldPrompt = shouldPrompt;
 exports.planPluginInstall = planPluginInstall;
 exports.resolvePlan = resolvePlan;
@@ -52,6 +53,32 @@ function defaultPlan(strict = false) {
         force: false,
     };
 }
+/**
+ * Pure config-merge for what `vigiles init` writes to `.vigilesrc.json`: record
+ * the `harness` if absent, add strict rule severities if `--strict`, NEVER
+ * clobber an existing key. Returns the merged config, or `null` when nothing
+ * changed (so the IO layer skips the write). The IO (read/parse/write + the
+ * malformed-file guard) stays in cli.ts.
+ */
+function mergeProjectConfig(existing, opts) {
+    const config = { ...existing };
+    let changed = false;
+    if (config.harness === undefined) {
+        config.harness = opts.harness;
+        changed = true;
+    }
+    if (opts.strict) {
+        const rules = { ...config.rules };
+        for (const r of ["require-spec", "require-skill-spec"]) {
+            if (rules[r] === undefined) {
+                rules[r] = "error";
+                changed = true;
+            }
+        }
+        config.rules = rules;
+    }
+    return changed ? config : null;
+}
 /**
  * Whether to drop into interactive prompts: a human at a TTY who passed neither
  * `--yes` nor an explicit `--target`, and who hasn't already pinned every choice

package/dist/skill-harness.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Cross-harness skill-frontmatter verification (slice 3 of
+ * research/multi-harness-compile.md, the *verify* half).
+ *
+ * A skill's `SKILL.md` references are harness-agnostic; the one harness-specific
+ * surface is the frontmatter PROFILE. The `claude-code` profile emits CC-only
+ * keys (`disable-model-invocation`, `argument-hint`); the `minimal` profile
+ * (Codex, OpenCode) omits them. So a skill that sets those keys, in a repo that
+ * also targets a minimal-profile harness, has a silent semantic gap: the
+ * constraint the author expressed won't take effect there.
+ *
+ * This reports that gap. It is ASSUMPTION-FREE — the minimal profile *drops* the
+ * keys, so the warning states a fact about vigiles's own output, not a guess
+ * about another tool's parser tolerance.
+ */
+import type { SkillSpec } from "./core/spec.js";
+/** The Claude-Code-only frontmatter keys a skill spec would emit. */
+export declare function claudeOnlyFrontmatterKeys(spec: SkillSpec): string[];
+/**
+ * Warn for each declared harness whose `minimal` SKILL.md profile would DROP a
+ * skill's Claude-Code-only frontmatter. Empty when the skill uses no such keys or
+ * no declared harness is minimal-profile.
+ */
+export declare function skillFrontmatterDropWarnings(spec: SkillSpec, harnessNames: readonly string[]): string[];
+//# sourceMappingURL=skill-harness.d.ts.map

package/dist/skill-harness.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeOnlyFrontmatterKeys = claudeOnlyFrontmatterKeys;
+exports.skillFrontmatterDropWarnings = skillFrontmatterDropWarnings;
+const adapter_registry_js_1 = require("./adapter-registry.js");
+/** The Claude-Code-only frontmatter keys a skill spec would emit. */
+function claudeOnlyFrontmatterKeys(spec) {
+    const keys = [];
+    if (spec.disableModelInvocation !== undefined) {
+        keys.push("disable-model-invocation");
+    }
+    if (spec.argumentHint || (spec.inputs && spec.inputs.length > 0)) {
+        keys.push("argument-hint");
+    }
+    return keys;
+}
+/**
+ * Warn for each declared harness whose `minimal` SKILL.md profile would DROP a
+ * skill's Claude-Code-only frontmatter. Empty when the skill uses no such keys or
+ * no declared harness is minimal-profile.
+ */
+function skillFrontmatterDropWarnings(spec, harnessNames) {
+    const ccKeys = claudeOnlyFrontmatterKeys(spec);
+    if (ccKeys.length === 0)
+        return [];
+    const warnings = [];
+    const seen = new Set();
+    for (const name of harnessNames) {
+        const adapter = (0, adapter_registry_js_1.getAdapter)(name);
+        if (!adapter || seen.has(adapter.name))
+            continue;
+        seen.add(adapter.name);
+        if (adapter.dialect.skillFrontmatter === "minimal") {
+            const one = ccKeys.length === 1;
+            warnings.push(`skill "${spec.name}": ${ccKeys.join(", ")} ${one ? "is" : "are"} Claude-Code-only — declared harness "${adapter.name}" drops ${one ? "it" : "them"}.`);
+        }
+    }
+    return warnings;
+}
+//# sourceMappingURL=skill-harness.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "Compile .spec.ts files to instruction files (CLAUDE.md, AGENTS.md) with linter cross-referencing",
   "bin": {
     "vigiles": "dist/cli.js"