mova-claude-import 0.1.1 → 0.1.3

package/src/control_apply_v0.ts

@@ -4,10 +4,18 @@ import { stableStringify } from "./stable_json.js";
 import { stableSha256 } from "./redaction.js";
 import { buildMovaControlEntryV0, MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
 import { ensureClaudeControlSurfacesV0 } from "./claude_profile_scaffold_v0.js";
+import { controlToMcpJson, controlToSettingsV0, normalizeControlV0 } from "./control_v0.js";
+import { validateControlV0Schema } from "./control_v0_schema.js";
+import { getMovaObserveScriptV0 } from "./observability_writer_v0.js";
 
 type ApplyResult = {
   run_id: string;
   report_path: string;
+  exit_code?: number;
+};
+
+type ApplyOptions = {
+  assetSourceRoot?: string;
 };
 
 async function exists(p: string): Promise<boolean> {
@@ -33,6 +41,37 @@ function computeRunId(parts: string[]): string {
   return stableSha256(parts.join("|")).slice(0, 16);
 }
 
+function mergeOverlayValue(existing: any, incoming: any): any {
+  if (existing === undefined) return incoming;
+  const existingArr = Array.isArray(existing) ? existing : null;
+  const incomingArr = Array.isArray(incoming) ? incoming : null;
+  if (existingArr || incomingArr) {
+    const left = existingArr ?? (existing === undefined ? [] : [existing]);
+    const right = incomingArr ?? (incoming === undefined ? [] : [incoming]);
+    const seen = new Set(left.map((item) => stableStringify(item)));
+    const merged = left.slice();
+    for (const item of right) {
+      const key = stableStringify(item);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      merged.push(item);
+    }
+    return merged;
+  }
+  if (existing && typeof existing === "object" && incoming && typeof incoming === "object") {
+    const out: Record<string, any> = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+      out[key] = mergeOverlayValue(out[key], value);
+    }
+    return out;
+  }
+  return existing;
+}
+
+function mergeSettingsOverlay(existing: any, incoming: any) {
+  return mergeOverlayValue(existing ?? {}, incoming ?? {});
+}
+
 function updateClaude(content: string, marker: string, block: string): string {
   if (content.includes(marker)) {
     const idx = content.indexOf(marker);
@@ -48,17 +87,41 @@ export async function controlApplyV0(
   projectDir: string,
   profilePath: string,
   outDir: string,
-  mode?: string
+  mode?: string,
+  options?: ApplyOptions
 ): Promise<ApplyResult> {
   await ensureClaudeControlSurfacesV0(projectDir);
   const profile = await readJson(profilePath);
-  const applyMode = mode ?? profile?.apply?.default_apply_mode ?? "preview";
+  const isControlV0 = profile?.version === "control_v0";
+  const control = isControlV0 ? normalizeControlV0(profile).control : null;
+  if (isControlV0) {
+    const validation = await validateControlV0Schema(profile);
+    if (!validation.ok) {
+      const runId = computeRunId([profilePath, "invalid_schema"]);
+      const runBase = path.join(outDir, "mova", "claude_control", "v0", "runs", runId);
+      const reportPath = path.join(runBase, "control_apply_report_v0.json");
+      const report = {
+        profile_version: "v0",
+        run_id: runId,
+        project_dir: projectDir,
+        profile_path: profilePath,
+        mode: mode ?? "preview",
+        outcome_code: "INVALID_SCHEMA",
+        errors: validation.errors ?? [],
+      };
+      await writeJson(reportPath, report);
+      return { run_id: runId, report_path: reportPath, exit_code: 2 };
+    }
+  }
+  const applyMode = mode ?? (isControlV0 && control?.policy?.mode === "report_only" ? "preview" : profile?.apply?.default_apply_mode) ?? "preview";
+  const isOverlay = applyMode === "overlay";
+  const assetSourceRoot = options?.assetSourceRoot ?? projectDir;
 
   const claudePath = path.join(projectDir, "CLAUDE.md");
   const mcpPath = path.join(projectDir, ".mcp.json");
   const claudeExists = await exists(claudePath);
   const mcpExists = await exists(mcpPath);
-  const marker = profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
+  const marker = control?.claude_md?.marker ?? profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
 
   const runId = computeRunId([profilePath, claudeExists ? "claude" : "", mcpExists ? "mcp" : "", marker, applyMode]);
   const runBase = path.join(outDir, "mova", "claude_control", "v0", "runs", runId);
@@ -75,15 +138,75 @@ export async function controlApplyV0(
   };
   const controlEntry = buildMovaControlEntryV0(overlayParams);
 
-  const applied = { claude_md: false, mcp_json: false, settings: false };
-  if (applyMode === "apply") {
-    if (profile?.anthropic?.claude_md?.inject_control_entry && claudeExists) {
+  const applied = { claude_md: false, mcp_json: false, settings: false, assets: false, lsp: false };
+  if (applyMode === "apply" || applyMode === "overlay") {
+    if ((control?.claude_md?.inject_control_entry ?? profile?.anthropic?.claude_md?.inject_control_entry) && claudeExists) {
       const raw = await fs.readFile(claudePath, "utf8");
       const updated = updateClaude(raw, marker, controlEntry);
       await fs.writeFile(claudePath, updated, "utf8");
       applied.claude_md = true;
     }
-    if (profile?.anthropic?.mcp?.servers && mcpExists) {
+    if (control) {
+      const settingsPath = path.join(projectDir, ".claude", "settings.json");
+      const settingsGenerated = controlToSettingsV0(control);
+      if (isOverlay && (await exists(settingsPath))) {
+        const current = await readJson(settingsPath);
+        const merged = mergeSettingsOverlay(current, settingsGenerated);
+        await writeJson(settingsPath, merged);
+      } else {
+        await writeJson(settingsPath, settingsGenerated);
+      }
+      applied.settings = true;
+
+      if (!(isOverlay && (await exists(mcpPath)))) {
+        await writeJson(path.join(projectDir, ".mcp.json"), controlToMcpJson(control));
+        applied.mcp_json = true;
+      }
+
+      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 target = path.join(projectDir, asset.path);
+        if (isOverlay && (await exists(target))) continue;
+        const sourceRel = asset.source_path ?? asset.path;
+        const source = path.isAbsolute(sourceRel) ? sourceRel : path.join(assetSourceRoot, sourceRel);
+        try {
+          await fs.stat(source);
+        } catch {
+          continue;
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        if (source !== target) {
+          await fs.copyFile(source, target);
+        }
+      }
+      applied.assets = assets.length > 0;
+
+      if (control.lsp.managed && Array.isArray(control.lsp.enabled_plugins)) {
+        const lspPath = path.join(projectDir, control.lsp.config_path);
+        if (!(isOverlay && (await exists(lspPath)))) {
+          await writeJson(lspPath, { enabled_plugins: control.lsp.enabled_plugins });
+        }
+        applied.lsp = true;
+      }
+
+      if (control.observability.enable && control.observability.writer?.script_path) {
+        const scriptPath = path.join(projectDir, control.observability.writer.script_path);
+        if (!(isOverlay && (await exists(scriptPath)))) {
+          await fs.mkdir(path.dirname(scriptPath), { recursive: true });
+          await fs.writeFile(scriptPath, getMovaObserveScriptV0(), "utf8");
+        }
+      }
+    } else if (profile?.anthropic?.mcp?.servers && mcpExists) {
       const mcp = await readJson(mcpPath);
       const merged = { ...mcp, servers: profile.anthropic.mcp.servers };
       await fs.writeFile(mcpPath, stableStringify(merged) + "\n", "utf8");
@@ -97,7 +220,7 @@ export async function controlApplyV0(
     project_dir: projectDir,
     profile_path: profilePath,
     mode: applyMode,
-    outcome_code: applyMode === "apply" ? "APPLIED" : "PREVIEW",
+    outcome_code: applyMode === "apply" || applyMode === "overlay" ? "APPLIED" : "PREVIEW",
     applied,
   };
 

package/src/control_check_v0.ts

@@ -3,11 +3,14 @@ import path from "node:path";
 import { stableStringify } from "./stable_json.js";
 import { stableSha256 } from "./redaction.js";
 import { buildMovaControlEntryV0, MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+import { controlToMcpJson, controlToSettingsV0, normalizeControlV0 } from "./control_v0.js";
+import { validateControlV0Schema } from "./control_v0_schema.js";
 
 type CheckResult = {
   run_id: string;
   plan_path: string;
   summary_path: string;
+  exit_code?: number;
 };
 
 async function exists(p: string): Promise<boolean> {
@@ -33,14 +36,48 @@ function computeRunId(parts: string[]): string {
   return stableSha256(parts.join("|")).slice(0, 16);
 }
 
+function normalizeJson(obj: any): string {
+  return stableStringify(obj);
+}
+
+function isPlaceholder(value: string): boolean {
+  return /^\$\{[A-Z0-9_]+(?::-?[^}]+)?\}$/.test(value.trim());
+}
+
+function validateMcpEnvValues(servers: any): Array<{ server: string; key: string; value: string }> {
+  if (!servers || typeof servers !== "object") return [];
+  const issues: Array<{ server: string; key: string; value: string }> = [];
+  const entries = Array.isArray(servers)
+    ? servers.map((server, idx) => [server?.name ?? `index_${idx}`, server])
+    : Object.entries(servers);
+  for (const [name, server] of entries) {
+    if (!server || typeof server !== "object") continue;
+    const env = (server as any).env;
+    if (!env || typeof env !== "object") continue;
+    for (const [key, value] of Object.entries(env)) {
+      if (typeof value !== "string") continue;
+      if (!value.includes("${")) continue;
+      if (!isPlaceholder(value)) {
+        issues.push({ server: String(name), key, value });
+      }
+    }
+  }
+  return issues;
+}
+
 export async function controlCheckV0(projectDir: string, profilePath: string, outDir: string): Promise<CheckResult> {
   const profile = await readJson(profilePath);
   const claudePath = path.join(projectDir, "CLAUDE.md");
   const mcpPath = path.join(projectDir, ".mcp.json");
+  const settingsPath = path.join(projectDir, ".claude", "settings.json");
 
   const claudeExists = await exists(claudePath);
   const mcpExists = await exists(mcpPath);
-  const marker = profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
+  const settingsExists = await exists(settingsPath);
+  const isControlV0 = profile?.version === "control_v0";
+  const marker = isControlV0
+    ? profile?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER
+    : profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
 
   const runId = computeRunId([profilePath, claudeExists ? "claude" : "", mcpExists ? "mcp" : "", marker]);
   const runBase = path.join(outDir, "mova", "claude_control", "v0", "runs", runId);
@@ -56,20 +93,148 @@ export async function controlCheckV0(projectDir: string, profilePath: string, ou
     exportManifestFile: "export_manifest_v0.json",
   };
 
-  const actions = [];
-  if (profile?.anthropic?.claude_md?.inject_control_entry) {
-    actions.push({
-      target: "CLAUDE.md",
-      action: "insert_or_update_control_entry",
-      marker,
-    });
+  if (!isControlV0) {
+    const actions = [];
+    if (profile?.anthropic?.claude_md?.inject_control_entry) {
+      actions.push({
+        target: "CLAUDE.md",
+        action: "insert_or_update_control_entry",
+        marker,
+      });
+    }
+    if (profile?.anthropic?.mcp?.servers && mcpExists) {
+      actions.push({
+        target: ".mcp.json",
+        action: "merge_servers",
+        summary: "merge profile servers with project mcp.json",
+      });
+    }
+
+    const plan = {
+      profile_version: "v0",
+      run_id: runId,
+      project_dir: projectDir,
+      profile_path: profilePath,
+      actions,
+    };
+
+    const summary = {
+      run_id: runId,
+      outcome_code: "PREVIEW",
+      actions_count: actions.length,
+      control_entry_preview: profile?.anthropic?.claude_md?.inject_control_entry
+        ? buildMovaControlEntryV0(overlayParams)
+        : null,
+    };
+
+    const planPath = path.join(runBase, "control_plan_v0.json");
+    const summaryPath = path.join(runBase, "control_summary_v0.json");
+    await writeJson(planPath, plan);
+    await writeJson(summaryPath, summary);
+
+    return { run_id: runId, plan_path: planPath, summary_path: summaryPath };
+  }
+
+  const schemaValidation = await validateControlV0Schema(profile);
+  const control = normalizeControlV0(profile).control;
+  const planPath = path.join(runBase, "control_plan_v0.json");
+  const summaryPath = path.join(runBase, "control_summary_v0.json");
+
+  if (!schemaValidation.ok) {
+    const summary = {
+      run_id: runId,
+      outcome_code: "INVALID_SCHEMA",
+      errors: schemaValidation.errors ?? [],
+    };
+    await writeJson(planPath, { profile_version: "v0", run_id: runId, project_dir: projectDir, profile_path: profilePath, actions: [] });
+    await writeJson(summaryPath, summary);
+    return { run_id: runId, plan_path: planPath, summary_path: summaryPath, exit_code: 2 };
+  }
+
+  const mcpJsonExpected = controlToMcpJson(control);
+  const settingsExpected = controlToSettingsV0(control);
+  const missing: string[] = [];
+  const drift: Array<{ path: string; expected: string; actual: string }> = [];
+
+  if (!claudeExists) missing.push("CLAUDE.md");
+  if (!settingsExists) missing.push(".claude/settings.json");
+  if (!mcpExists) missing.push(".mcp.json");
+
+  if (claudeExists && control.claude_md.inject_control_entry) {
+    const claude = await fs.readFile(claudePath, "utf8");
+    if (!claude.includes(control.claude_md.marker)) {
+      drift.push({ path: "CLAUDE.md", expected: `marker:${control.claude_md.marker}`, actual: "missing_marker" });
+    }
   }
-  if (profile?.anthropic?.mcp?.servers && mcpExists) {
-    actions.push({
-      target: ".mcp.json",
-      action: "merge_servers",
-      summary: "merge profile servers with project mcp.json",
-    });
+
+  if (settingsExists) {
+    const actual = normalizeJson(await readJson(settingsPath));
+    const expected = normalizeJson(settingsExpected);
+    if (actual !== expected) {
+      drift.push({ path: ".claude/settings.json", expected, actual });
+    }
+  }
+
+  if (mcpExists) {
+    const actual = normalizeJson(await readJson(mcpPath));
+    const expected = normalizeJson(mcpJsonExpected);
+    if (actual !== expected) {
+      drift.push({ path: ".mcp.json", expected, actual });
+    }
+  }
+
+  if (control.lsp.managed) {
+    const lspPath = control.lsp.config_path;
+    const abs = path.join(projectDir, lspPath);
+    if (!(await exists(abs))) {
+      missing.push(lspPath);
+    } else {
+      const actual = normalizeJson(await readJson(abs));
+      const expected = normalizeJson({ enabled_plugins: control.lsp.enabled_plugins });
+      if (actual !== expected) {
+        drift.push({ path: lspPath, expected, actual });
+      }
+    }
+  }
+
+  if (control.observability.enable && control.observability.writer?.script_path) {
+    const obsPath = path.join(projectDir, control.observability.writer.script_path);
+    if (!(await exists(obsPath))) {
+      missing.push(control.observability.writer.script_path);
+    }
+  }
+
+  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 abs = path.join(projectDir, asset.path);
+    if (!(await exists(abs))) {
+      missing.push(asset.path);
+    }
+  }
+
+  const envIssues = validateMcpEnvValues(control.mcp.servers);
+
+  let outcome = "OK";
+  let exitCode = 0;
+  if (envIssues.length > 0) {
+    outcome = "INVALID_CONTROL";
+    exitCode = 2;
+  } else if (missing.length > 0) {
+    outcome = "MISSING_REQUIRED_FILES";
+    exitCode = 4;
+  } else if (drift.length > 0) {
+    outcome = "DRIFT";
+    exitCode = 3;
   }
 
   const plan = {
@@ -77,22 +242,37 @@ export async function controlCheckV0(projectDir: string, profilePath: string, ou
     run_id: runId,
     project_dir: projectDir,
     profile_path: profilePath,
-    actions,
+    actions: [
+      {
+        target: "CLAUDE.md",
+        action: "ensure_control_entry",
+        marker: control.claude_md.marker,
+      },
+      {
+        target: ".claude/settings.json",
+        action: "overwrite",
+      },
+      {
+        target: ".mcp.json",
+        action: "overwrite",
+      },
+    ],
   };
 
   const summary = {
     run_id: runId,
-    outcome_code: "PREVIEW",
-    actions_count: actions.length,
-    control_entry_preview: profile?.anthropic?.claude_md?.inject_control_entry
-      ? buildMovaControlEntryV0(overlayParams)
-      : null,
+    outcome_code: outcome,
+    exit_code: exitCode,
+    missing,
+    drift_count: drift.length,
+    invalid_mcp_env: envIssues,
+    control_entry_preview: control.claude_md.inject_control_entry ? buildMovaControlEntryV0(overlayParams) : null,
   };
 
-  const planPath = path.join(runBase, "control_plan_v0.json");
-  const summaryPath = path.join(runBase, "control_summary_v0.json");
+  const reportPath = path.join(runBase, "control_check_report_v0.json");
   await writeJson(planPath, plan);
   await writeJson(summaryPath, summary);
+  await writeJson(reportPath, { summary, drift, missing, invalid_mcp_env: envIssues });
 
-  return { run_id: runId, plan_path: planPath, summary_path: summaryPath };
+  return { run_id: runId, plan_path: planPath, summary_path: summaryPath, exit_code: exitCode };
 }

package/src/control_prefill_v0.ts

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { stableStringify } from "./stable_json.js";
 import { loadControlContractsV0 } from "./control_contracts_v0.js";
+import { controlFromSettingsV0, normalizeControlV0 } from "./control_v0.js";
 
 type PrefillResult = {
   profile_path: string;
@@ -17,6 +18,21 @@ async function exists(p: string): Promise<boolean> {
   }
 }
 
+async function listFilesRec(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  const stack = [dir];
+  while (stack.length) {
+    const current = stack.pop()!;
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const e of entries) {
+      const abs = path.join(current, e.name);
+      if (e.isDirectory()) stack.push(abs);
+      else if (e.isFile()) out.push(abs);
+    }
+  }
+  return out;
+}
+
 async function readJson(p: string) {
   const raw = await fs.readFile(p, "utf8");
   return JSON.parse(raw);
@@ -34,29 +50,129 @@ export async function controlPrefillV0(projectDir: string, outDir: string): Prom
   const settingsPath = path.join(projectDir, ".claude", "settings.json");
   const settingsLocalPath = path.join(projectDir, ".claude", "settings.local.json");
 
-  let mcpServers: any = {};
+  let mcpParsed: any | undefined;
   let mcpFound = false;
   if (await exists(mcpPath)) {
-    const parsed = await readJson(mcpPath);
-    if (Array.isArray(parsed?.servers)) {
-      mcpServers = { servers: parsed.servers };
-    } else if (parsed?.servers && typeof parsed.servers === "object") {
-      mcpServers = { servers: parsed.servers };
-    }
+    mcpParsed = await readJson(mcpPath);
     mcpFound = true;
   }
 
   if (template?.anthropic?.mcp) {
-    template.anthropic.mcp.servers = mcpServers.servers ?? {};
+    const servers = mcpParsed?.mcpServers ?? mcpParsed?.servers ?? {};
+    template.anthropic.mcp.servers = servers;
+  }
+
+  let settingsParsed: any | undefined;
+  if (await exists(settingsPath)) {
+    settingsParsed = await readJson(settingsPath);
+  }
+
+  const controlDerived = controlFromSettingsV0(settingsParsed, mcpParsed);
+  const control = normalizeControlV0(controlDerived.control).control;
+
+  const skills: Array<{ path: string; mode: "copy_through"; source_path: string }> = [];
+  const skillsRoot = path.join(projectDir, ".claude", "skills");
+  if (await exists(skillsRoot)) {
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const rel = `.claude/skills/${entry.name}/SKILL.md`;
+      const abs = path.join(skillsRoot, entry.name, "SKILL.md");
+      if (await exists(abs)) {
+        skills.push({ path: rel, mode: "copy_through", source_path: rel });
+      }
+    }
+  }
+
+  const assetDirs = [
+    { key: "agents", root: path.join(projectDir, ".claude", "agents"), prefix: ".claude/agents" },
+    { key: "commands", root: path.join(projectDir, ".claude", "commands"), prefix: ".claude/commands" },
+    { key: "rules", root: path.join(projectDir, ".claude", "rules"), prefix: ".claude/rules" },
+    { key: "hooks", root: path.join(projectDir, ".claude", "hooks"), prefix: ".claude/hooks" },
+  ] as const;
+
+  const assetMap: Record<string, Array<{ path: string; mode: "copy_through"; source_path: string }>> = {
+    agents: [],
+    commands: [],
+    rules: [],
+    hooks: [],
+    workflows: [],
+    docs: [],
+    dotfiles: [],
+    schemas: [],
+  };
+
+  for (const dir of assetDirs) {
+    if (!(await exists(dir.root))) continue;
+    const files = await listFilesRec(dir.root);
+    for (const abs of files) {
+      const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+      assetMap[dir.key].push({ path: rel, mode: "copy_through", source_path: rel });
+    }
+  }
+
+  const docsCandidates = [
+    path.join(projectDir, ".claude", "settings.md"),
+    path.join(projectDir, ".claude", "skills", "README.md"),
+  ];
+  for (const abs of docsCandidates) {
+    if (await exists(abs)) {
+      const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+      assetMap.docs.push({ path: rel, mode: "copy_through", source_path: rel });
+    }
+  }
+
+  const dotfileCandidates = [path.join(projectDir, ".claude", ".gitignore")];
+  for (const abs of dotfileCandidates) {
+    if (await exists(abs)) {
+      const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+      assetMap.dotfiles.push({ path: rel, mode: "copy_through", source_path: rel });
+    }
+  }
+
+  const schemasRoot = path.join(projectDir, ".claude");
+  if (await exists(schemasRoot)) {
+    const files = await listFilesRec(schemasRoot);
+    for (const abs of files) {
+      if (!abs.endsWith(".schema.json")) continue;
+      const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+      assetMap.schemas.push({ path: rel, mode: "copy_through", source_path: rel });
+    }
+  }
+
+  const workflowsRoot = path.join(projectDir, ".github", "workflows");
+  if (await exists(workflowsRoot)) {
+    const files = await listFilesRec(workflowsRoot);
+    for (const abs of files) {
+      const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+      assetMap.workflows.push({ path: rel, mode: "copy_through", source_path: rel });
+    }
+  }
+
+  control.assets.skills = skills.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.agents = assetMap.agents.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.commands = assetMap.commands.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.rules = assetMap.rules.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.hooks = assetMap.hooks.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.workflows = assetMap.workflows.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.docs = assetMap.docs.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.dotfiles = assetMap.dotfiles.sort((a, b) => a.path.localeCompare(b.path));
+  control.assets.schemas = assetMap.schemas.sort((a, b) => a.path.localeCompare(b.path));
+
+  const hasSkillEval = control.assets.hooks.some((h) => h.path.endsWith("skill-eval.sh") || h.path.endsWith("skill-eval.js"));
+  if (hasSkillEval) {
+    control.skill_eval.enable = true;
   }
 
   const profilePath = path.join(outDir, "claude_control_profile_v0.json");
   const reportPath = path.join(outDir, "prefill_report_v0.json");
+  const controlPath = path.join(outDir, "mova", "control_v0.json");
 
   const report = {
     profile_version: "v0",
     project_dir: projectDir,
     profile_path: profilePath,
+    control_path: controlPath,
     found: {
       mcp_json: mcpFound,
       settings_json: await exists(settingsPath),
@@ -64,10 +180,22 @@ export async function controlPrefillV0(projectDir: string, outDir: string): Prom
     },
     applied: {
       mcp_servers: mcpFound,
+      assets: {
+        skills: control.assets.skills.length,
+        agents: control.assets.agents.length,
+        commands: control.assets.commands.length,
+        rules: control.assets.rules.length,
+        hooks: control.assets.hooks.length,
+        workflows: control.assets.workflows.length,
+        docs: control.assets.docs.length,
+        dotfiles: control.assets.dotfiles.length,
+        schemas: control.assets.schemas.length,
+      },
     },
   };
 
   await writeJson(profilePath, template);
+  await writeJson(controlPath, control);
   await writeJson(reportPath, report);
 
   return { profile_path: profilePath, report_path: reportPath };