mova-claude-import 0.1.1 → 0.1.2

package/dist/control_v0.d.ts

@@ -0,0 +1,149 @@
+export declare const CONTROL_V0_SCHEMA_ID = "https://mova.dev/schemas/mova.control_v0.schema.json";
+export type AssetMode = "copy_through" | "managed";
+export type AssetItem = {
+    path: string;
+    mode: AssetMode;
+    source_path?: string;
+};
+export type ControlV0 = {
+    $schema?: string;
+    version: "control_v0";
+    claude_md: {
+        inject_control_entry: boolean;
+        marker: string;
+        priority_sources: string[];
+    };
+    claude_memory: {
+        enable: boolean;
+        sources: string[];
+    };
+    overlay: {
+        enable: boolean;
+    };
+    settings: {
+        include_co_authored_by: boolean;
+        env: Record<string, string>;
+    };
+    mcp: {
+        servers: any;
+        enable_all_project_mcp_servers: boolean;
+        enabled_mcpjson_servers: string[];
+        env_substitutions: {
+            format: string;
+            default_format: string;
+        };
+    };
+    policy: {
+        mode: string;
+        hooks: {
+            enable: boolean;
+            on_invalid_hook: string;
+            definitions: any[];
+            events: Record<string, any>;
+        };
+        permissions: {
+            allow: any[];
+            deny: any[];
+            on_conflict: string;
+            on_unknown: string;
+        };
+        plugins: {
+            enable: boolean;
+            allowed_plugin_ids: any[];
+            denied_plugin_ids: any[];
+            on_unknown: string;
+            enabled_plugins: Record<string, boolean>;
+        };
+    };
+    lsp: {
+        enabled_plugins: string[];
+        config_path: string;
+        managed: boolean;
+    };
+    skill_eval: {
+        enable: boolean;
+        hooks: {
+            shell: string;
+            node: string;
+        };
+        rules_path: string;
+        scoring: {
+            threshold: number;
+        };
+    };
+    observability: {
+        enable: boolean;
+        mode: string;
+        writer: {
+            type: "node";
+            script_path: string;
+        };
+        output_dir: string;
+        stdout_tail_bytes: number;
+        stderr_tail_bytes: number;
+        max_event_bytes: number;
+        tail_lines: number;
+        include_tools: string[];
+        include_events: string[];
+    };
+    assets: {
+        skills: AssetItem[];
+        agents: AssetItem[];
+        commands: AssetItem[];
+        rules: AssetItem[];
+        hooks: AssetItem[];
+        workflows: AssetItem[];
+        docs: AssetItem[];
+        dotfiles: AssetItem[];
+        schemas: AssetItem[];
+    };
+};
+export declare function defaultControlV0(): ControlV0;
+export declare function normalizeControlV0(input: any): {
+    control: ControlV0;
+    defaults: string[];
+};
+export declare function controlFromSettingsV0(settings: any | undefined, mcp: any | undefined): {
+    control: ControlV0;
+    defaults: string[];
+};
+export declare function controlToSettingsV0(control: ControlV0): {
+    includeCoAuthoredBy: boolean;
+    env: Record<string, string>;
+    mcp: {
+        enableAllProjectMcpServers: boolean;
+        enabledMcpjsonServers: string[];
+    };
+    permissions: {
+        allow: any[];
+        deny: any[];
+        behavior: {
+            on_conflict: string;
+            on_unknown: string;
+        };
+    };
+    plugins: {
+        enable: boolean;
+        allowed_plugin_ids: any[];
+        denied_plugin_ids: any[];
+        behavior: {
+            on_unknown: string;
+        };
+        enabledPlugins: Record<string, boolean>;
+    };
+    lsp: {
+        enabledPlugins: string[];
+    };
+    hooks: Record<string, any>;
+    claude_md: {
+        inject_control_entry: boolean;
+        marker: string;
+    };
+};
+export declare function controlToMcpJson(control: ControlV0): {
+    servers: any[];
+    mcpServers?: undefined;
+} | {
+    mcpServers: Record<string, any>;
+    servers?: undefined;
+};

package/dist/control_v0.js

@@ -0,0 +1,360 @@
+import { MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+export const CONTROL_V0_SCHEMA_ID = "https://mova.dev/schemas/mova.control_v0.schema.json";
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function defaultControlV0() {
+    return {
+        $schema: CONTROL_V0_SCHEMA_ID,
+        version: "control_v0",
+        claude_md: {
+            inject_control_entry: true,
+            marker: MOVA_CONTROL_ENTRY_MARKER,
+            priority_sources: ["CLAUDE.md", ".claude/CLAUDE.md", "~/.claude/CLAUDE.md"],
+        },
+        claude_memory: {
+            enable: true,
+            sources: ["CLAUDE.md"],
+        },
+        overlay: {
+            enable: true,
+        },
+        settings: {
+            include_co_authored_by: true,
+            env: {},
+        },
+        mcp: {
+            servers: {},
+            enable_all_project_mcp_servers: false,
+            enabled_mcpjson_servers: [],
+            env_substitutions: {
+                format: "${VAR}",
+                default_format: "${VAR:-default}",
+            },
+        },
+        policy: {
+            mode: "report_only",
+            hooks: {
+                enable: true,
+                on_invalid_hook: "report_only",
+                definitions: [],
+                events: {},
+            },
+            permissions: {
+                allow: [],
+                deny: [],
+                on_conflict: "deny_wins",
+                on_unknown: "report_only",
+            },
+            plugins: {
+                enable: true,
+                allowed_plugin_ids: [],
+                denied_plugin_ids: [],
+                on_unknown: "report_only",
+                enabled_plugins: {},
+            },
+        },
+        lsp: {
+            enabled_plugins: [],
+            config_path: ".claude/lsp.json",
+            managed: false,
+        },
+        skill_eval: {
+            enable: false,
+            hooks: {
+                shell: ".claude/hooks/skill-eval.sh",
+                node: ".claude/hooks/skill-eval.js",
+            },
+            rules_path: ".claude/hooks/skill-rules.json",
+            scoring: {
+                threshold: 0.6,
+            },
+        },
+        observability: {
+            enable: true,
+            mode: "report_only",
+            writer: {
+                type: "node",
+                script_path: ".claude/hooks/mova-observe.js",
+            },
+            output_dir: ".mova/episodes",
+            stdout_tail_bytes: 4000,
+            stderr_tail_bytes: 4000,
+            max_event_bytes: 20000,
+            tail_lines: 50,
+            include_tools: ["Bash", "Read", "Edit", "MultiEdit", "Write"],
+            include_events: ["PostToolUse", "UserPromptSubmit", "Stop"],
+        },
+        assets: {
+            skills: [],
+            agents: [],
+            commands: [],
+            rules: [],
+            hooks: [],
+            workflows: [],
+            docs: [],
+            dotfiles: [],
+            schemas: [],
+        },
+    };
+}
+function coerceBoolean(value, fallback, defaults, path) {
+    if (typeof value === "boolean")
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function coerceString(value, fallback, defaults, path) {
+    if (typeof value === "string")
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function coerceNumber(value, fallback, defaults, path) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function coerceArray(value, fallback, defaults, path) {
+    if (Array.isArray(value))
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function coerceRecord(value, fallback, defaults, path) {
+    if (isObject(value))
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function coerceServers(value, fallback, defaults, path) {
+    if (Array.isArray(value))
+        return value;
+    if (isObject(value))
+        return value;
+    defaults.push(path);
+    return fallback;
+}
+function normalizeAssets(value, fallback, defaults, path) {
+    if (!Array.isArray(value)) {
+        defaults.push(path);
+        return fallback;
+    }
+    const normalized = [];
+    for (const item of value) {
+        if (!isObject(item) || typeof item.path !== "string")
+            continue;
+        const mode = item.mode === "managed" ? "managed" : "copy_through";
+        const entry = { path: item.path, mode };
+        if (typeof item.source_path === "string")
+            entry.source_path = item.source_path;
+        normalized.push(entry);
+    }
+    return normalized.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function normalizeControlV0(input) {
+    const defaults = [];
+    const base = defaultControlV0();
+    const src = isObject(input) ? input : {};
+    base.$schema = CONTROL_V0_SCHEMA_ID;
+    base.version = "control_v0";
+    base.claude_md.inject_control_entry = coerceBoolean(src?.claude_md?.inject_control_entry, base.claude_md.inject_control_entry, defaults, "claude_md.inject_control_entry");
+    base.claude_md.marker = coerceString(src?.claude_md?.marker, base.claude_md.marker, defaults, "claude_md.marker");
+    base.claude_md.priority_sources = coerceArray(src?.claude_md?.priority_sources, base.claude_md.priority_sources, defaults, "claude_md.priority_sources");
+    base.claude_memory.enable = coerceBoolean(src?.claude_memory?.enable, base.claude_memory.enable, defaults, "claude_memory.enable");
+    base.claude_memory.sources = coerceArray(src?.claude_memory?.sources, base.claude_memory.sources, defaults, "claude_memory.sources");
+    base.overlay.enable = coerceBoolean(src?.overlay?.enable, base.overlay.enable, defaults, "overlay.enable");
+    base.settings.include_co_authored_by = coerceBoolean(src?.settings?.include_co_authored_by, base.settings.include_co_authored_by, defaults, "settings.include_co_authored_by");
+    base.settings.env = coerceRecord(src?.settings?.env, base.settings.env, defaults, "settings.env");
+    base.mcp.servers = coerceServers(src?.mcp?.servers, base.mcp.servers, defaults, "mcp.servers");
+    base.mcp.enable_all_project_mcp_servers = coerceBoolean(src?.mcp?.enable_all_project_mcp_servers, base.mcp.enable_all_project_mcp_servers, defaults, "mcp.enable_all_project_mcp_servers");
+    base.mcp.enabled_mcpjson_servers = coerceArray(src?.mcp?.enabled_mcpjson_servers, base.mcp.enabled_mcpjson_servers, defaults, "mcp.enabled_mcpjson_servers");
+    base.mcp.env_substitutions = coerceRecord(src?.mcp?.env_substitutions, base.mcp.env_substitutions, defaults, "mcp.env_substitutions");
+    base.mcp.env_substitutions.format = coerceString(base.mcp.env_substitutions.format, "${VAR}", defaults, "mcp.env_substitutions.format");
+    base.mcp.env_substitutions.default_format = coerceString(base.mcp.env_substitutions.default_format, "${VAR:-default}", defaults, "mcp.env_substitutions.default_format");
+    base.policy.mode = coerceString(src?.policy?.mode, base.policy.mode, defaults, "policy.mode");
+    base.policy.hooks.enable = coerceBoolean(src?.policy?.hooks?.enable, base.policy.hooks.enable, defaults, "policy.hooks.enable");
+    base.policy.hooks.on_invalid_hook = coerceString(src?.policy?.hooks?.on_invalid_hook, base.policy.hooks.on_invalid_hook, defaults, "policy.hooks.on_invalid_hook");
+    base.policy.hooks.definitions = coerceArray(src?.policy?.hooks?.definitions, base.policy.hooks.definitions, defaults, "policy.hooks.definitions");
+    base.policy.hooks.events = coerceRecord(src?.policy?.hooks?.events, base.policy.hooks.events, defaults, "policy.hooks.events");
+    base.policy.permissions.allow = coerceArray(src?.policy?.permissions?.allow, base.policy.permissions.allow, defaults, "policy.permissions.allow");
+    base.policy.permissions.deny = coerceArray(src?.policy?.permissions?.deny, base.policy.permissions.deny, defaults, "policy.permissions.deny");
+    base.policy.permissions.on_conflict = coerceString(src?.policy?.permissions?.on_conflict, base.policy.permissions.on_conflict, defaults, "policy.permissions.on_conflict");
+    base.policy.permissions.on_unknown = coerceString(src?.policy?.permissions?.on_unknown, base.policy.permissions.on_unknown, defaults, "policy.permissions.on_unknown");
+    base.policy.plugins.enable = coerceBoolean(src?.policy?.plugins?.enable, base.policy.plugins.enable, defaults, "policy.plugins.enable");
+    base.policy.plugins.allowed_plugin_ids = coerceArray(src?.policy?.plugins?.allowed_plugin_ids, base.policy.plugins.allowed_plugin_ids, defaults, "policy.plugins.allowed_plugin_ids");
+    base.policy.plugins.denied_plugin_ids = coerceArray(src?.policy?.plugins?.denied_plugin_ids, base.policy.plugins.denied_plugin_ids, defaults, "policy.plugins.denied_plugin_ids");
+    base.policy.plugins.on_unknown = coerceString(src?.policy?.plugins?.on_unknown, base.policy.plugins.on_unknown, defaults, "policy.plugins.on_unknown");
+    base.policy.plugins.enabled_plugins = coerceRecord(src?.policy?.plugins?.enabled_plugins, base.policy.plugins.enabled_plugins, defaults, "policy.plugins.enabled_plugins");
+    base.lsp.enabled_plugins = coerceArray(src?.lsp?.enabled_plugins, base.lsp.enabled_plugins, defaults, "lsp.enabled_plugins");
+    base.lsp.config_path = coerceString(src?.lsp?.config_path, base.lsp.config_path, defaults, "lsp.config_path");
+    base.lsp.managed = coerceBoolean(src?.lsp?.managed, base.lsp.managed, defaults, "lsp.managed");
+    base.skill_eval.enable = coerceBoolean(src?.skill_eval?.enable, base.skill_eval.enable, defaults, "skill_eval.enable");
+    base.skill_eval.hooks = coerceRecord(src?.skill_eval?.hooks, base.skill_eval.hooks, defaults, "skill_eval.hooks");
+    base.skill_eval.hooks.shell = coerceString(base.skill_eval.hooks.shell, defaultControlV0().skill_eval.hooks.shell, defaults, "skill_eval.hooks.shell");
+    base.skill_eval.hooks.node = coerceString(base.skill_eval.hooks.node, defaultControlV0().skill_eval.hooks.node, defaults, "skill_eval.hooks.node");
+    base.skill_eval.rules_path = coerceString(src?.skill_eval?.rules_path, base.skill_eval.rules_path, defaults, "skill_eval.rules_path");
+    base.skill_eval.scoring = coerceRecord(src?.skill_eval?.scoring, base.skill_eval.scoring, defaults, "skill_eval.scoring");
+    base.skill_eval.scoring.threshold = coerceNumber(base.skill_eval.scoring.threshold, defaultControlV0().skill_eval.scoring.threshold, defaults, "skill_eval.scoring.threshold");
+    base.observability.enable = coerceBoolean(src?.observability?.enable, base.observability.enable, defaults, "observability.enable");
+    base.observability.mode = coerceString(src?.observability?.mode, base.observability.mode, defaults, "observability.mode");
+    base.observability.writer = coerceRecord(src?.observability?.writer, base.observability.writer, defaults, "observability.writer");
+    base.observability.writer.type = "node";
+    base.observability.writer.script_path = coerceString(base.observability.writer.script_path, defaultControlV0().observability.writer.script_path, defaults, "observability.writer.script_path");
+    base.observability.output_dir = coerceString(src?.observability?.output_dir, base.observability.output_dir, defaults, "observability.output_dir");
+    base.observability.stdout_tail_bytes = coerceNumber(src?.observability?.stdout_tail_bytes, base.observability.stdout_tail_bytes, defaults, "observability.stdout_tail_bytes");
+    base.observability.stderr_tail_bytes = coerceNumber(src?.observability?.stderr_tail_bytes, base.observability.stderr_tail_bytes, defaults, "observability.stderr_tail_bytes");
+    base.observability.max_event_bytes = coerceNumber(src?.observability?.max_event_bytes, base.observability.max_event_bytes, defaults, "observability.max_event_bytes");
+    base.observability.tail_lines = coerceNumber(src?.observability?.tail_lines, base.observability.tail_lines, defaults, "observability.tail_lines");
+    base.observability.include_tools = coerceArray(src?.observability?.include_tools, base.observability.include_tools, defaults, "observability.include_tools");
+    base.observability.include_events = coerceArray(src?.observability?.include_events, base.observability.include_events, defaults, "observability.include_events");
+    base.assets.skills = normalizeAssets(src?.assets?.skills, base.assets.skills, defaults, "assets.skills");
+    base.assets.agents = normalizeAssets(src?.assets?.agents, base.assets.agents, defaults, "assets.agents");
+    base.assets.commands = normalizeAssets(src?.assets?.commands, base.assets.commands, defaults, "assets.commands");
+    base.assets.rules = normalizeAssets(src?.assets?.rules, base.assets.rules, defaults, "assets.rules");
+    base.assets.hooks = normalizeAssets(src?.assets?.hooks, base.assets.hooks, defaults, "assets.hooks");
+    base.assets.workflows = normalizeAssets(src?.assets?.workflows, base.assets.workflows, defaults, "assets.workflows");
+    base.assets.docs = normalizeAssets(src?.assets?.docs, base.assets.docs, defaults, "assets.docs");
+    base.assets.dotfiles = normalizeAssets(src?.assets?.dotfiles, base.assets.dotfiles, defaults, "assets.dotfiles");
+    base.assets.schemas = normalizeAssets(src?.assets?.schemas, base.assets.schemas, defaults, "assets.schemas");
+    return { control: base, defaults };
+}
+export function controlFromSettingsV0(settings, mcp) {
+    const defaults = [];
+    const base = defaultControlV0();
+    if (!settings) {
+        defaults.push("settings", "policy", "claude_md");
+    }
+    else {
+        base.settings.include_co_authored_by = coerceBoolean(settings?.includeCoAuthoredBy, base.settings.include_co_authored_by, defaults, "settings.include_co_authored_by");
+        base.settings.env = coerceRecord(settings?.env, base.settings.env, defaults, "settings.env");
+        base.policy.hooks.enable = coerceBoolean(settings?.hooks?.enable ?? true, base.policy.hooks.enable, defaults, "policy.hooks.enable");
+        base.policy.hooks.on_invalid_hook = coerceString(settings?.hooks?.behavior?.on_invalid_hook, base.policy.hooks.on_invalid_hook, defaults, "policy.hooks.on_invalid_hook");
+        base.policy.hooks.definitions = coerceArray(settings?.hooks?.definitions, base.policy.hooks.definitions, defaults, "policy.hooks.definitions");
+        const events = {};
+        if (isObject(settings?.hooks)) {
+            for (const [key, value] of Object.entries(settings.hooks)) {
+                if (key === "enable" || key === "behavior" || key === "definitions")
+                    continue;
+                events[key] = value;
+            }
+        }
+        base.policy.hooks.events = events;
+        base.policy.permissions.allow = coerceArray(settings?.permissions?.allow, base.policy.permissions.allow, defaults, "policy.permissions.allow");
+        base.policy.permissions.deny = coerceArray(settings?.permissions?.deny, base.policy.permissions.deny, defaults, "policy.permissions.deny");
+        base.policy.permissions.on_conflict = coerceString(settings?.permissions?.behavior?.on_conflict, base.policy.permissions.on_conflict, defaults, "policy.permissions.on_conflict");
+        base.policy.permissions.on_unknown = coerceString(settings?.permissions?.behavior?.on_unknown, base.policy.permissions.on_unknown, defaults, "policy.permissions.on_unknown");
+        base.policy.plugins.enable = coerceBoolean(settings?.plugins?.enable, base.policy.plugins.enable, defaults, "policy.plugins.enable");
+        base.policy.plugins.allowed_plugin_ids = coerceArray(settings?.plugins?.allowed_plugin_ids, base.policy.plugins.allowed_plugin_ids, defaults, "policy.plugins.allowed_plugin_ids");
+        base.policy.plugins.denied_plugin_ids = coerceArray(settings?.plugins?.denied_plugin_ids, base.policy.plugins.denied_plugin_ids, defaults, "policy.plugins.denied_plugin_ids");
+        base.policy.plugins.on_unknown = coerceString(settings?.plugins?.behavior?.on_unknown, base.policy.plugins.on_unknown, defaults, "policy.plugins.on_unknown");
+        base.policy.plugins.enabled_plugins = coerceRecord(settings?.plugins?.enabledPlugins, base.policy.plugins.enabled_plugins, defaults, "policy.plugins.enabled_plugins");
+        base.claude_md.inject_control_entry = coerceBoolean(settings?.claude_md?.inject_control_entry, base.claude_md.inject_control_entry, defaults, "claude_md.inject_control_entry");
+        base.claude_md.marker = coerceString(settings?.claude_md?.marker, base.claude_md.marker, defaults, "claude_md.marker");
+        base.mcp.enable_all_project_mcp_servers = coerceBoolean(settings?.mcp?.enableAllProjectMcpServers, base.mcp.enable_all_project_mcp_servers, defaults, "mcp.enable_all_project_mcp_servers");
+        base.mcp.enabled_mcpjson_servers = coerceArray(settings?.mcp?.enabledMcpjsonServers, base.mcp.enabled_mcpjson_servers, defaults, "mcp.enabled_mcpjson_servers");
+        base.lsp.enabled_plugins = coerceArray(settings?.lsp?.enabledPlugins, base.lsp.enabled_plugins, defaults, "lsp.enabled_plugins");
+    }
+    if (!mcp) {
+        defaults.push("mcp.servers");
+    }
+    else if (isObject(mcp) && isObject(mcp.mcpServers)) {
+        base.mcp.servers = mcp.mcpServers;
+    }
+    else {
+        base.mcp.servers = coerceServers(mcp?.servers, base.mcp.servers, defaults, "mcp.servers");
+    }
+    return { control: base, defaults };
+}
+export function controlToSettingsV0(control) {
+    const hooks = {
+        enable: control.policy.hooks.enable,
+        definitions: control.policy.hooks.definitions,
+        behavior: {
+            on_invalid_hook: control.policy.hooks.on_invalid_hook,
+        },
+    };
+    for (const [event, value] of Object.entries(control.policy.hooks.events)) {
+        hooks[event] = value;
+    }
+    if (control.observability.enable && Array.isArray(control.observability.include_events)) {
+        const scriptRel = control.observability.writer.script_path.replace(/^[\\/]+/, "");
+        const baseCommand = `node \"$CLAUDE_PROJECT_DIR/${scriptRel}\"`;
+        const commonArgs = [
+            `--stdout-tail-bytes ${control.observability.stdout_tail_bytes}`,
+            `--stderr-tail-bytes ${control.observability.stderr_tail_bytes}`,
+            `--max-event-bytes ${control.observability.max_event_bytes}`,
+            `--tail-lines ${control.observability.tail_lines}`,
+            `--output-dir ${control.observability.output_dir}`,
+        ].join(" ");
+        const postMatcher = control.observability.include_tools.length
+            ? control.observability.include_tools.join("|")
+            : undefined;
+        const ensureEventHook = (event, matcher) => {
+            const entry = {
+                hooks: [
+                    {
+                        type: "command",
+                        command: `${baseCommand} --event ${event} ${commonArgs}`.trim(),
+                        timeout: 5,
+                    },
+                ],
+            };
+            if (matcher)
+                entry.matcher = matcher;
+            hooks[event] = Array.isArray(hooks[event]) ? [...hooks[event], entry] : [entry];
+        };
+        if (control.observability.include_events.includes("PostToolUse")) {
+            ensureEventHook("PostToolUse", postMatcher);
+        }
+        if (control.observability.include_events.includes("UserPromptSubmit")) {
+            ensureEventHook("UserPromptSubmit");
+        }
+        if (control.observability.include_events.includes("Stop")) {
+            ensureEventHook("Stop");
+        }
+    }
+    return {
+        includeCoAuthoredBy: control.settings.include_co_authored_by,
+        env: control.settings.env,
+        mcp: {
+            enableAllProjectMcpServers: control.mcp.enable_all_project_mcp_servers,
+            enabledMcpjsonServers: control.mcp.enabled_mcpjson_servers,
+        },
+        permissions: {
+            allow: control.policy.permissions.allow,
+            deny: control.policy.permissions.deny,
+            behavior: {
+                on_conflict: control.policy.permissions.on_conflict,
+                on_unknown: control.policy.permissions.on_unknown,
+            },
+        },
+        plugins: {
+            enable: control.policy.plugins.enable,
+            allowed_plugin_ids: control.policy.plugins.allowed_plugin_ids,
+            denied_plugin_ids: control.policy.plugins.denied_plugin_ids,
+            behavior: {
+                on_unknown: control.policy.plugins.on_unknown,
+            },
+            enabledPlugins: control.policy.plugins.enabled_plugins,
+        },
+        lsp: {
+            enabledPlugins: control.lsp.enabled_plugins,
+        },
+        hooks,
+        claude_md: {
+            inject_control_entry: control.claude_md.inject_control_entry,
+            marker: control.claude_md.marker,
+        },
+    };
+}
+export function controlToMcpJson(control) {
+    if (Array.isArray(control.mcp.servers)) {
+        return { servers: control.mcp.servers };
+    }
+    if (isObject(control.mcp.servers)) {
+        return { mcpServers: control.mcp.servers };
+    }
+    return { servers: [] };
+}

package/dist/control_v0_schema.d.ts

@@ -0,0 +1,6 @@
+type ValidationResult = {
+    ok: boolean;
+    errors: any[] | null | undefined;
+};
+export declare function validateControlV0Schema(control: any): Promise<ValidationResult>;
+export {};

package/dist/control_v0_schema.js

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { CONTROL_V0_SCHEMA_ID } from "./control_v0.js";
+async function loadControlSchema() {
+    const schemaPath = fileURLToPath(new URL("../schemas/mova.control_v0.schema.json", import.meta.url));
+    const raw = await fs.readFile(schemaPath, "utf8");
+    return JSON.parse(raw);
+}
+export async function validateControlV0Schema(control) {
+    const schema = await loadControlSchema();
+    const ajv = new Ajv({ allErrors: true, strict: true, validateSchema: false });
+    addFormats(ajv);
+    ajv.addSchema(schema, CONTROL_V0_SCHEMA_ID);
+    const validate = ajv.compile(schema);
+    const ok = Boolean(validate(control));
+    return { ok, errors: validate.errors };
+}

package/dist/init_v0.d.ts

@@ -1,7 +1,12 @@
+import { type ControlV0 } from "./control_v0.js";
 type InitResult = {
     createdFiles: string[];
     zipRelPath?: string;
     zipSha256?: string;
 };
-export declare function initProfileV0(outRoot: string, emitZip: boolean): Promise<InitResult>;
+type InitOptions = {
+    controlOverride?: ControlV0;
+    assetsRoot?: string;
+};
+export declare function initProfileV0(outRoot: string, emitZip: boolean, options?: InitOptions): Promise<InitResult>;
 export {};

package/dist/init_v0.js

@@ -4,6 +4,7 @@ import { getAnthropicProfileV0Files } from "./anthropic_profile_v0.js";
 import { stableStringify } from "./stable_json.js";
 import { createExportZipV0 } from "./export_zip_v0.js";
 import { writeCleanClaudeProfileScaffoldV0 } from "./claude_profile_scaffold_v0.js";
+import { defaultControlV0 } from "./control_v0.js";
 async function writeTextFile(absPath, content) {
     await fs.mkdir(path.dirname(absPath), { recursive: true });
     await fs.writeFile(absPath, content, "utf8");
@@ -12,7 +13,38 @@ async function writeJsonFile(absPath, obj) {
     await fs.mkdir(path.dirname(absPath), { recursive: true });
     await fs.writeFile(absPath, stableStringify(obj) + "\n", "utf8");
 }
-export async function initProfileV0(outRoot, emitZip) {
+async function copyPresetAssets(control, assetsRoot, outRoot) {
+    const created = [];
+    const assets = [
+        ...control.assets.skills,
+        ...control.assets.agents,
+        ...control.assets.commands,
+        ...control.assets.rules,
+        ...control.assets.hooks,
+        ...control.assets.workflows,
+        ...control.assets.docs,
+        ...control.assets.dotfiles,
+        ...control.assets.schemas,
+    ];
+    for (const asset of assets) {
+        const sourceRel = asset.source_path ?? asset.path;
+        const source = path.isAbsolute(sourceRel) ? sourceRel : path.join(assetsRoot, sourceRel);
+        const target = path.join(outRoot, asset.path);
+        try {
+            await fs.stat(source);
+        }
+        catch {
+            continue;
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        if (source !== target) {
+            await fs.copyFile(source, target);
+        }
+        created.push(asset.path.replace(/\\/g, "/"));
+    }
+    return created.sort();
+}
+export async function initProfileV0(outRoot, emitZip, options) {
     const createdFiles = [];
     await writeCleanClaudeProfileScaffoldV0(outRoot);
     const profileFiles = getAnthropicProfileV0Files();
@@ -22,6 +54,14 @@ export async function initProfileV0(outRoot, emitZip) {
         await writeTextFile(path.join(outRoot, rel), content);
         createdFiles.push(rel);
     }
+    const controlRel = path.join("mova", "control_v0.json").replace(/\\/g, "/");
+    const control = options?.controlOverride ?? defaultControlV0();
+    await writeJsonFile(path.join(outRoot, controlRel), control);
+    createdFiles.push(controlRel);
+    if (options?.assetsRoot) {
+        const assetFiles = await copyPresetAssets(control, options.assetsRoot, outRoot);
+        createdFiles.push(...assetFiles);
+    }
     const movaBase = path.join(outRoot, "mova", "claude_import", "v0");
     const initManifestRel = path.join("mova", "claude_import", "v0", "init_manifest_v0.json").replace(/\\/g, "/");
     let zipRelPath;

package/dist/observability_writer_v0.d.ts

@@ -0,0 +1 @@
+export declare function getMovaObserveScriptV0(): string;