@piecemaker-legal/piecemaker 2.0.17 → 2.0.19

package/server/piecemaker/library/global-state.ts

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { listUserProviderConnectors } from './provider-connectors.js';
+
+const GLOBAL_DIRECTORIES = [
+  ['.claude/skills', 'Claude'],
+  ['.claude/agents', 'Claude'],
+  ['.codex/skills', 'Codex'],
+  ['.codex/agents', 'Codex'],
+  ['.agents/skills', 'Codex'],
+  ['.cursor/skills', 'Cursor'],
+  ['.cursor/agents', 'Cursor'],
+  ['.config/opencode/skills', 'OpenCode'],
+  ['.config/opencode/agent', 'OpenCode'],
+  ['.config/opencode/agents', 'OpenCode'],
+  ['.grok/skills', 'Grok'],
+  ['.grok/agents', 'Grok'],
+] as const;
+
+const GLOBAL_CONNECTOR_FILES = [
+  ['.claude.json', 'Claude'],
+  ['.codex/config.toml', 'Codex'],
+  ['.cursor/mcp.json', 'Cursor'],
+  ['.config/opencode/opencode.json', 'OpenCode'],
+  ['.config/opencode/opencode.jsonc', 'OpenCode'],
+  ['.grok/config.toml', 'Grok'],
+] as const;
+
+export function globalProviderIndex(userHome: string) {
+  const providers = new Map<string, Set<string>>();
+  const record = (source: string, provider: string) => {
+    providers.set(source, (providers.get(source) ?? new Set()).add(provider));
+  };
+  for (const [directory, provider] of GLOBAL_DIRECTORIES) {
+    const root = path.join(userHome, directory);
+    let children: string[];
+    try { children = fs.readdirSync(root); } catch { continue; }
+    for (const child of children) {
+      for (const candidate of [path.join(root, child), path.join(root, child, 'SKILL.md')]) {
+        try {
+          if (!fs.statSync(candidate).isFile()) continue;
+          record(candidate, provider);
+          record(fs.realpathSync(candidate), provider);
+        } catch {}
+      }
+    }
+  }
+  for (const connector of listUserProviderConnectors(userHome)) {
+    const file = connector.source.slice(0, connector.source.lastIndexOf('#'));
+    const match = GLOBAL_CONNECTOR_FILES.find(([name]) => path.join(userHome, name) === file);
+    if (match) record(connector.source, match[1]);
+  }
+  return (sources: string[]) => [...new Set(sources.flatMap((source) => [...(providers.get(source) ?? [])]))].sort();
+}

package/server/piecemaker/library/index.ts

@@ -7,6 +7,7 @@ import express from 'express';
 import { createLibraryStore } from './store.js';
 import { createLibraryRouter } from './routes.js';
 import { createLibraryMarketplaceRouter, scanInstalledLibraryCollections } from './marketplace.js';
+import { importLibraryDirectory } from './migrate.js';
 import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
 import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.js';
 import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
@@ -22,6 +23,12 @@ export async function openLibrary(home: string, applicationRoot: string) {
   try { scanAndPersistLibraryProviderConnectors(store, os.homedir()); } catch {}
   try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
   try { fs.unlinkSync(path.join(store.directory, 'connection.json')); } catch {}
+  const bundled = path.join(applicationRoot, 'server/piecemaker/vendor/piecemaker-plugin');
+  const defaults: string[] = [];
+  for (const [folder, kind] of [['skills', 'skill'], ['agents', 'agent']] as const) {
+    try { defaults.push(...importLibraryDirectory(store, path.join(bundled, folder), kind).map((entry) => entry.id)); } catch {}
+  }
+  store.setDefaultEntries(defaults);
   const router = express.Router();
   router.use((req, res, next) => {
     const length = Number(req.headers['content-length'] || 0);

package/server/piecemaker/library/marketplace.ts

@@ -6,7 +6,7 @@ import { spawnSync } from 'node:child_process';
 import express from 'express';
 
 import type { createLibraryStore } from './store.js';
-import { normalizeProviderConnector } from './connector-installation.js';
+import { normalizeProviderConnector, setWorkspaceClaudePlugin, workspaceClaudePlugins } from './connector-installation.js';
 import { importLibraryDirectory } from './migrate.js';
 import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
 import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.js';
@@ -45,7 +45,16 @@ function marketplacePackageKinds(userHome: string, marketplaceName: string, plug
   return [...kinds];
 }
 
-function disableNativeClaudePlugin(userHome: string, id: string) {
+function userClaudePlugins(userHome: string) {
+  const settingsFilename = path.join(userHome, '.claude/settings.json');
+  if (!fs.existsSync(settingsFilename)) return {};
+  const enabledPlugins = JSON.parse(fs.readFileSync(settingsFilename, 'utf8')).enabledPlugins;
+  return enabledPlugins && typeof enabledPlugins === 'object' && !Array.isArray(enabledPlugins)
+    ? enabledPlugins as Record<string, unknown>
+    : {};
+}
+
+function setNativeClaudePlugin(userHome: string, id: string, enabled: boolean) {
   const settingsFilename = path.join(userHome, '.claude/settings.json');
   const settings = fs.existsSync(settingsFilename)
     ? JSON.parse(fs.readFileSync(settingsFilename, 'utf8'))
@@ -53,8 +62,8 @@ function disableNativeClaudePlugin(userHome: string, id: string) {
   const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
     ? settings.enabledPlugins
     : {};
-  if (enabledPlugins[id] === false) return;
-  settings.enabledPlugins = { ...enabledPlugins, [id]: false };
+  if (enabledPlugins[id] === enabled) return;
+  settings.enabledPlugins = { ...enabledPlugins, [id]: enabled };
   fs.mkdirSync(path.dirname(settingsFilename), { recursive: true, mode: 0o700 });
   const temporary = `${settingsFilename}.library.tmp`;
   fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
@@ -129,39 +138,6 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
   }
 }
 
-function readInstalledClaudePlugins(userHome: string) {
-  const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
-  if (!fs.existsSync(filename)) return {};
-  const config = JSON.parse(fs.readFileSync(filename, 'utf8'));
-  return config.plugins && typeof config.plugins === 'object' && !Array.isArray(config.plugins)
-    ? config.plugins as Record<string, unknown>
-    : {};
-}
-
-function synchronizeInstalledPluginActivation(
-  store: ReturnType<typeof createLibraryStore>,
-  userHome: string,
-  workspacePath: string,
-) {
-  const settingsFilename = path.join(userHome, '.claude/settings.json');
-  if (!fs.existsSync(settingsFilename)) return store.listCollections(workspacePath);
-  const settings = JSON.parse(fs.readFileSync(settingsFilename, 'utf8'));
-  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
-    ? settings.enabledPlugins as Record<string, unknown>
-    : {};
-  const installedPlugins = readInstalledClaudePlugins(userHome);
-  const collections = store.listCollections(workspacePath);
-
-  for (const id of Object.keys(installedPlugins)) {
-    const collection = collections.find((entry) => entry.id === id);
-    const enabled = enabledPlugins[id];
-    if (!collection || collection.componentCount === 0 || typeof enabled !== 'boolean' || collection.enabled === enabled) continue;
-    store.setCollectionEnabled(workspacePath, id, enabled);
-  }
-
-  return store.listCollections(workspacePath);
-}
-
 export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLibraryStore>, applicationRoot: string, userHome: string) {
   const require = createRequire(import.meta.url);
   const { listMarketplaceConnectors, registerOfficialMarketplace } = require(path.join(applicationRoot, 'server/piecemaker/vendor/websocket-server/admin-routes.cjs'));
@@ -181,6 +157,19 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     return fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
   };
   const importInstalledCollections = () => scanInstalledLibraryCollections(store, userHome);
+  const describeCollections = (workspacePath?: string) => {
+    const collections = store.listCollections(workspacePath);
+    const registry = installed();
+    const everywhere = userClaudePlugins(userHome);
+    const here = workspacePath ? workspaceClaudePlugins(fs.realpathSync(workspacePath)) : {};
+    return collections.map((collection) => {
+      const native = Boolean(registry[collection.id]);
+      if (!native) return { ...collection, native, global: false };
+      const global = everywhere[collection.id] === true;
+      const local = here[collection.id];
+      return { ...collection, native, global, partial: false, enabled: Boolean(workspacePath) && (typeof local === 'boolean' ? local : global) };
+    });
+  };
   router.get('/plugin/marketplace', (req, res) => {
     try {
       const marketplace = scope(req.query.scope);
@@ -202,7 +191,7 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
   router.get('/plugins', (req, res) => {
     try {
       const workspacePath = typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined;
-      res.json({ plugins: store.listCollections(workspacePath) });
+      res.json({ plugins: describeCollections(workspacePath) });
     } catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/plugins/sync', async (req, res) => {
@@ -212,12 +201,7 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
       scanAndPersistLibraryProviderAgents(store, userHome);
       scanAndPersistLibraryProviderConnectors(store, userHome);
       scanInstalledLibraryCollections(store, userHome);
-      res.json({
-        ok: true,
-        plugins: workspacePath
-          ? synchronizeInstalledPluginActivation(store, userHome, workspacePath)
-          : store.listCollections(),
-      });
+      res.json({ ok: true, plugins: describeCollections(workspacePath) });
     } catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/plugins/scan', (_req, res) => {
@@ -237,8 +221,28 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     catch (error) { res.status(409).json({ error: (error as Error).message }); }
   });
   router.put('/plugins/:id/activation', (req, res) => {
-    try { res.json(store.setCollectionEnabled(req.body?.workspacePath, String(req.params.id), req.body?.enabled)); }
-    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+    try {
+      const id = String(req.params.id);
+      const workspacePath = req.body?.workspacePath;
+      const enabled = req.body?.enabled;
+      if (typeof workspacePath !== 'string') throw new Error('Dossier absolu requis.');
+      if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
+      const collection = store.listCollections(workspacePath).find((entry) => entry.id === id);
+      const native = Boolean(installed()[id]);
+      if (!collection || (!native && !collection.componentCount)) throw new Error('Plugin introuvable.');
+      if (collection.componentCount) store.setCollectionEnabled(workspacePath, id, enabled, { skipClaude: native });
+      if (native) setWorkspaceClaudePlugin(fs.realpathSync(workspacePath), id, enabled ? true : userClaudePlugins(userHome)[id] === true ? false : null);
+      res.json(describeCollections(workspacePath).find((entry) => entry.id === id));
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.put('/plugins/:id/global', (req, res) => {
+    try {
+      const id = String(req.params.id);
+      if (typeof req.body?.enabled !== 'boolean') throw new Error('Activation booléenne requise.');
+      if (!installed()[id]) throw new Error('Plugin absent de Claude Code.');
+      setNativeClaudePlugin(userHome, id, req.body.enabled);
+      res.json({ ok: true, global: req.body.enabled });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/plugin/marketplace/register', (req, res) => {
     try { res.json(registerOfficialMarketplace(run, scope(req.body?.scope))); }
@@ -252,10 +256,10 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
       if (installed()[id]) throw new Error('Déjà installé. Son activation se règle par dossier.');
       const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
       if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Élément absent du catalogue.');
-      disableNativeClaudePlugin(userHome, id);
+      setNativeClaudePlugin(userHome, id, false);
       let result;
       try { result = run('claude', ['plugin', 'install', id, '--scope', 'user']); }
-      finally { disableNativeClaudePlugin(userHome, id); }
+      finally { setNativeClaudePlugin(userHome, id, false); }
       if (!result.ok) throw new Error(result.output || 'Installation impossible.');
       importInstalledCollections();
       res.json({ ok: true, enabled: false });

package/server/piecemaker/library/migrate.ts

@@ -19,38 +19,3 @@ export function importLibraryDirectory(store: ReturnType<typeof createLibrarySto
   }
   return imported;
 }
-
-export function migratePersonalLibrary(store: ReturnType<typeof createLibraryStore>, userHome: string, applicationRoot: string, withdraw = false) {
-  const imported = [];
-  for (const folder of ['assistant-workflows', 'tabular-review-workflows']) {
-    imported.push(...importLibraryDirectory(store, path.join(applicationRoot, 'server/piecemaker/vendor/mike-defaults-fr', folder), 'skill'));
-  }
-  for (const [directory, kind] of [
-    [path.join(userHome, '.claude', 'skills'), 'skill'],
-    [path.join(userHome, '.codex', 'skills'), 'skill'],
-    [path.join(userHome, '.agents', 'skills'), 'skill'],
-    [path.join(userHome, '.cursor', 'skills'), 'skill'],
-    [path.join(userHome, '.config', 'opencode', 'skills'), 'skill'],
-    [path.join(userHome, '.grok', 'skills'), 'skill'],
-    [path.join(userHome, '.claude', 'agents'), 'agent'],
-    [path.join(userHome, '.cursor', 'agents'), 'agent'],
-    [path.join(userHome, '.grok', 'agents'), 'agent'],
-    [path.join(userHome, '.config', 'opencode', 'agents'), 'agent'],
-    [path.join(userHome, '.config', 'opencode', 'agent'), 'agent'],
-    [path.join(userHome, '.piecemaker', 'library', 'skills'), 'skill'],
-    [path.join(userHome, '.piecemaker', 'library', 'agents'), 'agent'],
-  ] as const) imported.push(...importLibraryDirectory(store, directory, kind));
-  if (withdraw) {
-    const candidates = imported.filter((entry) => ['.claude', '.codex', '.agents', '.cursor', '.grok', path.join('.config', 'opencode')].some((provider) => entry.source.startsWith(path.join(userHome, provider) + path.sep)));
-    const backup = path.join(store.directory, `migration-${Date.now()}`);
-    fs.mkdirSync(backup, { recursive: true, mode: 0o700 });
-    fs.writeFileSync(path.join(backup, 'manifest.json'), JSON.stringify(candidates, null, 2), { mode: 0o600 });
-    for (const entry of candidates.sort((a, b) => Number(b.linked) - Number(a.linked))) {
-      const destination = path.join(backup, path.relative(userHome, entry.source));
-      fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
-      fs.renameSync(entry.source, destination);
-    }
-    fs.writeFileSync(path.join(store.directory, 'centralized.json'), JSON.stringify({ migratedAt: new Date().toISOString(), count: candidates.length }), { mode: 0o600 });
-  }
-  return imported;
-}

package/server/piecemaker/library/routes.ts

@@ -1,12 +1,19 @@
+import os from 'node:os';
+
 import express from 'express';
 
 import type { createLibraryStore } from './store.js';
+import { globalProviderIndex } from './global-state.js';
 import { listLibraryProviderSkills, scanAndPersistLibraryProviderSkills } from './provider-skills.js';
 
-export function createLibraryRouter(store: ReturnType<typeof createLibraryStore>) {
+export function createLibraryRouter(store: ReturnType<typeof createLibraryStore>, userHome = os.homedir()) {
   const router = express.Router();
   router.get('/catalog', (req, res) => {
-    try { res.json({ entries: store.list(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) }); }
+    try {
+      const globalProviders = globalProviderIndex(userHome);
+      const entries = store.list(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined);
+      res.json({ entries: entries.map(({ sources, ...entry }) => ({ ...entry, globalProviders: globalProviders(sources) })) });
+    }
     catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/catalog', (req, res) => {

package/server/piecemaker/library/store.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
 
@@ -7,7 +8,16 @@ import Database from 'better-sqlite3';
 import { parseFrontMatter } from '@/shared/frontmatter.js';
 
 import { parseConnectorConfig, prepareConnectorInstallation, type LibraryConnectorConfig } from './connector-installation.js';
-import { componentFolderName, prepareWorkspaceInstallation } from './workspace-installation.js';
+import {
+  componentFileHashes,
+  componentFolderName,
+  prepareWorkspaceInstallation,
+  readLibraryManifest,
+  removeLegacyLinks,
+  writeLibraryManifest,
+  type LibraryComponent,
+  type LibraryManifestEntry,
+} from './workspace-installation.js';
 
 type StoredLibraryEntry = {
   id: string;
@@ -69,6 +79,25 @@ function installationFolder(content: string, fallback = '') {
   return componentFolderName(String(data.name || data.metadata?.title || fallback));
 }
 
+function installableComponent(entry: LibraryEntry): LibraryComponent {
+  const slug = installationFolder(entry.content, entry.name);
+  if (entry.kind === 'skill') {
+    const files = Object.fromEntries(Object.entries(entry.assets).map(([name, bytes]) => [name, Buffer.from(bytes, 'base64')]));
+    return { kind: 'skill', slug, files: { ...files, 'SKILL.md': Buffer.from(entry.content, 'utf8') } };
+  }
+  const { data, content } = parseFrontMatter(entry.content);
+  const toml = (fields: Record<string, string>) => `${Object.entries(fields).map(([key, value]) => `${key} = ${JSON.stringify(value)}`).join('\n')}\n`;
+  const name = String(data.name || entry.name);
+  const description = entry.description || entry.name;
+  return {
+    kind: 'agent',
+    slug,
+    markdown: entry.content,
+    codex: toml({ name, description, developer_instructions: content }),
+    vibe: toml({ display_name: name, description, agent_type: 'subagent', instructions: content }),
+  };
+}
+
 function collectionMainPath(entry: LibraryEntry, rootPath: string) {
   return entry.kind === 'skill' && !rootPath.toLowerCase().endsWith('.md') ? `${rootPath}/SKILL.md` : rootPath;
 }
@@ -109,6 +138,7 @@ export function createLibraryStore(home: string) {
   `);
   const originColumns = db.prepare('PRAGMA table_info(origins)').all() as Array<{ name: string }>;
   if (!originColumns.some((column) => column.name === 'source_hash')) db.exec('ALTER TABLE origins ADD COLUMN source_hash TEXT');
+  let defaultEntries: string[] = [];
 
   function workspace(value: unknown) {
     if (typeof value !== 'string' || !path.isAbsolute(value)) throw new Error('Dossier absolu requis.');
@@ -123,14 +153,54 @@ export function createLibraryStore(home: string) {
     return { ...entry, assets: JSON.parse(entry.assets) as Record<string, string> };
   }
 
+  function activeEntries(selected: string) {
+    return (db.prepare('SELECT entry_id AS entryId FROM activation WHERE workspace = ?').all(selected) as Array<{ entryId: string }>).map((row) => row.entryId);
+  }
+
+  function reconcile(selected: string) {
+    const known = (id: string) => Boolean(db.prepare('SELECT 1 FROM entries WHERE id = ?').get(id));
+    const manifest = readLibraryManifest(selected);
+    if (manifest) {
+      const expected = manifest.map((entry) => entry.id).filter(known);
+      const current = activeEntries(selected);
+      if (expected.length === current.length && expected.every((id) => current.includes(id))) return;
+      db.transaction(() => {
+        db.prepare('DELETE FROM activation WHERE workspace = ?').run(selected);
+        for (const id of expected) db.prepare('INSERT OR IGNORE INTO activation VALUES (?, ?)').run(selected, id);
+      })();
+      return;
+    }
+    const inherited = activeEntries(selected);
+    const defaults = selected === fs.realpathSync(os.homedir()) ? [] : defaultEntries.filter((id) => known(id) && !inherited.includes(id));
+    if (!inherited.length && !defaults.length) return;
+    const legacy = path.join(directory, 'active');
+    try {
+      removeLegacyLinks(selected, legacy);
+      writeLibraryManifest(selected, inherited.map((id) => {
+        const entry = document(id);
+        const slug = entry.kind === 'connector' ? entry.name : installationFolder(entry.content, entry.name);
+        const files = entry.kind === 'connector' ? {} : componentFileHashes(selected, installableComponent(entry), false);
+        return { id, kind: entry.kind, name: entry.name, slug, files, skipClaude: false };
+      }));
+    } catch { return; }
+    db.prepare('DELETE FROM activation WHERE workspace = ?').run(selected);
+    for (const id of [...inherited, ...defaults]) {
+      try { setEnabled(selected, id, true); }
+      catch { writeLibraryManifest(selected, (readLibraryManifest(selected) ?? []).filter((entry) => entry.id !== id)); }
+    }
+    fs.rmSync(path.join(legacy, createHash('sha256').update(selected).digest('hex')), { recursive: true, force: true });
+  }
+
   function list(workspacePath?: string) {
     const selected = workspacePath ? workspace(workspacePath) : '';
+    if (selected) reconcile(selected);
     return db.prepare(`SELECT e.id, e.kind, e.name, e.description,
       EXISTS(SELECT 1 FROM activation a WHERE a.entry_id = e.id AND a.workspace = ?) AS enabled,
-      (SELECT ce.collection_id FROM collection_entries ce WHERE ce.entry_id = e.id LIMIT 1) AS collectionId
+      (SELECT ce.collection_id FROM collection_entries ce WHERE ce.entry_id = e.id LIMIT 1) AS collectionId,
+      (SELECT json_group_array(o.source) FROM origins o WHERE o.entry_id = e.id) AS sources
       FROM entries e ORDER BY e.name COLLATE NOCASE`).all(selected).map((row) => {
-        const entry = row as Omit<StoredLibraryEntry, 'content' | 'assets'> & { enabled: number; collectionId: string | null };
-        return { ...entry, enabled: Boolean(entry.enabled), collectionId: entry.collectionId || null };
+        const entry = row as Omit<StoredLibraryEntry, 'content' | 'assets'> & { enabled: number; collectionId: string | null; sources: string };
+        return { ...entry, enabled: Boolean(entry.enabled), collectionId: entry.collectionId || null, sources: JSON.parse(entry.sources) as string[] };
       });
   }
 
@@ -225,9 +295,6 @@ export function createLibraryStore(home: string) {
       const entry = document(id);
       if (entry.content !== previousContent) throw new Error('Le document a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
       const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
-      if (entry.kind !== 'connector' && installationFolder(content) !== installationFolder(entry.content)) {
-        for (const { workspace: selected } of active) setEnabled(selected, id, false);
-      }
       if (entry.kind === 'connector') {
         const config = parseConnectorConfig(content);
         const description = config.url || config.command || entry.name;
@@ -305,6 +372,7 @@ export function createLibraryStore(home: string) {
 
   function listCollections(workspacePath?: string) {
     const selected = workspacePath ? workspace(workspacePath) : '';
+    if (selected) reconcile(selected);
     return db.prepare(`SELECT c.id, c.name, c.description, c.source,
       COUNT(ce.entry_id) AS entryCount,
       SUM(CASE WHEN a.entry_id IS NOT NULL THEN 1 ELSE 0 END) AS enabledCount
@@ -442,7 +510,7 @@ export function createLibraryStore(home: string) {
     throw new Error('Fichier introuvable.');
   }
 
-  function setCollectionEnabled(workspacePath: unknown, id: string, enabled: unknown) {
+  function setCollectionEnabled(workspacePath: unknown, id: string, enabled: unknown, options: { skipClaude?: boolean } = {}) {
     if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
     const selected = workspace(workspacePath);
     const mappings = collectionEntries(id);
@@ -452,7 +520,7 @@ export function createLibraryStore(home: string) {
     try {
       for (const mapping of mappings) {
         if (active.has(mapping.entryId) === enabled) continue;
-        setEnabled(selected, mapping.entryId, enabled);
+        setEnabled(selected, mapping.entryId, enabled, options);
         changed.push(mapping.entryId);
       }
     } catch (error) {
@@ -462,59 +530,26 @@ export function createLibraryStore(home: string) {
     return listCollections(selected).find((collection) => collection.id === id);
   }
 
-  function setEnabled(workspacePath: unknown, id: string, enabled: unknown) {
+  function setEnabled(workspacePath: unknown, id: string, enabled: unknown, options: { skipClaude?: boolean } = {}) {
     if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
     const selected = workspace(workspacePath);
     const entry = document(id);
+    const manifest = readLibraryManifest(selected) ?? [];
+    const previous = manifest.find((item) => item.id === id);
+    const skipClaude = options.skipClaude ?? previous?.skipClaude ?? false;
+    const installed: LibraryManifestEntry = { id, kind: entry.kind, name: entry.name, slug: entry.name, files: {}, skipClaude };
     if (entry.kind === 'connector') {
-      prepareConnectorInstallation(selected, entry.name, parseConnectorConfig(entry.content), enabled)();
-      if (enabled) db.prepare('INSERT OR IGNORE INTO activation VALUES (?, ?)').run(selected, id);
-      else db.prepare('DELETE FROM activation WHERE workspace = ? AND entry_id = ?').run(selected, id);
-      return { ok: true, enabled };
-    }
-    const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), id);
-    const install = prepareWorkspaceInstallation(selected, id, installationFolder(entry.content, entry.name), packageRoot, entry.kind, enabled);
-    if (enabled) {
-      fs.mkdirSync(path.dirname(packageRoot), { recursive: true, mode: 0o700 });
-      if (!fs.realpathSync(path.dirname(packageRoot)).startsWith(fs.realpathSync(directory) + path.sep)) throw new Error('Répertoire d’activation non autorisé.');
-      const staging = fs.mkdtempSync(path.join(directory, '.activation-'));
-      const backup = `${staging}.previous`;
-      try {
-        for (const [relative, bytes] of Object.entries(entry.assets)) {
-          const target = path.resolve(staging, relative);
-          if (!target.startsWith(staging + path.sep)) throw new Error('Chemin associé invalide.');
-          fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
-          fs.writeFileSync(target, Buffer.from(bytes, 'base64'), { mode: 0o600 });
-        }
-        if (entry.kind === 'skill') fs.writeFileSync(path.join(staging, 'SKILL.md'), entry.content, { mode: 0o600 });
-        else {
-          fs.writeFileSync(path.join(staging, 'agent.md'), entry.content, { mode: 0o600 });
-          const { data, content } = parseFrontMatter(entry.content);
-          const toml = Object.entries({ name: String(data.name || entry.name), description: entry.description || entry.name, developer_instructions: content })
-            .map(([key, value]) => `${key} = ${JSON.stringify(value)}`).join('\n');
-          fs.writeFileSync(path.join(staging, 'agent.toml'), `${toml}\n`, { mode: 0o600 });
-        }
-        if (fs.existsSync(packageRoot)) fs.renameSync(packageRoot, backup);
-        try {
-          fs.renameSync(staging, packageRoot);
-          install();
-        }
-        catch (error) {
-          fs.rmSync(packageRoot, { recursive: true, force: true });
-          if (fs.existsSync(backup)) fs.renameSync(backup, packageRoot);
-          throw error;
-        }
-      } finally {
-        fs.rmSync(staging, { recursive: true, force: true });
-        fs.rmSync(backup, { recursive: true, force: true });
-      }
-    } else if (fs.existsSync(path.dirname(packageRoot))) {
-      if (!fs.realpathSync(path.dirname(packageRoot)).startsWith(fs.realpathSync(directory) + path.sep)) throw new Error('Répertoire d’activation non autorisé.');
-      install();
-      fs.rmSync(packageRoot, { recursive: true, force: true });
+      prepareConnectorInstallation(selected, entry.name, parseConnectorConfig(entry.content), enabled, skipClaude)();
     } else {
-      install();
+      const component = installableComponent(entry);
+      const installation = prepareWorkspaceInstallation(selected, previous, enabled ? { component, skipClaude } : null);
+      installation.commit();
+      installed.slug = component.slug;
+      installed.files = installation.files;
     }
+    const others = manifest.filter((item) => item.id !== id);
+    if (enabled) writeLibraryManifest(selected, [...others, installed]);
+    else if (previous) writeLibraryManifest(selected, others);
     if (enabled) db.prepare('INSERT OR IGNORE INTO activation VALUES (?, ?)').run(selected, id);
     else db.prepare('DELETE FROM activation WHERE workspace = ? AND entry_id = ?').run(selected, id);
     return { ok: true, enabled };
@@ -522,13 +557,14 @@ export function createLibraryStore(home: string) {
 
   function instructions(workspacePath: string) {
     const selected = workspace(workspacePath);
+    reconcile(selected);
     const entries = db.prepare(`SELECT e.* FROM entries e JOIN activation a ON a.entry_id = e.id
       WHERE a.workspace = ? AND e.kind IN ('skill', 'agent') ORDER BY e.name`).all(selected) as StoredLibraryEntry[];
     return entries.map((entry) => {
       const assets = JSON.parse(entry.assets) as Record<string, string>;
       const references = Object.entries(assets).filter(([name]) => name === 'table-columns.yaml')
         .map(([name, bytes]) => `### ${name}\n${Buffer.from(bytes, 'base64').toString('utf8')}`);
-      const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), entry.id);
+      const packageRoot = path.join(selected, '.agents', 'skills', installationFolder(entry.content, entry.name));
       return `## ${entry.kind === 'agent' ? 'Instructions de rôle' : 'Skill'} : ${entry.name}\n${entry.content}\n${references.join('\n\n')}\nFichiers associés disponibles dans : ${packageRoot}\n${Object.keys(assets).join('\n')}`;
     }).join('\n\n');
   }
@@ -552,6 +588,7 @@ export function createLibraryStore(home: string) {
     collectionFile,
     updateCollectionFile,
     setCollectionEnabled,
+    setDefaultEntries: (ids: string[]) => { defaultEntries = ids; },
     close: () => db.close(),
   };
 }