mova-claude-import 0.1.1

package/dist/run_import.js

@@ -0,0 +1,479 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { redactText, redactJson } from "./redaction.js";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { getAnthropicProfileV0Files } from "./anthropic_profile_v0.js";
+import { lintV0 } from "./lint_v0.js";
+import { stableStringify } from "./stable_json.js";
+import { createExportZipV0 } from "./export_zip_v0.js";
+import { buildMovaOverlayV0, buildMovaControlEntryV0, MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+import { scanInputPolicyV0 } from "./input_policy_v0.js";
+import { EvidenceWriter } from "@leryk1981/mova-core-engine";
+import { MOVA_SPEC_BINDINGS_V0 } from "./mova_spec_bindings_v0.js";
+import { writeCleanClaudeProfileScaffoldV0 } from "./claude_profile_scaffold_v0.js";
+async function exists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function sha256File(p) {
+    const buf = await fs.readFile(p);
+    return crypto.createHash("sha256").update(buf).digest("hex");
+}
+async function readToolVersion() {
+    try {
+        const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
+        const raw = await fs.readFile(pkgPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function isLocalExcluded(rel, includeLocal) {
+    if (includeLocal)
+        return false;
+    const base = path.basename(rel);
+    if (base === "CLAUDE.local.md")
+        return true;
+    if (base.includes(".local."))
+        return true;
+    return false;
+}
+async function scanProject(opts) {
+    const projectDir = path.resolve(opts.projectDir);
+    const skipped = [];
+    const found = { skillFiles: [], skipped };
+    const claudeMd = path.join(projectDir, "CLAUDE.md");
+    if (await exists(claudeMd))
+        found.claudeMdPath = claudeMd;
+    const mcpJson = path.join(projectDir, ".mcp.json");
+    if (await exists(mcpJson))
+        found.mcpJsonPath = mcpJson;
+    const skillsRoot = path.join(projectDir, ".claude", "skills");
+    if (await exists(skillsRoot)) {
+        const stack = [skillsRoot];
+        while (stack.length) {
+            const dir = stack.pop();
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const e of entries) {
+                const abs = path.join(dir, e.name);
+                const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+                if (isLocalExcluded(rel, opts.includeLocal)) {
+                    skipped.push({ path: rel, reason: "excluded_by_default_local" });
+                    continue;
+                }
+                if (e.isDirectory())
+                    stack.push(abs);
+                else if (e.isFile() && e.name.toLowerCase().endsWith(".md"))
+                    found.skillFiles.push(abs);
+            }
+        }
+    }
+    // placeholder for user settings exclusion
+    if (!opts.includeUserSettings) {
+        skipped.push({ path: "~/.claude/*", reason: "excluded_by_default_user_settings" });
+    }
+    found.skillFiles.sort((a, b) => a.localeCompare(b));
+    return found;
+}
+function computeRunId(hashes) {
+    const h = crypto.createHash("sha256");
+    for (const x of hashes.sort())
+        h.update(x);
+    return h.digest("hex").slice(0, 16);
+}
+function normalizeSkillDir(rel) {
+    const base = rel.replace(/\\/g, "/").replace(/\.md$/i, "");
+    const withoutRoot = base.replace(/^\.claude\/skills\//, "");
+    return withoutRoot.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function writeJsonFile(absPath, obj) {
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, stableStringify(obj) + "\n", "utf8");
+}
+async function writeTextFile(absPath, content) {
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, content, "utf8");
+}
+/** Load a JSON file and redact it */
+async function loadAndRedactJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    const parsed = JSON.parse(raw);
+    const { redacted, hits } = redactJson(parsed);
+    return { raw, parsed, redacted, hits };
+}
+async function ensureClaudeControlEntry(claudePath, block, marker) {
+    const content = await fs.readFile(claudePath, "utf8");
+    if (content.includes(marker))
+        return;
+    await fs.writeFile(claudePath, `${block}\n${content}`, "utf8");
+}
+function orderedObject(obj) {
+    return JSON.parse(stableStringify(obj));
+}
+async function writeEvidenceArtifact(writer, baseDir, rel, obj) {
+    const target = await writer.writeArtifact(baseDir, rel, orderedObject(obj));
+    await fs.writeFile(target, stableStringify(obj) + "\n", "utf8");
+}
+async function loadMovaSpecSchema(fileName) {
+    const require = createRequire(import.meta.url);
+    const pkgPath = require.resolve("@leryk1981/mova-spec/package.json");
+    const schemaPath = path.join(path.dirname(pkgPath), "schemas", fileName);
+    const raw = await fs.readFile(schemaPath, "utf8");
+    return JSON.parse(raw);
+}
+async function loadMovaSpecSchemaById(schemaId) {
+    const fileName = schemaId.split("/").pop();
+    if (!fileName)
+        throw new Error(`Invalid schema id: ${schemaId}`);
+    return loadMovaSpecSchema(fileName);
+}
+export async function runImport(opts) {
+    const projectDir = path.resolve(opts.projectDir);
+    const outRoot = path.resolve(opts.outDir);
+    const inputPolicy = await scanInputPolicyV0(projectDir, {
+        strict: opts.strict,
+        include_local: opts.includeLocal,
+    });
+    const found = await scanProject(opts);
+    const inputs = [];
+    const redactionHits = [];
+    /** Process a text file – redact and record */
+    async function processTextFile(rel, absPath) {
+        const raw = await fs.readFile(absPath, "utf8");
+        const { redacted, hits } = redactText(raw);
+        inputs.push({ rel, sha256: await sha256File(absPath) });
+        redactionHits.push(...hits);
+        return redacted;
+    }
+    // CLAUDE.md
+    let claudeMdRedacted = "";
+    if (found.claudeMdPath) {
+        claudeMdRedacted = await processTextFile("CLAUDE.md", found.claudeMdPath);
+    }
+    // .mcp.json
+    let mcpJsonRedacted = "";
+    let mcpJsonParsed;
+    if (found.mcpJsonPath) {
+        const { parsed, redacted, hits } = await loadAndRedactJson(found.mcpJsonPath);
+        mcpJsonParsed = parsed;
+        mcpJsonRedacted = stableStringify(redacted);
+        redactionHits.push(...hits);
+        inputs.push({
+            rel: ".mcp.json",
+            sha256: await sha256File(found.mcpJsonPath),
+        });
+    }
+    // skill files
+    const skillRedactedMap = {};
+    for (const f of found.skillFiles) {
+        const rel = path.relative(projectDir, f).replace(/\\/g, "/");
+        const redacted = await processTextFile(rel, f);
+        skillRedactedMap[rel] = redacted;
+    }
+    const runId = computeRunId(inputs.map((x) => `${x.rel}:${x.sha256}`));
+    const movaBase = path.join(outRoot, "mova", "claude_import", "v0");
+    const evidenceWriter = new EvidenceWriter();
+    const overlayParams = {
+        contractsDir: "mova/claude_import/v0/contracts/",
+        artifactsDir: "mova/claude_import/v0/",
+        instructionProfileFile: "instruction_profile_v0.json",
+        skillsCatalogFile: "skills_catalog_v0.json",
+        mcpServersFile: "mcp_servers_v0.json",
+        lintReportFile: "lint_report_v0.json",
+        qualityReportFile: "quality_report_v0.json",
+        exportManifestFile: "export_manifest_v0.json",
+    };
+    const normalizedSkills = Object.entries(skillRedactedMap).map(([rel, body]) => ({
+        rel,
+        body,
+        normDir: normalizeSkillDir(rel),
+        title: path.basename(rel, ".md"),
+    }));
+    if (!opts.dryRun) {
+        const toolVersion = await readToolVersion();
+        const versionInfo = {
+            tool_name: "mova-claude-import",
+            tool_version: toolVersion,
+            profile_version: "anthropic_profile_v0",
+            overlay_version: "mova_control_overlay_v0",
+            input_policy_version: "input_policy_v0",
+            lint_version: "lint_v0",
+            quality_version: "quality_v0",
+            export_zip_version: "export_zip_v0",
+        };
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "VERSION.json", versionInfo);
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "input_policy_report_v0.json", inputPolicy);
+    }
+    if (opts.strict && !inputPolicy.ok) {
+        const deniedRunId = computeRunId(inputPolicy.denied.map((d) => `${d.path}:${d.kind}:${d.reason}`).sort());
+        if (!opts.dryRun) {
+            const manifest = {
+                tool: "mova-claude-import",
+                version: "v0",
+                run_id: deniedRunId,
+                project_dir: projectDir,
+                emit_profile: opts.emitProfile,
+                inputs: [],
+                imported: {
+                    claude_md: false,
+                    mcp_json: false,
+                    skills_count: 0,
+                },
+                skipped: found.skipped,
+                input_policy_ok: false,
+            };
+            const episode = {
+                episode_id: deniedRunId,
+                recorded_at: "1970-01-01T00:00:00.000Z",
+                episode_type: "claude_import_run_v0",
+                run_id: deniedRunId,
+                ok: false,
+                result_core: {
+                    imported: manifest.imported,
+                    inputs_count: 0,
+                    validation: null,
+                },
+                failure: {
+                    reason: "input_policy_denied",
+                    denied_count: inputPolicy.denied.length,
+                },
+            };
+            await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+            await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+        }
+        return {
+            ok: false,
+            exit_code: 2,
+            run_id: deniedRunId,
+            out_dir: outRoot,
+            imported: { claude_md: false, mcp_json: false, skills_count: 0 },
+            skipped: found.skipped,
+            lint_summary: "lint_v0: skipped",
+        };
+    }
+    let movaSpecSchemas;
+    try {
+        movaSpecSchemas = {
+            instruction_profile: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.instruction_profile_id),
+            mcp_servers: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.mcp_servers_id),
+            core: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.core_schema_id),
+        };
+    }
+    catch (err) {
+        if (!opts.dryRun) {
+            const manifest = {
+                tool: "mova-claude-import",
+                version: "v0",
+                run_id: runId,
+                project_dir: projectDir,
+                emit_profile: opts.emitProfile,
+                inputs: [],
+                imported: {
+                    claude_md: false,
+                    mcp_json: false,
+                    skills_count: 0,
+                },
+                skipped: found.skipped,
+                input_policy_ok: inputPolicy.ok,
+                failure: {
+                    reason: "mova_spec_schema_missing",
+                },
+            };
+            const episode = {
+                episode_id: runId,
+                recorded_at: "1970-01-01T00:00:00.000Z",
+                episode_type: "claude_import_run_v0",
+                run_id: runId,
+                ok: false,
+                result_core: {
+                    imported: manifest.imported,
+                    inputs_count: 0,
+                    validation: null,
+                },
+                failure: {
+                    reason: "mova_spec_schema_missing",
+                    detail: String(err?.message ?? err),
+                },
+            };
+            await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+            await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+        }
+        return {
+            ok: false,
+            exit_code: 2,
+            run_id: runId,
+            out_dir: outRoot,
+            imported: { claude_md: false, mcp_json: false, skills_count: 0 },
+            skipped: found.skipped,
+            lint_summary: "lint_v0: skipped",
+        };
+    }
+    if (!opts.dryRun && opts.emitProfile) {
+        await writeCleanClaudeProfileScaffoldV0(outRoot);
+        if (opts.emitOverlay) {
+            const controlEntry = buildMovaControlEntryV0(overlayParams);
+            const claudePath = path.join(outRoot, "CLAUDE.md");
+            if (await exists(claudePath)) {
+                await ensureClaudeControlEntry(claudePath, controlEntry, MOVA_CONTROL_ENTRY_MARKER);
+            }
+            const overlayFiles = buildMovaOverlayV0(overlayParams);
+            for (const [rel, content] of Object.entries(overlayFiles)) {
+                await writeTextFile(path.join(outRoot, rel), content);
+            }
+        }
+        const profileFiles = getAnthropicProfileV0Files();
+        for (const [rel, content] of Object.entries(profileFiles)) {
+            if (rel === "CLAUDE.md" || rel === ".claude/settings.json")
+                continue;
+            await writeTextFile(path.join(outRoot, rel), content);
+        }
+        if (mcpJsonParsed) {
+            await writeJsonFile(path.join(outRoot, ".mcp.json"), mcpJsonParsed);
+        }
+        for (const skill of normalizedSkills) {
+            const outRel = path.join(".claude", "skills", skill.normDir, "SKILL.md");
+            await writeTextFile(path.join(outRoot, outRel), skill.body);
+        }
+    }
+    // Build contracts
+    const instructionProfile = {
+        profile_version: "v0",
+        claude_md: claudeMdRedacted,
+        anchors: {
+            mova_entry: "MOVA.md",
+            normalized_project: ".",
+        },
+    };
+    const skillsCatalog = {
+        profile_version: "v0",
+        skills: normalizedSkills.map((skill) => ({
+            skill_id: skill.normDir,
+            rel_dir: `.claude/skills/${skill.normDir}`,
+            title: skill.title,
+            skill_md: skill.body,
+        })),
+    };
+    const mcpServers = {
+        profile_version: "v0",
+        servers: Array.isArray(mcpJsonParsed?.servers) ? mcpJsonParsed?.servers : [],
+    };
+    if (!opts.dryRun) {
+        await writeJsonFile(path.join(movaBase, "contracts", "instruction_profile_v0.json"), instructionProfile);
+        await writeJsonFile(path.join(movaBase, "contracts", "skills_catalog_v0.json"), skillsCatalog);
+        await writeJsonFile(path.join(movaBase, "contracts", "mcp_servers_v0.json"), mcpServers);
+    }
+    // Validation with Ajv
+    const ajv = new Ajv({ allErrors: true, strict: true, validateSchema: false });
+    addFormats(ajv);
+    const coreSchemaId = movaSpecSchemas.core?.$id ?? "https://mova.dev/schemas/ds.mova_schema_core_v1.schema.json";
+    ajv.addSchema(movaSpecSchemas.core, coreSchemaId);
+    const schemaPath = (name) => fileURLToPath(new URL(`../schemas/${name}`, import.meta.url));
+    const schemas = {
+        instruction_profile: JSON.parse(await fs.readFile(schemaPath("ds.claude_import.instruction_profile_v0.schema.json"), "utf8")),
+        skills_catalog: JSON.parse(await fs.readFile(schemaPath("ds.claude_import.skills_catalog_v0.schema.json"), "utf8")),
+        mcp_servers: JSON.parse(await fs.readFile(schemaPath("ds.claude_import.mcp_servers_v0.schema.json"), "utf8")),
+    };
+    const validateInstruction = ajv.compile(schemas.instruction_profile);
+    const validateSkills = ajv.compile(schemas.skills_catalog);
+    const validateMcp = ajv.compile(schemas.mcp_servers);
+    const validateSpecInstruction = ajv.compile(movaSpecSchemas.instruction_profile);
+    const validateSpecMcp = ajv.compile(movaSpecSchemas.mcp_servers);
+    const validationReport = {
+        instruction_profile: validateInstruction(instructionProfile),
+        skills_catalog: validateSkills(skillsCatalog),
+        mcp_servers: validateMcp(mcpServers),
+        mova_spec: {
+            instruction_profile: validateSpecInstruction(instructionProfile),
+            mcp_servers: validateSpecMcp(mcpServers),
+            errors: {
+                instruction_profile: validateSpecInstruction.errors,
+                mcp_servers: validateSpecMcp.errors,
+            },
+        },
+        errors: {
+            instruction_profile: validateInstruction.errors,
+            skills_catalog: validateSkills.errors,
+            mcp_servers: validateMcp.errors,
+        },
+    };
+    const manifest = {
+        tool: "mova-claude-import",
+        version: "v0",
+        run_id: runId,
+        project_dir: projectDir,
+        emit_profile: opts.emitProfile,
+        inputs: inputs.sort((a, b) => a.rel.localeCompare(b.rel)),
+        imported: {
+            claude_md: Boolean(found.claudeMdPath),
+            mcp_json: Boolean(found.mcpJsonPath),
+            skills_count: normalizedSkills.length,
+        },
+        skipped: found.skipped,
+        input_policy_ok: inputPolicy.ok,
+    };
+    const redactionReport = {
+        hits: redactionHits,
+        note: "Only presence/len recorded, values omitted.",
+    };
+    const episode = {
+        episode_id: runId,
+        recorded_at: "1970-01-01T00:00:00.000Z",
+        episode_type: "claude_import_run_v0",
+        run_id: runId,
+        ok: true,
+        result_core: {
+            imported: manifest.imported,
+            inputs_count: manifest.inputs.length,
+            validation: validationReport,
+        },
+    };
+    if (!opts.dryRun) {
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "redaction_report.json", redactionReport);
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+    }
+    let lintReport = {
+        profile_version: "v0",
+        ok: true,
+        issues: [],
+        summary: "lint_v0: ok",
+    };
+    if (!opts.dryRun) {
+        lintReport = await lintV0({
+            outRoot,
+            emitProfile: opts.emitProfile,
+            mcpExpected: Boolean(found.mcpJsonPath),
+        });
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "lint_report_v0.json", lintReport);
+    }
+    if (!opts.dryRun && opts.emitZip) {
+        const exportZip = await createExportZipV0(outRoot, opts.zipName);
+        const exportManifest = {
+            profile_version: "v0",
+            zip_rel_path: exportZip.zipRelPath,
+            zip_sha256: exportZip.zipSha256,
+            files_count: exportZip.files.length,
+            files: exportZip.files,
+        };
+        await writeEvidenceArtifact(evidenceWriter, movaBase, "export_manifest_v0.json", exportManifest);
+    }
+    return {
+        ok: true,
+        run_id: runId,
+        out_dir: outRoot,
+        imported: manifest.imported,
+        skipped: found.skipped,
+        lint_summary: lintReport.summary,
+    };
+}

package/dist/stable_json.d.ts

@@ -0,0 +1 @@
+export declare function stableStringify(value: any): string;

package/dist/stable_json.js

@@ -0,0 +1,15 @@
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            out[key] = sortValue(value[key]);
+        }
+        return out;
+    }
+    return value;
+}
+export function stableStringify(value) {
+    return JSON.stringify(sortValue(value), null, 2);
+}

package/docs/ANTHROPIC_PROFILE_v0.md

@@ -0,0 +1,38 @@
+# Anthropic Profile v0 (Source of Truth)
+
+This document defines the deterministic output layout produced by the Anthropic
+profile v0 rebuild.
+
+Output root (<OUT>/):
+
+```
+<OUT>/
+  CLAUDE.md
+  MOVA.md
+  .mcp.json                    (only if present in input)
+  .claude/
+    settings.json
+    commands/
+      mova_context.md
+      mova_lint.md
+    skills/
+      mova-layer-v0/
+        SKILL.md
+      <imported skills...>/    (normalized)
+  mova/
+    claude_import/v0/
+      import_manifest.json
+      redaction_report.json
+      lint_report_v0.json
+      contracts/
+        instruction_profile_v0.json
+        skills_catalog_v0.json
+        mcp_servers_v0.json
+      episode_import_run.json
+```
+
+Notes:
+- The output is fully deterministic (no timestamps, random IDs, or run-specific
+  folders).
+- Source inputs are not copied into the output project; only normalized profile
+  artifacts and contracts are emitted.

package/docs/COMPATIBILITY_MATRIX.md

@@ -0,0 +1,25 @@
+# Compatibility Matrix v0
+
+## Runtime
+
+- Node.js: 20.x, 22.x
+- npm: 9+
+
+## Required MOVA deps (enforced)
+
+- @leryk1981/mova-spec = ^4.1.1
+- @leryk1981/mova-core-engine = ^0.1.1
+
+## Compatibility rules
+
+- When updating mova-spec, run `npm run docs:bindings` and ensure `npm run quality` + `npm run quality:neg` are green.
+- Deps gate: `npm run deps:audit` must pass.
+
+## Exit codes
+
+- 0: ok
+- 2: validation/policy/bindings failures (strict deny, docs:check, deps:audit)
+
+## Operational
+
+- Deterministic outputs are guaranteed for identical inputs + flags.

package/docs/CONTROL_PROFILE_GUIDE_v0.md

@@ -0,0 +1,40 @@
+# Control Profile Guide v0
+
+## Что это за файл
+
+`claude_control_profile_v0.json` — единая панель управления политиками и поведением
+Claude Code + MOVA наблюдаемости.
+
+## Минимально необходимые поля
+
+- `kind`, `id`, `version`, `mode`, `title`
+- `anthropic.permissions`
+- `anthropic.mcp`
+- `anthropic.claude_md`
+- `mova.overlay`
+- `mova.observability`
+- `apply.default_apply_mode`
+
+## Как выбрать пример
+
+| Профиль | Когда использовать |
+| --- | --- |
+| min | Быстрый старт, только базовые поля |
+| standard | Рекомендуемый набор, полный контроль без жёсткости |
+| strict | Более жёсткие allow‑списки, но всё ещё report‑only |
+
+См. примеры в `examples/`.
+
+## Apply‑flow
+
+1) `control prefill` — создать профиль
+2) отредактировать профиль
+3) `control check` — получить план
+4) `control apply` — применить при `--mode apply`
+
+## Где смотреть отчёты
+
+- `prefill_report_v0.json` — что было найдено при prefill
+- `mova/claude_control/v0/runs/<run_id>/control_plan_v0.json`
+- `mova/claude_control/v0/runs/<run_id>/control_summary_v0.json`
+- `mova/claude_control/v0/runs/<run_id>/control_apply_report_v0.json`

package/docs/IMPORT_SPEC_v0.md

@@ -0,0 +1,30 @@
+# mova-claude-import v0 (free)
+
+## Inputs (scanned)
+- CLAUDE.md
+- .claude/skills/**/*.md
+- .mcp.json
+Excluded by default:
+- CLAUDE.local.md and *.local.*
+- user settings (~/.claude/*) unless explicitly enabled
+
+## Outputs (written)
+- mova/claude_import/v0/runs/<run_id>/import_manifest.json
+- mova/claude_import/v0/runs/<run_id>/redaction_report.json
+- mova/claude_import/v0/episodes/* (execution episode)
+- mova/claude_import/v0/runs/latest.json
+- mova/claude_import/v0/runs/<run_id>/sources/... (redacted source files)
+- mova/claude_import/v0/runs/<run_id>/contracts/... (generated contracts)
+
+## Determinism
+run_id = sha256(sorted(file_path + sha256(file_content)))[:16]
+
+## Contracts (generated)
+- instruction_profile_v0.json
+- skills_catalog_v0.json
+- mcp_servers_v0.json
+
+## Plugin wrapper
+Example Claude Code plugin is provided under:
+- plugin/mova-import/.claude-plugin/
+- plugin/mova-import/commands/import.md

package/docs/MOVA_SPEC_BINDINGS.json

@@ -0,0 +1,21 @@
+{
+  "spec_version": "4.1.1",
+  "bindings": [
+    {
+      "category": "instruction_profile",
+      "schema_id": "https://mova.dev/schemas/ds.instruction_profile_core_v1.schema.json",
+      "file_path": "schemas/ds.instruction_profile_core_v1.schema.json"
+    },
+    {
+      "category": "mcp_servers",
+      "schema_id": "https://mova.dev/schemas/ds.runtime_binding_core_v1.schema.json",
+      "file_path": "schemas/ds.runtime_binding_core_v1.schema.json"
+    },
+    {
+      "category": "core_schema",
+      "schema_id": "https://mova.dev/schemas/ds.mova_schema_core_v1.schema.json",
+      "file_path": "schemas/ds.mova_schema_core_v1.schema.json"
+    }
+  ],
+  "selection_rule": "Bound to MOVA_SPEC_BINDINGS_V0 used by run_import.ts"
+}

package/docs/MOVA_SPEC_BINDINGS.md

@@ -0,0 +1,11 @@
+# MOVA Spec Bindings v0
+
+Spec version: 4.1.1
+
+| Category | Chosen schema $id | File path |
+| --- | --- | --- |
+| instruction_profile | https://mova.dev/schemas/ds.instruction_profile_core_v1.schema.json | schemas/ds.instruction_profile_core_v1.schema.json |
+| mcp_servers | https://mova.dev/schemas/ds.runtime_binding_core_v1.schema.json | schemas/ds.runtime_binding_core_v1.schema.json |
+| core_schema | https://mova.dev/schemas/ds.mova_schema_core_v1.schema.json | schemas/ds.mova_schema_core_v1.schema.json |
+
+Selection rule: Bound to `MOVA_SPEC_BINDINGS_V0` used by `src/run_import.ts`.