@akshar5/skillsync 0.1.3 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akshar Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -15,7 +15,7 @@ npm install -g @akshar5/skillsync
 Connect this device to an existing private skills vault:
 
 ```bash
-skillsync setup --repo AksharP5/skills
+skillsync setup --repo OWNER/skills
 ```
 
 Add a local skill folder to the vault:
@@ -88,7 +88,7 @@ npm install -g @akshar5/skillsync
 Connect to an existing vault:
 
 ```bash
-skillsync setup --repo AksharP5/skills
+skillsync setup --repo OWNER/skills
 ```
 
 Or create/select a vault repo interactively:
@@ -99,7 +99,7 @@ skillsync setup
 
 If you run plain `skillsync setup` in an interactive terminal, it first asks which vault type to use:
 
-- Choose `Use an existing GitHub repo`, then enter a repo like `AksharP5/skills`.
+- Choose `Use an existing GitHub repo`, then enter a repo like `OWNER/skills`.
 - Choose `Create or use OWNER/<name>`, then enter a repo name like `skills`.
 
 `setup --name skills` is the non-interactive form of the second option. It creates `OWNER/skills` as a private GitHub repo if it does not exist. If it exists, SkillSync verifies it is private before using it.
@@ -107,7 +107,7 @@ If you run plain `skillsync setup` in an interactive terminal, it first asks whi
 You can also run commands without a global install:
 
 ```bash
-npx @akshar5/skillsync setup --repo AksharP5/skills
+npx @akshar5/skillsync setup --repo OWNER/skills
 npx @akshar5/skillsync add https://github.com/example-org/example-skill --skill example-skill
 ```
 
@@ -115,7 +115,7 @@ If an older SkillSync version failed with `git@github.com: Permission denied (pu
 
 ```bash
 npm install -g @akshar5/skillsync@latest
-skillsync setup --repo AksharP5/skills
+skillsync setup --repo OWNER/skills
 ```
 
 ## Common workflows
@@ -134,6 +134,14 @@ skillsync
 
 Choose `Browse/install skills`, press Space to select every skill you want installed on this device, then press Enter to apply the changes.
 
+View skills installed on this device:
+
+```bash
+skillsync installed
+```
+
+In the interactive UI, choose `Installed on this device` to see both SkillSync-managed installs and detected local skills. From there you can sync vault-backed skills or uninstall selected skills from the current device. Local-only detected folders require confirmation before SkillSync deletes them.
+
 Check current vault/device state:
 
 ```bash
@@ -180,6 +188,8 @@ Sync the vault and reapply local links:
 skillsync sync
 ```
 
+If an installed skill changes in the vault, `skillsync sync` pulls the vault and reapplies local projections. Symlink targets point at the current vault copy automatically; copy targets are refreshed when links are reapplied. Vault skills that already exist locally but were not installed by SkillSync are shown as local vault-backed skills and checked in Browse/install. Sync them from the `Installed on this device` screen to replace the same-named local folder with the vault-managed projection.
+
 Scan configured target folders for already-installed local skills:
 
 ```bash
@@ -195,6 +205,7 @@ skillsync setup --name skills
 skillsync
 skillsync status
 skillsync list
+skillsync installed
 skillsync add <skill-folder-or-git-url> --skill <name>
 skillsync add https://github.com/example-org/example-skill --skill example-skill
 skillsync import hermes
@@ -214,9 +225,13 @@ skillsync daemon
 - `skillsync uninstall <skill>` removes the skill from the current device only.
 - `skillsync delete <skill>` removes the skill from the vault and all device manifests.
 
+## Skill names
+
+Skill names are vault-wide identifiers. Installing `my-skill` on two devices means both devices refer to the same vault skill. You can install the same skill on many devices, but you should not use the same name for two different skills in one vault; adding a skill with an existing name updates/replaces that vault entry.
+
 ## Detected versus managed skills
 
-`installed` skills are SkillSync-managed projections into a target folder. `detected` skills are already present in a local agent's skill tree, such as bundled Hermes skills under `~/.hermes/skills`.
+`managed` skills are SkillSync-owned projections into a target folder. `detected` skills are already present in a local agent's skill tree, such as bundled Hermes skills under `~/.hermes/skills` or skills you installed before setting up SkillSync.
 
 For Hermes, use a separate scan path so SkillSync installs personal synced skills into `~/.hermes/skills/personal` while still showing the full Hermes skill inventory from `~/.hermes/skills`:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akshar5/skillsync",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Local-first GitHub-backed skill vault sync client for AI agent skills.",
   "type": "module",
   "repository": {
@@ -15,6 +15,7 @@
     "skillsync": "src/cli.js"
   },
   "files": [
+    "LICENSE",
     "src",
     "README.md"
   ],

package/src/cli.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 
 import { loadConfig, saveConfig, defaultRepoPath } from './core/config.js';
 import { addTarget, applyLinks, defaultDeviceId, installSkill, listDevices, loadDevice, removeTarget, scanTargets, uninstallSkill } from './core/device.js';
-import { ensureDir, exists, expandHome } from './core/fs.js';
+import { ensureDir, exists, expandHome, removePath } from './core/fs.js';
 import { cloneRepo, commandExists, commitAllIfChanged, gh, git, isGitRepo, push, run } from './core/git.js';
 import { addSkillToVault, deleteSkillFromVault, ensureVault, loadRegistry, rebuildRegistry, refreshChangedRegistryEntries, validateSkillFolder } from './core/registry.js';
 import { cloneSkillSource, discoverSkillFolders, isRemoteSkillSource, selectDiscoveredSkills } from './core/source.js';
@@ -34,6 +34,8 @@ async function main() {
       return status();
     case 'list':
       return listSkills();
+    case 'installed':
+      return installedCommand();
     case 'add':
       return addSkill(rest);
     case 'import':
@@ -102,6 +104,12 @@ async function promptWithEscape(promptPromise, escapeValue = null) {
   }
 }
 
+function promptPageSize(itemCount, { min = 8, max = 28, reservedRows = 6 } = {}) {
+  const rows = Number(process.stdout.rows) || 30;
+  const availableRows = Math.max(min, rows - reservedRows);
+  return Math.max(1, Math.min(itemCount, max, availableRows));
+}
+
 async function configured() {
   const config = await loadConfig();
   if (!config.repoPath || !await exists(config.repoPath)) {
@@ -289,9 +297,90 @@ async function listSkills() {
     console.log('No skills in vault yet. Add one with: skillsync add <skill-folder>');
     return;
   }
+  const localByName = new Map(localSkillEntries(device, registry).map((skill) => [skill.name, skill]));
   for (const name of names) {
-    const targets = device.installed[name]?.join(', ');
-    console.log(`${targets ? '✓' : '○'} ${name}${targets ? `  [${targets}]` : ''}`);
+    const localSkill = localByName.get(name);
+    const targetSummary = localSkill ? localSkillTargetSummary(localSkill) : '';
+    const state = localSkill?.managedTargets.length ? 'managed' : 'local';
+    console.log(`${targetSummary ? '✓' : '○'} ${name}${targetSummary ? `  [${state}: ${targetSummary}]` : ''}`);
+  }
+}
+
+function localSkillEntries(device, registry) {
+  const byName = new Map();
+  const entryFor = (name) => {
+    if (!byName.has(name)) {
+      byName.set(name, {
+        name,
+        managedTargets: new Set(),
+        detectedTargets: [],
+        inVault: Boolean(registry.skills[name]),
+      });
+    }
+    return byName.get(name);
+  };
+
+  for (const [name, targets] of Object.entries(device.installed || {})) {
+    const entry = entryFor(name);
+    for (const target of Array.isArray(targets) ? targets : []) entry.managedTargets.add(target);
+  }
+
+  for (const [targetName, skills] of Object.entries(device.detected || {})) {
+    if (!Array.isArray(skills)) continue;
+    for (const skill of skills) {
+      const entry = entryFor(skill.name);
+      entry.inVault = entry.inVault || Boolean(skill.in_vault) || Boolean(registry.skills[skill.name]);
+      entry.detectedTargets.push({
+        targetName,
+        path: skill.path,
+        inVault: Boolean(skill.in_vault) || Boolean(registry.skills[skill.name]),
+        managed: entry.managedTargets.has(targetName),
+      });
+    }
+  }
+
+  return Array.from(byName.values())
+    .map((entry) => ({
+      ...entry,
+      managedTargets: [...entry.managedTargets].sort(),
+      detectedTargets: entry.detectedTargets.sort((a, b) => a.targetName.localeCompare(b.targetName) || a.path.localeCompare(b.path)),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function localSkillLabel(skill) {
+  const localTargets = [...new Set(skill.detectedTargets.map((target) => {
+    if (!target.path || target.path === skill.name) return target.targetName;
+    return `${target.targetName}/${target.path}`;
+  }))];
+  const parts = [];
+  if (skill.managedTargets.length) parts.push(`managed: ${skill.managedTargets.join(', ')}`);
+  if (localTargets.length) parts.push(`local: ${localTargets.join(', ')}`);
+  parts.push(skill.inVault ? 'in vault' : 'local only');
+  return `${skill.name}  [${parts.join(' | ')}]`;
+}
+
+function localSkillTargetSummary(skill) {
+  const targets = new Set([
+    ...skill.managedTargets,
+    ...skill.detectedTargets.map((target) => target.targetName),
+  ]);
+  return [...targets].sort().join(', ');
+}
+
+async function installedCommand() {
+  const config = await configured();
+  await refreshChangedRegistryEntries(config.repoPath);
+  const registry = await loadRegistry(config.repoPath);
+  const device = await loadDevice(config.repoPath, config.deviceId);
+  const localSkills = localSkillEntries(device, registry);
+  if (!localSkills.length) {
+    console.log('No local skills found on this device. Run `skillsync scan` to refresh detected local skills.');
+    return;
+  }
+  console.log(`Local skills on ${device.display_name}:`);
+  for (const skill of localSkills) {
+    console.log(`- ${localSkillLabel(skill)}`);
   }
 }
 
@@ -458,7 +547,7 @@ async function chooseInstallTargets(config, rest) {
   return promptWithEscape(checkbox({
     message: 'Choose local targets',
     loop: false,
-    pageSize: Math.min(12, available.length),
+    pageSize: promptPageSize(available.length, { min: 6, max: 18 }),
     choices: available.map((target) => ({ name: target, value: target, checked: true })),
     instructions: 'Space toggles targets. Enter confirms. Esc cancels.',
   }), []);
@@ -585,23 +674,26 @@ async function runUi() {
 
   while (true) {
     await refreshChangedRegistryEntries(config.repoPath);
+    const menuChoices = [
+      { name: 'Browse/install skills', value: 'skills', description: 'Select multiple vault skills to install or remove here.' },
+      { name: 'Installed on this device', value: 'installed', description: 'View, sync, or uninstall local skills on this device.' },
+      { name: 'Devices', value: 'devices', description: 'Show devices known to the vault.' },
+      { name: 'Targets', value: 'targets', description: 'Manage local agent skill folders.' },
+      { name: 'Add skill from folder', value: 'add', description: 'Copy a local SKILL.md folder into the vault.' },
+      { name: 'Import Hermes skills', value: 'import-hermes', description: 'Import detected Hermes skills into the vault.' },
+      { name: 'Scan local targets', value: 'scan', description: 'Refresh detected local skills.' },
+      { name: 'Sync now', value: 'sync', description: 'Pull, link, scan, commit, and push vault changes.' },
+      { name: 'Quit', value: 'quit' },
+    ];
     const choice = await promptWithEscape(select({
       message: 'SkillSync',
       loop: false,
-      pageSize: 8,
-      choices: [
-        { name: 'Browse/install skills', value: 'skills', description: 'Select multiple vault skills to install or remove here.' },
-        { name: 'Devices', value: 'devices', description: 'Show devices known to the vault.' },
-        { name: 'Targets', value: 'targets', description: 'Manage local agent skill folders.' },
-        { name: 'Add skill from folder', value: 'add', description: 'Copy a local SKILL.md folder into the vault.' },
-        { name: 'Import Hermes skills', value: 'import-hermes', description: 'Import detected Hermes skills into the vault.' },
-        { name: 'Scan local targets', value: 'scan', description: 'Refresh detected local skills.' },
-        { name: 'Sync now', value: 'sync', description: 'Pull, link, scan, commit, and push vault changes.' },
-        { name: 'Quit', value: 'quit' },
-      ],
+      pageSize: promptPageSize(menuChoices.length, { min: 8, max: 12 }),
+      choices: menuChoices,
     }));
     if (!choice || choice === 'quit') return;
     if (choice === 'skills') await skillsScreen(config);
+    if (choice === 'installed') await installedScreen(config);
     if (choice === 'devices') await devicesScreen(config);
     if (choice === 'targets') await targetsScreen(config);
     if (choice === 'add') await addSkill([await input({ message: 'Skill folder path:' })]);
@@ -619,29 +711,31 @@ async function skillsScreen(config) {
     console.log('\nNo skills in vault yet. Use Add/import first.\n');
     return;
   }
-  const installedNames = new Set(Object.keys(device.installed || {}));
+  const localByName = new Map(localSkillEntries(device, registry).map((skill) => [skill.name, skill]));
+  const localVaultNames = new Set([...localByName.values()].filter((skill) => skill.inVault).map((skill) => skill.name));
   const selected = await promptWithEscape(checkbox({
     message: `Install skills on ${device.display_name}`,
     loop: false,
-    pageSize: Math.min(14, Math.max(7, names.length)),
+    pageSize: promptPageSize(names.length, { min: 10, max: 32, reservedRows: 5 }),
     instructions: 'Space toggles skills. Enter applies changes. Esc goes back.',
     choices: names.map((name) => {
-      const targets = device.installed[name] || [];
-      const targetLabel = targets.length ? `  [${targets.join(', ')}]` : '';
+      const localSkill = localByName.get(name);
+      const targetSummary = localSkill ? localSkillTargetSummary(localSkill) : '';
+      const state = localSkill?.managedTargets.length ? 'managed' : 'local';
+      const targetLabel = targetSummary ? `  [${state}: ${targetSummary}]` : '';
       return {
         name: `${name}${targetLabel}`,
         short: name,
         value: name,
-        checked: installedNames.has(name),
-        description: targets.length ? `Installed in ${targets.join(', ')}` : 'Not installed on this device',
+        checked: localVaultNames.has(name),
       };
     }),
   }));
   if (!selected) return;
 
   const selectedNames = new Set(selected);
-  const toInstall = names.filter((name) => selectedNames.has(name) && !installedNames.has(name));
-  const toUninstall = names.filter((name) => !selectedNames.has(name) && installedNames.has(name));
+  const toInstall = names.filter((name) => selectedNames.has(name) && !localVaultNames.has(name));
+  const toUninstall = names.filter((name) => !selectedNames.has(name) && localVaultNames.has(name));
   if (!toInstall.length && !toUninstall.length) {
     console.log('\nNo install changes.\n');
     return;
@@ -656,8 +750,16 @@ async function skillsScreen(config) {
   for (const skillName of toInstall) {
     await installSkill({ vaultPath: config.repoPath, deviceId: config.deviceId, skillName, targets });
   }
-  for (const skillName of toUninstall) {
-    await uninstallSkill({ vaultPath: config.repoPath, deviceId: config.deviceId, skillName });
+  const localToRemove = toUninstall.map((name) => localByName.get(name)).filter(Boolean);
+  if (localToRemove.some(hasUnmanagedDetectedTargets)) {
+    const confirmed = await confirm({
+      message: 'Remove selected local detected skill folders from this device?',
+      default: false,
+    });
+    if (!confirmed) return;
+  }
+  for (const skill of localToRemove) {
+    await uninstallLocalSkill({ config, device, skill });
   }
   await applyLinks({ vaultPath: config.repoPath, deviceId: config.deviceId });
   await syncVault({ vaultPath: config.repoPath, deviceId: config.deviceId, pull: false });
@@ -667,6 +769,173 @@ async function skillsScreen(config) {
   console.log(`\n${[installedText, removedText].filter(Boolean).join(' ')}\n`);
 }
 
+async function installedScreen(config) {
+  await refreshChangedRegistryEntries(config.repoPath);
+  const registry = await loadRegistry(config.repoPath);
+  const device = await loadDevice(config.repoPath, config.deviceId);
+  const localSkills = localSkillEntries(device, registry);
+  if (!localSkills.length) {
+    await promptWithEscape(select({
+      message: `Local skills on ${device.display_name}`,
+      loop: false,
+      pageSize: 1,
+      choices: [
+        { name: 'No local skills found. Run Scan local targets, then check again.', value: 'back' },
+      ],
+    }));
+    return;
+  }
+  const localByName = new Map(localSkills.map((skill) => [skill.name, skill]));
+
+  const selected = await promptWithEscape(checkbox({
+    message: `Local skills on ${device.display_name}`,
+    loop: false,
+    pageSize: promptPageSize(localSkills.length, { min: 8, max: 28, reservedRows: 5 }),
+    instructions: 'Space selects skills. Enter chooses an action. Esc goes back.',
+    choices: localSkills.map((skill) => ({
+      name: localSkillLabel(skill),
+      short: skill.name,
+      value: skill.name,
+      checked: false,
+    })),
+  }), []);
+  if (!selected.length) return;
+
+  const action = await promptWithEscape(select({
+    message: `Manage ${selected.length} selected skill${selected.length === 1 ? '' : 's'}`,
+    loop: false,
+    pageSize: 3,
+    choices: [
+      { name: 'Sync selected from vault', value: 'update', description: 'Replace same-named local skills with the vault version.' },
+      { name: 'Uninstall from this device', value: 'uninstall', description: 'Remove selected skills from this device only.' },
+      { name: 'Back', value: 'back' },
+    ],
+  }));
+  if (!action || action === 'back') return;
+
+  const selectedSkills = selected.map((name) => localByName.get(name)).filter(Boolean);
+  if (action === 'update') {
+    await updateLocalSkillsFromVault({ config, device, selectedSkills });
+    return;
+  }
+
+  if (selectedSkills.some(hasUnmanagedDetectedTargets)) {
+    console.log('\nLocal-only detected folders are not SkillSync-managed. Removing them deletes those local skill folders from this device only.\n');
+  }
+  const confirmed = await confirm({
+    message: `Uninstall ${selected.join(', ')} from this device?`,
+    default: false,
+  });
+  if (!confirmed) return;
+
+  for (const skill of selectedSkills) {
+    await uninstallLocalSkill({ config, device, skill });
+  }
+  await applyLinks({ vaultPath: config.repoPath, deviceId: config.deviceId });
+  await syncVault({ vaultPath: config.repoPath, deviceId: config.deviceId, pull: false });
+  console.log(`\nRemoved ${selected.join(', ')} from this device.\n`);
+}
+
+function hasUnmanagedDetectedTargets(skill) {
+  return skill.detectedTargets.some((target) => !target.managed);
+}
+
+function isPathInside(childPath, parentPath) {
+  const child = path.resolve(childPath);
+  const parent = path.resolve(parentPath);
+  return child === parent || child.startsWith(parent + path.sep);
+}
+
+function detectedTargetLocation(device, detectedTarget) {
+  const targetConfig = device.targets?.[detectedTarget.targetName];
+  if (!targetConfig) return { removable: false, reason: 'target is no longer configured' };
+
+  const scanRoot = path.resolve(expandHome(targetConfig.scan_path || targetConfig.path));
+  const installRoot = path.resolve(expandHome(targetConfig.path));
+  const absolutePath = path.resolve(scanRoot, detectedTarget.path || '.');
+  if (!isPathInside(absolutePath, scanRoot)) {
+    return { removable: false, reason: 'detected path is outside the scan path' };
+  }
+  if (absolutePath === installRoot || !isPathInside(absolutePath, installRoot)) {
+    return { removable: false, reason: 'detected path is outside the configured install folder' };
+  }
+  return { removable: true, absolutePath };
+}
+
+function removableDetectedTargets(device, skill, { onlyInVault = false } = {}) {
+  return skill.detectedTargets
+    .filter((target) => !target.managed)
+    .filter((target) => !onlyInVault || target.inVault)
+    .map((target) => ({ ...target, ...detectedTargetLocation(device, target) }));
+}
+
+async function removeDetectedTargetPaths(targets) {
+  const removed = [];
+  const skipped = [];
+  const seen = new Set();
+  for (const target of targets) {
+    if (!target.removable) {
+      skipped.push(target);
+      continue;
+    }
+    if (seen.has(target.absolutePath)) continue;
+    seen.add(target.absolutePath);
+    if (!await exists(path.join(target.absolutePath, 'SKILL.md'))) {
+      skipped.push({ ...target, reason: 'SKILL.md was not found' });
+      continue;
+    }
+    await removePath(target.absolutePath);
+    removed.push(target);
+  }
+  return { removed, skipped };
+}
+
+async function uninstallLocalSkill({ config, device, skill }) {
+  await uninstallSkill({ vaultPath: config.repoPath, deviceId: config.deviceId, skillName: skill.name });
+  return removeDetectedTargetPaths(removableDetectedTargets(device, skill));
+}
+
+async function updateLocalSkillsFromVault({ config, device, selectedSkills }) {
+  const updatable = selectedSkills.filter((skill) => skill.inVault);
+  const skipped = selectedSkills.filter((skill) => !skill.inVault).map((skill) => skill.name);
+  if (!updatable.length) {
+    console.log(`\nNo selected skills are in the vault.${skipped.length ? ` Skipped: ${skipped.join(', ')}.` : ''}\n`);
+    return;
+  }
+
+  await syncVault({ vaultPath: config.repoPath, deviceId: config.deviceId, pull: true });
+
+  const replacements = updatable.flatMap((skill) => removableDetectedTargets(device, skill, { onlyInVault: true }).filter((target) => target.removable));
+  if (replacements.length) {
+    const confirmed = await confirm({
+      message: `Replace ${replacements.length} local detected skill folder${replacements.length === 1 ? '' : 's'} with vault-managed links/copies?`,
+      default: false,
+    });
+    if (!confirmed) return;
+    await removeDetectedTargetPaths(replacements);
+  }
+
+  for (const skill of updatable) {
+    const targets = new Set(skill.managedTargets);
+    for (const detectedTarget of skill.detectedTargets) {
+      const location = detectedTargetLocation(device, detectedTarget);
+      if (detectedTarget.inVault && location.removable) targets.add(detectedTarget.targetName);
+    }
+    if (targets.size) {
+      await installSkill({
+        vaultPath: config.repoPath,
+        deviceId: config.deviceId,
+        skillName: skill.name,
+        targets: [...targets].sort(),
+      });
+    }
+  }
+
+  await applyLinks({ vaultPath: config.repoPath, deviceId: config.deviceId });
+  await syncVault({ vaultPath: config.repoPath, deviceId: config.deviceId, pull: false });
+  console.log(`\nUpdated from vault: ${updatable.map((skill) => skill.name).join(', ')}.${skipped.length ? ` Skipped local-only: ${skipped.join(', ')}.` : ''}\n`);
+}
+
 async function chooseTargets(config) {
   const device = await loadDevice(config.repoPath, config.deviceId);
   const targetNames = Object.keys(device.targets);
@@ -674,7 +943,7 @@ async function chooseTargets(config) {
   return promptWithEscape(checkbox({
     message: 'Install into which targets?',
     loop: false,
-    pageSize: Math.min(12, targetNames.length),
+    pageSize: promptPageSize(targetNames.length, { min: 6, max: 18 }),
     choices: targetNames.map((name) => ({ name, value: name, checked: true })),
     required: true,
     instructions: 'Space toggles targets. Enter confirms. Esc cancels.',
@@ -683,14 +952,22 @@ async function chooseTargets(config) {
 
 async function devicesScreen(config) {
   const devices = await listDevices(config.repoPath);
-  console.log('\nDevices');
-  for (const device of devices) {
+  const choices = devices.map((device) => {
     const installed = Object.keys(device.installed || {}).length;
     const detected = countDetectedSkills(device);
     const targets = Object.keys(device.targets || {}).join(', ') || 'no targets';
-    console.log(`- ${device.display_name} (${device.device_id}) — ${detected} local, ${installed} managed — ${targets} — last seen ${device.last_seen || 'never'}`);
-  }
-  console.log('');
+    return {
+      name: `${device.display_name} (${device.device_id})  [${detected} local, ${installed} managed]`,
+      value: device.device_id,
+      description: `${targets} — last seen ${device.last_seen || 'never'}`,
+    };
+  }).concat([{ name: 'Back', value: 'back' }]);
+  await promptWithEscape(select({
+    message: 'Devices',
+    choices,
+    loop: false,
+    pageSize: promptPageSize(choices.length, { min: 6, max: 18 }),
+  }));
 }
 
 async function targetsScreen(config) {
@@ -702,7 +979,12 @@ async function targetsScreen(config) {
     { name: 'Add target', value: 'add' },
     { name: 'Back', value: 'back' },
   ]);
-  const choice = await promptWithEscape(select({ message: 'Targets on this device', choices, loop: false, pageSize: Math.min(10, choices.length) }));
+  const choice = await promptWithEscape(select({
+    message: 'Targets on this device',
+    choices,
+    loop: false,
+    pageSize: promptPageSize(choices.length, { min: 6, max: 18 }),
+  }));
   if (!choice || choice === 'back') return;
   if (choice === 'add') {
     const name = await input({ message: 'Target name (codex, claude, hermes, custom):' });
@@ -716,5 +998,5 @@ async function targetsScreen(config) {
 }
 
 function help() {
-  console.log(`SkillSync\n\nUsage:\n  skillsync setup [--name skills] [--repo owner/repo|url]\n  skillsync                 Open TUI\n  skillsync list\n  skillsync add <skill-folder-or-git-url> [--skill name] [--target target]\n  skillsync import hermes\n  skillsync install <skill> [--target codex,claude]\n  skillsync uninstall <skill>\n  skillsync delete <skill>\n  skillsync target add <name> <path> [--mode symlink|copy] [--scan-path path]\n  skillsync scan\n  skillsync sync\n  skillsync service install\n  skillsync daemon\n`);
+  console.log(`SkillSync\n\nUsage:\n  skillsync setup [--name skills] [--repo owner/repo|url]\n  skillsync                 Open TUI\n  skillsync list\n  skillsync installed\n  skillsync add <skill-folder-or-git-url> [--skill name] [--target target]\n  skillsync import hermes\n  skillsync install <skill> [--target codex,claude]\n  skillsync uninstall <skill>\n  skillsync delete <skill>\n  skillsync target add <name> <path> [--mode symlink|copy] [--scan-path path]\n  skillsync scan\n  skillsync sync\n  skillsync service install\n  skillsync daemon\n`);
 }