@deerdesign/deertools 1.2.13 → 1.2.17

package/README.md

@@ -185,11 +185,12 @@ deertools profile list
 deertools profile use staging
 
 # 12. AI Agent Skills (DeerSkills Hub):
-deertools skill list                         # Wyświetl skille (oficjalne globalne i Twoje)
-deertools skill search "kosztorys"           # Wyszukaj skille po nazwie, tagu lub opisie
-deertools skill install deer-kosztorys       # Zainstaluj skill w ~/.gemini/antigravity/skills lub .agents
+deertools skill list                         # Wyświetl listę skilli ze statusem zainstalowania w projekcie
+deertools skill sync                         # Jedna komenda: instaluje brakujące i aktualizuje obecne skille zespołu
+deertools skill install --all                # To samo co skill sync (pełna synchronizacja zespołu)
+deertools skill install deer-kosztorys       # Zainstaluj konkretny skill w ~/.gemini/antigravity/skills lub .agents
 deertools skill install deer-kosztorys --version 1.0.0
-deertools skill install all                  # Zainstaluj wszystkie oficjalne skille Deer Design
+deertools skill search "kosztorys"           # Wyszukaj skille po nazwie, tagu lub opisie
 deertools skill push ./my-skill              # Opublikuj nową wersję z automatycznym skanerem sekretów
 deertools skill push ./my-skill --bump minor # Automatyczne podbicie wersji SemVer
 deertools skill update deer-kosztorys        # Zaktualizuj zainstalowany skill do najnowszej wersji

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deerdesign/deertools",
-  "version": "1.2.13",
+  "version": "1.2.17",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/agent-detector.js

@@ -3,6 +3,27 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const { execSync } = require('child_process');
+const readline = require('readline');
+const { readConfig, writeConfig } = require('./profiles');
+
+function isBinaryInPath(cmd) {
+  try {
+    const check = process.platform === 'win32' ? `where ${cmd} 2>nul` : `which ${cmd} 2>/dev/null`;
+    execSync(check, { stdio: 'ignore', timeout: 800 });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function isAppInstalled(appName) {
+  if (process.platform === 'darwin') {
+    return fs.existsSync(`/Applications/${appName}.app`) || fs.existsSync(path.join(os.homedir(), `Applications/${appName}.app`));
+  }
+  return false;
+}
+
 /**
  * Rejestr obsługiwanych platform agentów AI.
  * Obsługuje: Google Antigravity / Gemini, Claude Code, OpenAI Codex, Hermes AI,
@@ -19,35 +40,35 @@ const KNOWN_AGENTS = [
   {
     id: 'claude',
     name: 'Claude Code',
-    detect: (home) => fs.existsSync(path.join(home, '.claude')),
+    detect: (home) => fs.existsSync(path.join(home, '.claude')) || isBinaryInPath('claude'),
     getTarget: (home) => path.join(home, '.claude', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'codex',
     name: 'OpenAI Codex',
-    detect: (home) => fs.existsSync(path.join(home, '.codex')),
+    detect: (home) => fs.existsSync(path.join(home, '.codex')) || isBinaryInPath('codex'),
     getTarget: (home) => path.join(home, '.codex', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'hermes',
     name: 'Hermes AI',
-    detect: (home) => fs.existsSync(path.join(home, '.hermes')) || fs.existsSync(path.join(home, '.config', 'hermes')) || Boolean(process.env.HERMES_HOME),
+    detect: (home) => fs.existsSync(path.join(home, '.hermes')) || fs.existsSync(path.join(home, '.config', 'hermes')) || Boolean(process.env.HERMES_HOME) || isBinaryInPath('hermes'),
     getTarget: (home) => process.env.HERMES_SKILLS_DIR || path.join(home, '.hermes', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'cursor',
     name: 'Cursor IDE',
-    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) || fs.existsSync(path.join(home, '.cursor')),
+    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) || fs.existsSync(path.join(home, '.cursor')) || isAppInstalled('Cursor'),
     getTarget: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) ? path.join(cwd, '.cursor', 'rules') : path.join(home, '.cursor', 'rules'),
     format: 'cursor_mdc',
   },
   {
     id: 'windsurf',
     name: 'Windsurf / Codeium',
-    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.windsurfrules')) || fs.existsSync(path.join(cwd, '.windsurf')) || fs.existsSync(path.join(home, '.codeium')),
+    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.windsurfrules')) || fs.existsSync(path.join(cwd, '.windsurf')) || fs.existsSync(path.join(home, '.codeium')) || isAppInstalled('Windsurf'),
     getTarget: (home, cwd) => path.join(cwd, '.windsurf', 'rules'),
     format: 'skill_md',
   },
@@ -61,7 +82,40 @@ const KNOWN_AGENTS = [
 ];
 
 /**
- * Wykrywa zainstalowane środowiska agentów lub filtruje według flagi --agent.
+ * Zwraca listę skonfigurowanych agentów użytkownika na tym PC.
+ */
+function getSelectedAgents() {
+  if (process.env.DEERTOOLS_AGENTS) {
+    const fromEnv = process.env.DEERTOOLS_AGENTS.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    if (fromEnv.length > 0) return fromEnv;
+  }
+  const cfg = readConfig();
+  if (cfg.selectedAgents && Array.isArray(cfg.selectedAgents) && cfg.selectedAgents.length > 0) {
+    return cfg.selectedAgents.map((s) => String(s).trim().toLowerCase());
+  }
+  return null;
+}
+
+/**
+ * Zapisuje listę wybranych agentów użytkownika w konfiguracji ~/.deertools/config.json.
+ */
+function setSelectedAgents(agentIds) {
+  const cfg = readConfig();
+  cfg.selectedAgents = agentIds.map((s) => String(s).trim().toLowerCase());
+  writeConfig(cfg);
+}
+
+/**
+ * Czyści zapisaną listę agentów (przywraca auto-detekcję wszystkich obecnych na PC).
+ */
+function clearSelectedAgents() {
+  const cfg = readConfig();
+  delete cfg.selectedAgents;
+  writeConfig(cfg);
+}
+
+/**
+ * Wykrywa zainstalowane środowiska agentów lub filtruje według flagi --agent / konfiguracji.
  */
 function detectAgents(options = {}) {
   const home = os.homedir();
@@ -77,7 +131,7 @@ function detectAgents(options = {}) {
     }];
   }
 
-  // Wymuszenie instalacji do WSZYSTKICH obsługiwanych platform (--all-agents)
+  // Wymuszenie instalacji do WSZYSTKICH znanych platform (--all-agents)
   if (options['all-agents']) {
     return KNOWN_AGENTS.map((spec) => ({
       id: spec.id,
@@ -87,21 +141,35 @@ function detectAgents(options = {}) {
     }));
   }
 
-  // Wskazanie konkretnego agenta (--agent claude / --agent codex / --agent hermes / etc.)
+  // Wskazanie konkretnego agenta lub listy po przecinku (--agent claude,antigravity)
   if (options.agent && options.agent !== 'all' && options.agent !== 'auto') {
-    const requested = options.agent.toLowerCase().trim();
-    const spec = KNOWN_AGENTS.find((a) => a.id === requested);
-    if (spec) {
-      return [{
+    const requested = options.agent.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const matched = KNOWN_AGENTS.filter((spec) => requested.includes(spec.id));
+    if (matched.length > 0) {
+      return matched.map((spec) => ({
+        id: spec.id,
+        name: spec.name,
+        targetDir: spec.getTarget(home, cwd),
+        format: spec.format,
+      }));
+    }
+  }
+
+  // Jeśli użytkownik ma zapisaną konfigurację wybranych agentów na tym PC:
+  const configured = getSelectedAgents();
+  if (configured && configured.length > 0 && !options['ignore-selected']) {
+    const matched = KNOWN_AGENTS.filter((spec) => configured.includes(spec.id));
+    if (matched.length > 0) {
+      return matched.map((spec) => ({
         id: spec.id,
         name: spec.name,
         targetDir: spec.getTarget(home, cwd),
         format: spec.format,
-      }];
+      }));
     }
   }
 
-  // Automatyczne wykrywanie obecnych agentów
+  // Automatyczne wykrywanie obecnych agentów na PC
   const matched = [];
   for (const spec of KNOWN_AGENTS) {
     try {
@@ -157,4 +225,48 @@ function installSkillContent(agent, skillName, rawMarkdown) {
   return filePath;
 }
 
-module.exports = { KNOWN_AGENTS, detectAgents, installSkillContent };
+/**
+ * Interaktywny prompt pytający użytkownika o wybór platform agentów w terminalu.
+ */
+async function promptSelectAgents(availableAgents) {
+  if (!process.stdin.isTTY) return availableAgents;
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    process.stdout.write(`\nWykryto platformy agentów AI na tym komputerze:\n`);
+    availableAgents.forEach((a, i) => {
+      process.stdout.write(`  [${i + 1}] ${a.name} (${a.id})\n`);
+    });
+    process.stdout.write(`\nWybierz platformy (np. 1, 3 lub 'all') [domyślnie: wszystkie wykryte]: `);
+
+    rl.question('', (answer) => {
+      rl.close();
+      const trimmed = (answer || '').trim().toLowerCase();
+      if (!trimmed || trimmed === 'all') {
+        resolve(availableAgents);
+        return;
+      }
+      const parts = trimmed.split(/[\s,]+/).map((p) => parseInt(p, 10)).filter((n) => !isNaN(n) && n >= 1 && n <= availableAgents.length);
+      if (parts.length === 0) {
+        resolve(availableAgents);
+        return;
+      }
+      const selected = parts.map((n) => availableAgents[n - 1]);
+      resolve(selected);
+    });
+  });
+}
+
+module.exports = {
+  KNOWN_AGENTS,
+  detectAgents,
+  installSkillContent,
+  getSelectedAgents,
+  setSelectedAgents,
+  clearSelectedAgents,
+  promptSelectAgents,
+  isBinaryInPath,
+};

package/src/cli.js

@@ -32,6 +32,8 @@ async function main(argv) {
   const table = {
     login: c.cmdLogin, logout: c.cmdLogout, whoami: c.cmdWhoami, docs: c.cmdDocs,
     endpoints: c.cmdEndpoints, api: c.cmdApi, estimate: c.cmdEstimate, skill: c.cmdSkill,
+    sync: (pos, flags) => c.cmdSkill(['sync', ...pos], flags),
+    agent: c.cmdAgent, agents: c.cmdAgent,
     mcp: c.cmdMcp, doctor: c.cmdDoctor, audit: c.cmdAudit, profile: c.cmdProfile,
     completion: c.cmdCompletion, catalog: c.cmdCatalog, deliveries: c.cmdDeliveries,
     supplier: c.cmdSupplier, rendermind: c.cmdRendermind, baselinker: c.cmdBaseLinker,

package/src/commands.js

@@ -379,6 +379,9 @@ async function cmdSkill(pos, flags) {
   if (sub === 'bundle') {
     return cmdSkillBundle(pos[1], flags);
   }
+  if (sub === 'sync') {
+    return skillCommands.cmdSkillSync(flags, out, err);
+  }
   if (sub === 'list') {
     return skillCommands.cmdSkillList(flags, out, err);
   }
@@ -404,9 +407,10 @@ async function cmdSkill(pos, flags) {
     return skillCommands.cmdSkillPromote(pos[1], flags, out, err);
   }
   if (sub === 'install') {
-    return skillCommands.cmdSkillInstall(pos[1], flags, out, err);
+    const target = pos[1] || (flags.all ? '--all' : null);
+    return skillCommands.cmdSkillInstall(target, flags, out, err);
   }
-  fail('Użycie:\n  deertools skill login [token]\n  deertools skill bundle <architekci|kosztorysy|logistyka|sprzedaz|it>\n  deertools skill list [--tag <tag>]\n  deertools skill search <fraza>\n  deertools skill install <slug[@version]>\n  deertools skill check\n  deertools skill update [slug]\n  deertools skill versions <slug>\n  deertools skill diff <slug> [wersjaA] [wersjaB]\n  deertools skill push [katalog] [--bump patch|minor|major] [--changelog "opis"]\n  deertools skill promote <slug>', 2);
+  fail('Użycie:\n  deertools skill login [token]\n  deertools skill sync [--force]\n  deertools skill bundle <architekci|kosztorysy|logistyka|sprzedaz|it>\n  deertools skill list [--tag <tag>]\n  deertools skill search <fraza>\n  deertools skill install [--all|<slug[@version]>]\n  deertools skill check\n  deertools skill update [slug]\n  deertools skill versions <slug>\n  deertools skill diff <slug> [wersjaA] [wersjaB]\n  deertools skill push [katalog] [--bump patch|minor|major] [--changelog "opis"]\n  deertools skill promote <slug>', 2);
 }
 
 
@@ -508,6 +512,91 @@ async function cmdMcp(pos, flags) {
   fail('Użycie: deertools mcp [config|install|serve] [produkt|all] [--json]', 2);
 }
 
+async function cmdAgent(pos, flags) {
+  const {
+    KNOWN_AGENTS,
+    detectAgents,
+    getSelectedAgents,
+    setSelectedAgents,
+    clearSelectedAgents,
+    promptSelectAgents,
+  } = require('./agent-detector');
+  const action = pos[0] || 'list';
+
+  if (action === 'list') {
+    const selected = getSelectedAgents();
+    const detected = detectAgents({ 'ignore-selected': true });
+    const detectedIds = new Set(detected.map((a) => a.id));
+
+    out(`\n=== Platformy Agentów AI (DeerTools) ===\n`);
+    for (const a of KNOWN_AGENTS) {
+      const isDetected = detectedIds.has(a.id);
+      const isActive = selected ? selected.includes(a.id) : isDetected;
+
+      let statusBadge = '\x1b[90m[○ Niewykryty na PC]\x1b[0m';
+      if (isDetected) statusBadge = '\x1b[32m[✓ Wykryty na PC]\x1b[0m';
+
+      let activeBadge = '';
+      if (isActive) {
+        activeBadge = ' \x1b[36m(AKTYWNY DLA SKILLI)\x1b[0m';
+      }
+
+      out(`  • ${a.id.padEnd(16)} ${(a.name).padEnd(32)} ${statusBadge}${activeBadge}`);
+      out(`    Ścieżka: ${a.getTarget(os.homedir(), process.cwd())}`);
+      out('');
+    }
+
+    out('─'.repeat(72));
+    if (selected && selected.length > 0) {
+      out(`📌 Wybrane platformy na tym PC: \x1b[36m${selected.join(', ')}\x1b[0m (zapisane w ~/.deertools/config.json)`);
+      out(`   Skille instalują się tylko u wybranych agentów.`);
+      out(`   Aby przywrócić auto-wykrywanie wszystkich: \x1b[33mdeertools agent reset\x1b[0m`);
+    } else {
+      out(`⚡ Tryb: \x1b[32mAutomatyczne wykrywanie wszystkich platform obecnych na komputerze\x1b[0m`);
+      out(`   Aby ograniczyć synchronizację do wybranych agentów:`);
+      out(`   \x1b[36mdeertools agent select antigravity,cursor\x1b[0m`);
+    }
+    out('─'.repeat(72) + '\n');
+    return;
+  }
+
+  if (action === 'select' || action === 'set') {
+    let targets = pos.slice(1).join(',').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    if (targets.length === 0) {
+      const detected = detectAgents({ 'ignore-selected': true });
+      const picked = await promptSelectAgents(detected);
+      targets = picked.map((a) => a.id);
+    }
+
+    const validIds = KNOWN_AGENTS.map((a) => a.id);
+    const validTargets = targets.filter((id) => validIds.includes(id));
+
+    if (validTargets.length === 0) {
+      fail(`Błąd: Podaj poprawne identyfikatory agentów: ${validIds.join(', ')}`, 2);
+    }
+
+    setSelectedAgents(validTargets);
+    out(`✓ Zapisano aktywnych agentów na tym komputerze: \x1b[36m${validTargets.join(', ')}\x1b[0m`);
+    out(`Od teraz deertools skill sync i skill install instalują skille tylko dla tych platform.`);
+    out(`Aby przywrócić instalację u wszystkich wykrytych: deertools agent reset\n`);
+    return;
+  }
+
+  if (action === 'reset' || action === 'clear') {
+    clearSelectedAgents();
+    out(`✓ Zresetowano konfigurację agentów. Przywrócono automatyczne wykrywanie obecnych na PC.\n`);
+    return;
+  }
+
+  if (action === 'current') {
+    const active = detectAgents({});
+    out(active.map((a) => a.id).join(','));
+    return;
+  }
+
+  fail(`Nieznana podkomenda „agent ${action}”. Użyj: deertools agent [list|select <agenty>|reset|current]`, 2);
+}
+
 const { cmdDoctor } = require('./doctor');
 const { cmdAudit } = require('./audit');
 const { cmdProfile } = require('./profiles');
@@ -544,9 +633,11 @@ BaseLinker MCP Proxy & Hub:
   deertools baselinker catalog <search|get>             Operacje katalogowe z poziomu terminala.
 
 Integracje MCP i Agenci AI (DeerSkills Hub):
-  deertools skill list [--tag <tag>]                    Przegląda skille globalne i użytkownika w DeerSkills Hub.
+  deertools agent [list|select <agenty>|reset]          Wykrywanie i konfiguracja platform agentów AI na PC.
+  deertools skill list [--tag <tag>]                    Przegląda skille w Hubie wraz ze statusem zainstalowania.
+  deertools skill sync [--agent <id>|-i|--force]        Instaluje brakujące i aktualizuje obecne skille zespołu.
+  deertools skill install [--all|<slug[@wersja]>]       Instaluje wszystkie skille (--all) lub wskazany skill.
   deertools skill search <fraza>                        Wyszukuje umiejętności po słowach kluczowych.
-  deertools skill install <slug[@wersja]>               Instaluje skill w ~/.gemini/antigravity/skills lub .agents.
   deertools skill versions <slug>                       Historia wydań z changelogami z commitów i datami.
   deertools skill diff <slug> [wersjaA] [wersjaB]       Porównanie zmian w plikach paczki i treści SKILL.md.
   deertools skill push [katalog] [--bump patch|minor]   Publikuje nową wersję z automatycznym skanerem sekretów.
@@ -566,13 +657,13 @@ Narzędzia systemowe:
   deertools audit [--limit 25] [--clear] [--json]       Historia operacji i wywołań API.
   deertools completion [install|zsh|bash]               Autouzupełnianie w powłoce po wciśnięciu Tab.
 
-Zmienne środowiskowe: DEERTOOLS_<PRODUKT>_KEY, BASELINKER_TOKEN, DEERTOOLS_HOME, DEERTOOLS_PROFILE.
+Zmienne środowiskowe: DEERTOOLS_<PRODUKT>_KEY, BASELINKER_TOKEN, DEERTOOLS_HOME, DEERTOOLS_PROFILE, DEERTOOLS_AGENTS.
 `;
 
 module.exports = {
   cmdLogin, cmdLogout, cmdWhoami, cmdDocs, cmdEndpoints, cmdApi, cmdEstimate, cmdSkill, cmdMcp,
   cmdDoctor, cmdAudit, cmdProfile, cmdCompletion, cmdCatalog, cmdDeliveries, cmdSupplier, cmdRendermind,
-  cmdBaseLinker,
+  cmdBaseLinker, cmdAgent,
   HELP, parseQuery,
 };
 

package/src/skill-commands.js

@@ -7,6 +7,8 @@ const { parseFrontmatterName } = require('./openapi');
 const { resolveProducts } = require('./registry');
 const { fetchText } = require('./http');
 
+const { compareSemver } = require('./updater');
+
 const LOCK_FILE = '.deertools-lock.json';
 
 function getLockFilePath(cwd = process.cwd()) {
@@ -38,14 +40,149 @@ function writeLock(data, cwd = process.cwd()) {
   } catch (_) {}
 }
 
+/**
+ * Szuka pliku skilla na dysku dla danego agenta.
+ */
+function findSkillFileForAgent(agent, skill) {
+  const slug = skill.slug;
+  const fullSlug = skill.full_slug || slug;
+  const shortSlug = slug.replace(/^@[^/]+\//, '');
+
+  if (agent.format === 'cursor_mdc') {
+    const candidates = [
+      path.join(agent.targetDir, `${slug}.mdc`),
+      path.join(agent.targetDir, `${shortSlug}.mdc`),
+      path.join(agent.targetDir, `${fullSlug.replace(/\//g, '-')}.mdc`),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    return null;
+  }
+
+  const candidates = [
+    path.join(agent.targetDir, slug, 'SKILL.md'),
+    path.join(agent.targetDir, shortSlug, 'SKILL.md'),
+    path.join(agent.targetDir, fullSlug, 'SKILL.md'),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+/**
+ * Wyciąga wersję z pliku SKILL.md lub .mdc z fallbackiem na lockfile.
+ */
+function readSkillVersion(filePath, lock, skill) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const head = fs.readFileSync(filePath, 'utf8').slice(0, 2048);
+    const m = head.match(/[\r\n]version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/i)
+      || head.match(/^version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/im);
+    if (m && m[1]) return m[1];
+    const vMatch = head.match(/v([0-9]+\.[0-9]+(\.[0-9]+)?)/i);
+    if (vMatch && vMatch[1]) return vMatch[1];
+  } catch (_) {}
+
+  if (lock?.skills) {
+    const lockEntry = lock.skills[skill.slug] || lock.skills[skill.full_slug];
+    if (lockEntry && lockEntry.version) return lockEntry.version;
+  }
+  return '1.0.0';
+}
+
+/**
+ * Bada stan instalacji i wersję skilla u wszystkich zadanych agentów.
+ */
+function inspectSkillForAgents(agents, skill, lock) {
+  const agentStatuses = {};
+  let installedCount = 0;
+  let upToDateCount = 0;
+  let outdatedCount = 0;
+  let missingCount = 0;
+
+  for (const agent of agents) {
+    const filePath = findSkillFileForAgent(agent, skill);
+    if (!filePath) {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: false,
+        version: null,
+        status: 'missing',
+        filePath: null,
+        badge: `\x1b[90m[○ ${agent.id}: brak]\x1b[0m`,
+      };
+      missingCount += 1;
+      continue;
+    }
+
+    installedCount += 1;
+    const installedVer = readSkillVersion(filePath, lock, skill);
+    const cmp = compareSemver(installedVer, skill.latest_version);
+
+    if (cmp >= 0) {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: true,
+        version: installedVer,
+        status: 'up_to_date',
+        filePath,
+        badge: `\x1b[32m[✓ ${agent.id}: v${installedVer}]\x1b[0m`,
+      };
+      upToDateCount += 1;
+    } else {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: true,
+        version: installedVer,
+        status: 'outdated',
+        target_version: skill.latest_version,
+        filePath,
+        badge: `\x1b[33m[↑ ${agent.id}: v${installedVer} → v${skill.latest_version}]\x1b[0m`,
+      };
+      outdatedCount += 1;
+    }
+  }
+
+  let overallStatus = 'missing';
+  let overallBadge = '\x1b[90m[○ Niezainstalowany]\x1b[0m';
+
+  if (installedCount > 0) {
+    if (installedCount === agents.length && outdatedCount === 0) {
+      overallStatus = 'up_to_date';
+      overallBadge = `\x1b[32m[✓ Aktualny (${installedCount}/${agents.length})]\x1b[0m`;
+    } else if (outdatedCount > 0) {
+      overallStatus = 'outdated';
+      overallBadge = `\x1b[33m[↑ Wymaga aktualizacji (${outdatedCount})]\x1b[0m`;
+    } else {
+      overallStatus = 'partial';
+      overallBadge = `\x1b[36m[◐ Częściowy (${installedCount}/${agents.length})]\x1b[0m`;
+    }
+  }
+
+  return {
+    agents: agentStatuses,
+    installedCount,
+    upToDateCount,
+    outdatedCount,
+    missingCount,
+    overallStatus,
+    overallBadge,
+  };
+}
+
 async function cmdSkillList(flags, out, err) {
-  out('Pobieram listę skilli z DeerSkills Hub...');
+  if (!flags.json) out('Pobieram listę skilli z DeerSkills Hub...');
   const res = await skillsHub.listSkills({
     query: flags.query,
     tag: flags.tag,
     category: flags.category,
     scope: flags.scope,
-    limit: flags.limit || 50,
+    limit: flags.limit || 100,
   });
 
   if (!res.ok) {
@@ -54,66 +191,133 @@ async function cmdSkillList(flags, out, err) {
   }
 
   const items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
+  const agents = detectAgents({
+    dir: flags.dir,
+    agent: flags.agent,
+    'all-agents': flags['all-agents'],
+  });
+  const lock = readLock(flags.dir);
+
   if (flags.json) {
-    out(JSON.stringify(items, null, 2));
+    const enriched = items.map((s) => {
+      const insp = inspectSkillForAgents(agents, s, lock);
+      return {
+        ...s,
+        overall_status: insp.overallStatus,
+        agents: Object.fromEntries(
+          Object.entries(insp.agents).map(([id, data]) => [
+            id,
+            {
+              installed: data.installed,
+              version: data.version,
+              status: data.status,
+              target_version: data.target_version || null,
+              file_path: data.filePath,
+            },
+          ])
+        ),
+      };
+    });
+    out(JSON.stringify(enriched, null, 2));
     return;
   }
 
+  const agentSummary = {};
+  for (const a of agents) {
+    agentSummary[a.id] = {
+      name: a.name,
+      targetDir: a.targetDir,
+      total: items.length,
+      upToDate: 0,
+      outdated: 0,
+      missing: 0,
+    };
+  }
+
   out(`\n=== Dostępne Skille w DeerSkills Hub (${items.length}) ===\n`);
   for (const s of items) {
     const badge = s.scope === 'global' ? '★ GLOBAL' : `@${s.namespace}`;
-    const ver = s.latest_version ? `v${s.latest_version}` : 'v1.0.0';
-    out(`  • ${s.full_slug.padEnd(35)} [${ver}] [${badge}]`);
-    if (s.summary) out(`    ${s.summary.slice(0, 90)}...`);
+    const latestVer = s.latest_version ? `v${s.latest_version}` : 'v1.0.0';
+    const insp = inspectSkillForAgents(agents, s, lock);
+
+    for (const a of agents) {
+      const st = insp.agents[a.id];
+      if (st.status === 'up_to_date') agentSummary[a.id].upToDate += 1;
+      else if (st.status === 'outdated') agentSummary[a.id].outdated += 1;
+      else agentSummary[a.id].missing += 1;
+    }
+
+    const agentBadges = agents.map((a) => insp.agents[a.id].badge).join(' ');
+
+    out(`  • ${s.full_slug.padEnd(36)} ${latestVer.padEnd(10)} ${badge.padEnd(14)} ${insp.overallBadge}`);
+    out(`    Agenci: ${agentBadges}`);
+    if (s.summary) out(`    ${s.summary.slice(0, 95)}...`);
     if (s.tags && s.tags.length) out(`    Tagi: ${s.tags.join(', ')}`);
     out('');
   }
+
+  out('─'.repeat(78));
+  out(`📊 Stan platform agentów AI / lokalnego środowiska agenta:`);
+  let anyOutdated = false;
+  let anyMissing = false;
+
+  for (const a of agents) {
+    const sum = agentSummary[a.id];
+    if (sum.outdated > 0) anyOutdated = true;
+    if (sum.missing > 0) anyMissing = true;
+
+    let badgeText = '';
+    if (sum.upToDate === sum.total) {
+      badgeText = `\x1b[32m${sum.upToDate}/${sum.total} aktualne\x1b[0m`;
+    } else {
+      const parts = [];
+      if (sum.upToDate > 0) parts.push(`\x1b[32m${sum.upToDate} aktualne\x1b[0m`);
+      if (sum.outdated > 0) parts.push(`\x1b[33m${sum.outdated} do aktualizacji\x1b[0m`);
+      if (sum.missing > 0) parts.push(`\x1b[90m${sum.missing} brak\x1b[0m`);
+      badgeText = parts.join(', ');
+    }
+    out(`   • ${(a.name + ' (' + a.id + '):').padEnd(36)} ${badgeText}`);
+  }
+
+  if (anyOutdated || anyMissing) {
+    out(`\n💡 Aby zainstalować brakujące i zaktualizować wszystkie skille u agentów:`);
+    out(`   \x1b[36mdeertools skill sync\x1b[0m   (lub: \x1b[36mdeertools sync\x1b[0m)`);
+  } else {
+    out(`\n✓ Wszystkie skille zespołu (${items.length}) są zainstalowane i aktualne u wszystkich wykrytych agentów.`);
+  }
+  out('─'.repeat(78) + '\n');
 }
 
 async function cmdSkillSearch(query, flags, out, err) {
   return cmdSkillList({ ...flags, query }, out, err);
 }
 
-async function cmdSkillInstall(target, flags, out, err) {
-  let [slug, requestedVersion] = String(target || '').split('@');
-  slug = slug.trim();
-
-  // Jeśli brak argumentu lub "all" lub nazwa produktu Deer, zachowaj kompatybilność wsteczną
-  if (!slug || slug === 'all' || ['estimate', 'catalog', 'deliveries', 'supplier', 'rendermind'].includes(slug)) {
-    const products = resolveProducts(slug || 'all');
-    const agents = detectAgents({ dir: flags.dir, agent: flags.agent });
-    let installed = 0;
-
-    for (const product of products) {
-      const r = await fetchText(`${product.site}/skill/SKILL.md`);
-      if (!r.ok) continue;
-      const skillName = parseFrontmatterName(r.text) || `deer-${product.id}`;
-      for (const agent of agents) {
-        try {
-          const dest = installSkillContent(agent, skillName, r.text);
-          out(`✓ [${agent.id}] ${product.name}: ${dest}`);
-          installed += 1;
-        } catch (e) {
-          err(`✗ [${agent.id}] ${product.name}: ${e.message}`);
-        }
-      }
-    }
-    if (!installed) throw new Error('Nie zainstalowano żadnego skilla produktowego.');
-    return;
-  }
+/**
+ * Instaluje pojedynczy skill z DeerSkills Hub.
+ */
+async function installSingleSkill(slug, requestedVersion, flags, out, err, { silentSummary = false } = {}) {
+  const legacyMap = {
+    estimate: 'deer-kosztorys',
+    catalog: 'deer-catalog',
+    deliveries: 'deertools-dostawy',
+    supplier: 'deertools-supplier-hub',
+    rendermind: 'rendermind',
+  };
+  const resolvedSlug = legacyMap[slug] || slug;
 
-  // Instalacja konkretnego skilla z DeerSkills Hub
-  out(`Pobieram skill „${slug}”${requestedVersion ? ` w wersji ${requestedVersion}` : ''} z DeerSkills Hub...`);
-  const res = await skillsHub.getSkill(slug, requestedVersion);
+  if (!silentSummary) {
+    out(`Pobieram skill „${resolvedSlug}”${requestedVersion ? ` w wersji ${requestedVersion}` : ''} z DeerSkills Hub...`);
+  }
+  const res = await skillsHub.getSkill(resolvedSlug, requestedVersion);
 
   if (!res.ok || !res.data?.skill) {
-    throw new Error(`Nie znaleziono skilla „${slug}” w DeerSkills Hub (${res.status}): ${res.data?.error || 'Błąd'}`);
+    throw new Error(`Nie znaleziono skilla „${resolvedSlug}” w DeerSkills Hub (${res.status}): ${res.data?.error || 'Błąd'}`);
   }
 
   const skill = res.data.skill;
   const versionData = res.data.selected_version || res.data.version || (res.data.versions && res.data.versions[0]);
   if (!versionData) {
-    throw new Error(`Brak opublikowanej wersji dla skilla „${slug}”.`);
+    throw new Error(`Brak opublikowanej wersji dla skilla „${resolvedSlug}”.`);
   }
   const agents = detectAgents({ dir: flags.dir, agent: flags.agent });
 
@@ -125,12 +329,14 @@ async function cmdSkillInstall(target, flags, out, err) {
   for (const agent of agents) {
     try {
       const dest = installSkillContent(agent, skill.slug, versionData.skill_md_content);
-      out(`✓ [${agent.id}] Zainstalowano ${skill.full_slug} (${versionData.version}) → ${dest}`);
+      if (!silentSummary) {
+        out(`✓ [${agent.id}] Zainstalowano ${skill.full_slug} (${versionData.version}) → ${dest}`);
+      }
       count += 1;
 
       // Jeśli są dodatkowe pliki w manifeście, zapisz je obok SKILL.md
       if (versionData.files_manifest && Array.isArray(versionData.files_manifest)) {
-        const baseDir = path.dirname(dest);
+        const baseDir = agent.format === 'cursor_mdc' ? path.join(agent.targetDir, skill.slug) : path.dirname(dest);
         for (const file of versionData.files_manifest) {
           const targetFile = path.join(baseDir, file.path);
           fs.mkdirSync(path.dirname(targetFile), { recursive: true });
@@ -147,18 +353,112 @@ async function cmdSkillInstall(target, flags, out, err) {
   }
 
   // Zapis do .deertools-lock.json
-  const lock = readLock();
+  const lock = readLock(flags.dir);
   lock.skills[skill.slug] = {
     fullSlug: skill.full_slug,
     version: versionData.version,
     installedAt: new Date().toISOString(),
     sha256: versionData.sha256_checksum,
   };
-  writeLock(lock);
-  out(`✓ Zaktualizowano ${LOCK_FILE} (wersja ${versionData.version}).`);
+  writeLock(lock, flags.dir);
+
+  if (!silentSummary) {
+    out(`✓ Zaktualizowano ${LOCK_FILE} (wersja ${versionData.version}).`);
+    printSkillSummary(skill, versionData, out);
+  }
+
+  return { skill, versionData, count };
+}
+
+/**
+ * Instaluje lub synchronizuje wszystkie skille zespołu z DeerSkills Hub.
+ */
+async function cmdSkillSync(flags, out, err) {
+  out('Pobieram pełną listę skilli zespołu z DeerSkills Hub...');
+  const res = await skillsHub.listSkills({ limit: 100 });
+  if (!res.ok) {
+    err(`✗ Błąd pobierania katalogu skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+    return;
+  }
+  const items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
+  if (items.length === 0) {
+    out('Brak skilli w DeerSkills Hub.');
+    return;
+  }
+
+  let agents = detectAgents({ dir: flags.dir, agent: flags.agent });
+  if (flags.i || flags.interactive || flags.select) {
+    const { promptSelectAgents } = require('./agent-detector');
+    const available = detectAgents({ dir: flags.dir, 'ignore-selected': true });
+    agents = await promptSelectAgents(available);
+    flags = { ...flags, agent: agents.map((a) => a.id).join(',') };
+  }
+
+  if (agents.length === 0) {
+    err('✗ Nie wybrano ani nie wykryto żadnego środowiska agenta AI.');
+    return;
+  }
+
+  const lock = readLock(flags.dir);
+  out(`Platformy docelowe: \x1b[36m${agents.map((a) => a.name || a.id).join(', ')}\x1b[0m`);
+  out(`Rozpoczynam synchronizację ${items.length} skilli zespołu...\n`);
+
+  let installedCount = 0;
+  let updatedCount = 0;
+  let unchangedCount = 0;
+  let failedCount = 0;
+
+  for (const s of items) {
+    const slug = s.slug;
+    const fullSlug = s.full_slug;
+    const current = lock.skills?.[slug] || lock.skills?.[fullSlug];
+    const currentVer = current?.version;
+    const latestVer = s.latest_version || '1.0.0';
+
+    if (currentVer && currentVer === latestVer && !flags.force) {
+      out(`  \x1b[32m✓\x1b[0m ${s.full_slug.padEnd(38)} v${currentVer.padEnd(8)} [Aktualny]`);
+      unchangedCount += 1;
+      continue;
+    }
+
+    try {
+      await installSingleSkill(s.full_slug || s.slug, latestVer, flags, out, err, { silentSummary: true });
+      if (currentVer) {
+        out(`  \x1b[33m↑\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zaktualizowano z v${currentVer}]`);
+        updatedCount += 1;
+      } else {
+        out(`  \x1b[36m+\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zainstalowano]`);
+        installedCount += 1;
+      }
+    } catch (e) {
+      out(`  \x1b[31m✗\x1b[0m ${s.full_slug.padEnd(38)} Błąd: ${e.message}`);
+      failedCount += 1;
+    }
+  }
+
+  out('\n' + '─'.repeat(72));
+  out(`\x1b[1m✓ Podsumowanie synchronizacji ekosystemu Deer Design:\x1b[0m`);
+  out(`   • Nowo zainstalowane:       \x1b[36m${installedCount}\x1b[0m`);
+  out(`   • Zaktualizowane:          \x1b[33m${updatedCount}\x1b[0m`);
+  out(`   • Aktualne bez zmian:      \x1b[32m${unchangedCount}\x1b[0m`);
+  if (failedCount > 0) {
+    out(`   • Błędy instalacji:        \x1b[31m${failedCount}\x1b[0m`);
+  }
+  out(`   • Agenci docelowi:         ${agents.map((a) => a.id).join(', ')}`);
+  out(`   • Zapisano w rejestrze:    ${LOCK_FILE}`);
+  out('─'.repeat(72) + '\n');
+}
+
+async function cmdSkillInstall(target, flags, out, err) {
+  let [slug, requestedVersion] = String(target || '').split('@');
+  slug = (slug || '').trim();
+
+  // Jeśli brak argumentu lub "all" / "--all" / "team" / "*" lub flaga --all, synchronizuj wszystkie
+  if (!slug || slug === 'all' || slug === '--all' || slug === 'team' || slug === '*' || flags.all) {
+    return cmdSkillSync(flags, out, err);
+  }
 
-  // Podsumowanie możliwości skilla dla użytkownika i Agenta AI
-  printSkillSummary(skill, versionData, out);
+  await installSingleSkill(slug, requestedVersion, flags, out, err);
 }
 
 function extractCapabilities(content, summary = '') {
@@ -479,6 +779,7 @@ module.exports = {
   cmdSkillList,
   cmdSkillSearch,
   cmdSkillInstall,
+  cmdSkillSync,
   cmdSkillPush,
   cmdSkillCheck,
   cmdSkillUpdate,