fix

Author: zbeyens

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "skiller",
-	"version": "0.7.21",
+	"version": "0.7.22",
 	"description": "Skiller — apply the same rules to all coding agents",
 	"main": "dist/lib.js",
 	"publishConfig": {

src/core/ClaudePluginSync.ts

@@ -48,6 +48,11 @@ interface PluginResolvedSource {
   version?: string;
 }
 
+interface PluginPackageManifestEntry {
+  name?: string;
+  source?: string;
+}
+
 interface LegacyMarkerFile {
   pluginId: string;
   pluginVersion?: string;
@@ -191,6 +196,74 @@ async function resolvePluginMarketplaceRoot(
   return null;
 }
 
+async function hasPluginContent(root: string): Promise<boolean> {
+  const candidates = [
+    path.join(root, 'skills'),
+    path.join(root, 'commands'),
+    path.join(root, 'agents'),
+  ];
+
+  for (const candidate of candidates) {
+    if (await dirExists(candidate)) return true;
+  }
+
+  return false;
+}
+
+async function readPluginPackageManifestEntries(
+  installPath: string,
+): Promise<PluginPackageManifestEntry[]> {
+  const packageJsonPath = path.join(installPath, 'package.json');
+
+  try {
+    const raw = JSON.parse(await fs.readFile(packageJsonPath, 'utf8')) as {
+      plugins?: unknown;
+    };
+    if (!Array.isArray(raw.plugins)) return [];
+
+    return raw.plugins.filter(
+      (entry): entry is PluginPackageManifestEntry =>
+        Boolean(entry) && typeof entry === 'object',
+    );
+  } catch {
+    return [];
+  }
+}
+
+async function resolveInstalledPluginSourceRoot(
+  pluginId: string,
+  installPath: string,
+): Promise<string | null> {
+  const manifestEntries = await readPluginPackageManifestEntries(installPath);
+  const parsedPluginId = parsePluginId(pluginId);
+  const matchingEntry =
+    manifestEntries.find(
+      (entry) => entry.name === parsedPluginId?.pluginName,
+    ) ?? (manifestEntries.length === 1 ? manifestEntries[0] : null);
+
+  const rawSource =
+    typeof matchingEntry?.source === 'string' &&
+    matchingEntry.source.trim() !== ''
+      ? matchingEntry.source
+      : '.';
+
+  const sourceRoot = path.resolve(installPath, rawSource);
+  const normalizedInstallPath = path.resolve(installPath);
+  const isWithinInstallPath =
+    sourceRoot === normalizedInstallPath ||
+    sourceRoot.startsWith(normalizedInstallPath + path.sep);
+
+  if (isWithinInstallPath && (await hasPluginContent(sourceRoot))) {
+    return sourceRoot;
+  }
+
+  if (await hasPluginContent(installPath)) {
+    return installPath;
+  }
+
+  return null;
+}
+
 export function resolvePluginInstall(
   pluginId: string,
   projectRoot: string,
@@ -772,13 +845,27 @@ export async function syncClaudePluginsToSkillsDirs(
   const unresolvedEnabled = new Set<string>();
 
   for (const pluginId of enabledPlugins) {
-    const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir);
+    const resolved = index
+      ? resolvePluginInstall(pluginId, projectRoot, index)
+      : null;
+    const marketplaceRoot = await resolvePluginMarketplaceRoot(
+      pluginId,
+      claudeDir,
+    );
+    const pluginRoot =
+      (marketplaceRoot && (await hasPluginContent(marketplaceRoot))
+        ? marketplaceRoot
+        : null) ??
+      (resolved
+        ? await resolveInstalledPluginSourceRoot(pluginId, resolved.installPath)
+        : null);
+
     if (!pluginRoot) {
       unresolvedEnabled.add(pluginId);
       const hasIndexEntry = Boolean(index?.plugins?.[pluginId]?.length);
       if (hasIndexEntry) {
         logVerboseInfo(
-          `[plugins] Enabled plugin has no marketplace content, skipping: ${pluginId}`,
+          `[plugins] Enabled plugin has no syncable content, skipping: ${pluginId}`,
           verbose,
           dryRun,
         );
@@ -788,10 +875,6 @@ export async function syncClaudePluginsToSkillsDirs(
       continue;
     }
 
-    const resolved = index
-      ? resolvePluginInstall(pluginId, projectRoot, index)
-      : null;
-
     resolvedSources.push({
       pluginId,
       pluginRoot,

tests/integration/claude-plugins-to-skills.integration.test.ts

@@ -175,4 +175,127 @@ Find docs and summarize.
       fs.access(path.join(expectedAgentDir, 'SKILL.md')),
     ).resolves.toBeUndefined();
   });
+
+  it('syncs plugin skills from the installed plugin root when marketplace discovery has no syncable content', async () => {
+    const { projectRoot } = testProject;
+
+    const pluginId = 'planning-with-files@testmarket';
+    const emptyMarketplacePluginPath = path.join(
+      tmpHome,
+      '.claude',
+      'plugins',
+      'marketplaces',
+      'testmarket',
+      'plugins',
+      'planning-with-files',
+    );
+    const pluginInstallPath = path.join(
+      tmpHome,
+      '.claude',
+      'plugins',
+      'cache',
+      'testmarket',
+      'planning-with-files',
+      '2.21.0',
+    );
+
+    await fs.mkdir(emptyMarketplacePluginPath, { recursive: true });
+    const pluginSkillDir = path.join(pluginInstallPath, 'skills', 'plan');
+    await fs.mkdir(pluginSkillDir, { recursive: true });
+    await fs.writeFile(
+      path.join(pluginInstallPath, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'planning-with-files',
+          owner: {
+            name: 'Ahmad Othman Ammar Adi',
+            url: 'https://github.com/OthmanAdi',
+          },
+          plugins: [
+            {
+              name: 'planning-with-files',
+              source: './',
+              description:
+                'Manus-style persistent markdown files for planning, progress tracking, and knowledge storage. Now with hooks integration.',
+              version: '2.21.0',
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+    );
+    await fs.writeFile(
+      path.join(pluginSkillDir, 'SKILL.md'),
+      `---
+name: plan
+description: Persistent planning
+---
+
+Write plans to files.
+`,
+    );
+
+    const indexPath = path.join(
+      tmpHome,
+      '.claude',
+      'plugins',
+      'installed_plugins.json',
+    );
+    await fs.mkdir(path.dirname(indexPath), { recursive: true });
+    await fs.writeFile(
+      indexPath,
+      JSON.stringify(
+        {
+          version: 2,
+          plugins: {
+            [pluginId]: [
+              {
+                scope: 'project',
+                projectPath: projectRoot,
+                installPath: pluginInstallPath,
+                version: '2.21.0',
+                installedAt: '2026-03-01T00:00:00.000Z',
+                lastUpdated: '2026-03-02T00:00:00.000Z',
+              },
+            ],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    await fs.writeFile(
+      path.join(projectRoot, '.claude', 'settings.json'),
+      JSON.stringify(
+        {
+          enabledPlugins: {
+            [pluginId]: true,
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    await applyAllAgentConfigs(
+      projectRoot,
+      ['codex'],
+      undefined,
+      false,
+      undefined,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      true,
+    );
+
+    await expect(
+      fs.access(path.join(projectRoot, '.codex', 'skills', 'plan', 'SKILL.md')),
+    ).resolves.toBeUndefined();
+  });
 });