sra-skills 0.14.13 → 0.16.0

package/index.mjs

@@ -9,11 +9,198 @@ import {
   mergeCredentials, warnMissingCredentials,
   runToolSetup, runPostInstall, runPostUninstall, promptSkillDeps, findSkillsWithDeps,
   ensureIdentity, resolveSkillDependencyClosure, planSkillRemovals,
+  loadProfiles, getProfileSkills, validateProfileSkills,
 } from './lib.mjs';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, lstatSync, unlinkSync, rmSync } from 'fs';
 import { join, basename, resolve } from 'path';
 import { execSync } from 'child_process';
 
+// --- Profile helpers (identity/role detection) ---
+
+const IDENTITY_CACHE = join(SRA_HOME, 'identity.json');
+const IDENTITY_TTL_HOURS = 24;
+const WHOIS_API_URL = 'https://issues.aiassistant.mpsra.shopee.io/api/whois';
+const WHOIS_API_TOKEN = 'wczlkTZazZCWG80wq9OGNH2J8To-bZ6NXOee3dDQX_E';
+const WHOIS_TIMEOUT = 5000;
+
+const DEPT_TO_TEAM = {
+  'search': 'search',
+  'recommendation': 'rcmd',
+  'ads': 'ads',
+  'engineering & architecture': 'ea',
+};
+
+function parseTeamFromDept(departmentPath) {
+  if (!departmentPath) return null;
+  const parts = departmentPath.split('/').map(p => p.trim());
+  const dept = (parts.length > 1 ? parts[parts.length - 1] : parts[0]).toLowerCase();
+  for (const [keyword, teamKey] of Object.entries(DEPT_TO_TEAM)) {
+    if (dept.includes(keyword)) return teamKey;
+  }
+  return null;
+}
+
+function readIdentityCache() {
+  if (!existsSync(IDENTITY_CACHE)) return null;
+  try {
+    const data = JSON.parse(readFileSync(IDENTITY_CACHE, 'utf8'));
+    if (typeof data !== 'object' || !data.profile_key) return null;
+    return data;
+  } catch { return null; }
+}
+
+function writeIdentityCache(email, team, role, profileKey) {
+  mkdirSync(SRA_HOME, { recursive: true });
+  writeFileSync(IDENTITY_CACHE, JSON.stringify({
+    email, team, role, profile_key: profileKey,
+    detected_at: new Date().toISOString(),
+  }, null, 2) + '\n');
+}
+
+async function fetchRoleFromApi(email) {
+  try {
+    const url = `${WHOIS_API_URL}?email=${encodeURIComponent(email)}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), WHOIS_TIMEOUT);
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json', Authorization: `Bearer ${WHOIS_API_TOKEN}` },
+    });
+    clearTimeout(timeout);
+    const result = await resp.json();
+    if (!result.success) return null;
+    const data = result.data || {};
+    const team = parseTeamFromDept(data.department_path || '');
+    const role = (data.role || '').toLowerCase().trim();
+    if (team && role) return [team, role];
+  } catch {}
+  return null;
+}
+
+async function detectRole(email) {
+  if (!email) return 'other';
+  const cache = readIdentityCache();
+  if (cache && cache.email === email && cache.detected_at) {
+    try {
+      const age = Date.now() - new Date(cache.detected_at).getTime();
+      if (age < IDENTITY_TTL_HOURS * 3600 * 1000) return cache.profile_key;
+    } catch {}
+  }
+  const result = await fetchRoleFromApi(email);
+  if (result) {
+    const [team, role] = result;
+    const profileKey = `${team}/${role}`;
+    writeIdentityCache(email, team, role, profileKey);
+    return profileKey;
+  }
+  if (cache && cache.email === email) return cache.profile_key || 'other';
+  return 'other';
+}
+
+function getUserEmail() {
+  const credPath = join(HOME, '.config', 'sra', 'credentials.json');
+  if (!existsSync(credPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(credPath, 'utf8'));
+    return data.default?.identity || null;
+  } catch { return null; }
+}
+
+function computeSkillDiff(allDiscovered, profileSkillNames, enabled, disabled) {
+  const discoveredNames = new Set(allDiscovered.map(s => s.name));
+  const effEnabled = new Set([...enabled].filter(n => discoveredNames.has(n)));
+  const effDisabled = new Set([...disabled].filter(n => discoveredNames.has(n)));
+  const hasProfile = profileSkillNames !== null;
+
+  const keep = new Set();
+  const newProfile = new Set();
+  const newOther = new Set();
+  const removedFromProfile = new Set();
+  const forcedDisabled = new Set();
+
+  for (const s of allDiscovered) {
+    const { name } = s;
+    if (effEnabled.has(name)) {
+      if (hasProfile && profileSkillNames.size && !profileSkillNames.has(name)) {
+        removedFromProfile.add(name);
+      } else {
+        keep.add(name);
+      }
+    } else if (effDisabled.has(name)) {
+      forcedDisabled.add(name);
+    } else {
+      if (hasProfile && profileSkillNames.size && profileSkillNames.has(name)) {
+        newProfile.add(name);
+      } else {
+        newOther.add(name);
+      }
+    }
+  }
+  return { keep, newProfile, newOther, removedFromProfile, forcedDisabled };
+}
+
+function parseSkillsFile(path) {
+  try {
+    const result = new Set();
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+      const t = line.trim();
+      if (t && !t.startsWith('#')) result.add(t);
+    }
+    return result;
+  } catch (e) {
+    console.error(`Error reading skills file ${path}: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function selectSkillsWithProfile(skills, profileSkillNames, profileKey, profilesData) {
+  if (!process.stdin.isTTY) return [skills.filter(s => profileSkillNames.has(s.name)), profileKey];
+  const label = profilesData?.profiles?.[profileKey]?.label || profileKey;
+  console.log(`\n检测到角色: ${label} (${profileKey})`);
+  const choices = [];
+  const recommended = skills.filter(s => profileSkillNames.has(s.name));
+  const others = skills.filter(s => !profileSkillNames.has(s.name));
+  if (recommended.length) {
+    choices.push({ name: `── 推荐 (profile + core) ──`, value: null, disabled: '' });
+    for (const s of recommended) choices.push({ name: s.name, value: s.name, checked: true });
+  }
+  if (others.length) {
+    choices.push({ name: `── 其他可用 ──`, value: null, disabled: '' });
+    for (const s of others) choices.push({ name: s.name, value: s.name, checked: false });
+  }
+  const selected = await checkbox({
+    message: `Select skills (${recommended.length} recommended / ${skills.length} total)`,
+    choices, pageSize: 20,
+  });
+  return [skills.filter(s => selected.includes(s.name)), profileKey];
+}
+
+async function promptSkillChanges(diff, allSkills, profileSkillNames, skipPrompt) {
+  const { newProfile, newOther, removedFromProfile } = diff;
+  if (!newProfile.size && !newOther.size && !removedFromProfile.size) return [new Set(), new Set()];
+  if (skipPrompt || !process.stdin.isTTY) return [newProfile, new Set()];
+
+  const choices = [];
+  for (const name of [...newProfile].sort()) {
+    choices.push({ name: `${name}  \x1b[32m← NEW (推荐)\x1b[0m`, value: `enable:${name}`, checked: true });
+  }
+  for (const name of [...newOther].sort()) {
+    choices.push({ name: `${name}  \x1b[32m← NEW\x1b[0m`, value: `enable:${name}`, checked: false });
+  }
+  for (const name of [...removedFromProfile].sort()) {
+    choices.push({ name: `${name}  \x1b[33m← 不再推荐\x1b[0m`, value: `keep:${name}`, checked: true });
+  }
+
+  const selected = await checkbox({ message: 'Skill 变更:', choices, pageSize: 20 });
+  const selectedSet = new Set(selected);
+  const toEnable = new Set();
+  const toDisable = new Set();
+  for (const name of newProfile) { if (selectedSet.has(`enable:${name}`)) toEnable.add(name); }
+  for (const name of newOther) { if (selectedSet.has(`enable:${name}`)) toEnable.add(name); }
+  for (const name of removedFromProfile) { if (!selectedSet.has(`keep:${name}`)) toDisable.add(name); }
+  return [toEnable, toDisable];
+}
+
 async function selectSkills(skills, previouslyEnabled = null, previouslyDisabled = null) {
   if (!process.stdin.isTTY) return skills;
   const enabledSet = previouslyEnabled instanceof Set ? previouslyEnabled : null;
@@ -100,20 +287,25 @@ function getOptionValue(args, flag) {
 
 function parseSkillsFilter(args) {
   const raw = getOptionValue(args, '--skills') || process.env.SRA_SKILLS || '';
-  if (!raw.trim()) return null;
-  return new Set(raw.split(',').map(s => s.trim()).filter(Boolean));
+  if (raw.trim()) return new Set(raw.split(',').map(s => s.trim()).filter(Boolean));
+  const skillsFile = getOptionValue(args, '--skills-file');
+  if (skillsFile) return parseSkillsFile(skillsFile);
+  return null;
 }
 
 if (cmd === 'add') {
   const isLocal = cmdArgs.includes('--local');
-  const skipPrompt = cmdArgs.includes('-y') || cmdArgs.includes('--yes');
+  const skipPrompt = cmdArgs.includes('-y') || cmdArgs.includes('--yes') || cmdArgs.includes('--non-interactive');
+  const installAll = cmdArgs.includes('--all');
+  const resetFlag = cmdArgs.includes('--reset');
   const defaultIdentity = getOptionValue(cmdArgs, '--default-identity');
+  const explicitProfile = getOptionValue(cmdArgs, '--profile');
   const skillsFilter = parseSkillsFilter(cmdArgs);
   const tools = parseToolFlag(cmdArgs) || detectTools();
   let url, name, repoPath, existingRef;
 
   // Values consumed by named options must not be mistaken for the positional URL/path argument
-  const _namedOptionFlags = ['--tool', '--name', '--ref', '--default-identity', '--skills'];
+  const _namedOptionFlags = ['--tool', '--name', '--ref', '--default-identity', '--skills', '--skills-file', '--profile'];
   const _consumedValues = new Set(_namedOptionFlags.map(f => getOptionValue(cmdArgs, f)).filter(Boolean));
   const _positional = a => !a.startsWith('-') && !_consumedValues.has(a);
 
@@ -144,7 +336,12 @@ if (cmd === 'add') {
         '  --tool <tool>           Target AI tool (claude, cursor, codex; auto-detected)\n' +
         '  --name <name>           Override local repo name\n' +
         '  --skills <a,b,...>      Install only specific skills (comma-separated)\n' +
-        '  -y, --yes               Skip interactive prompts\n'
+        '  --skills-file <path>    Install skills listed in file (one per line)\n' +
+        '  --profile <key>         Explicit profile (e.g. rcmd/algo), skip auto-detection\n' +
+        '  --all                   Install all skills (ignores profile)\n' +
+        '  --reset                 Clear disabled_skills and re-run profile selection\n' +
+        '  -y, --yes               Non-interactive mode, install by profile defaults\n' +
+        '  --non-interactive       Same as -y\n'
       );
       process.exit(1);
     }
@@ -211,17 +408,25 @@ if (cmd === 'add') {
     }
   }
 
-  // Read previous selections if re-adding same repo
+  const allDiscovered = discoverSkills(repoPath);
+  const discoveredNames = new Set(allDiscovered.map(s => s.name));
   const manifest = readManifest();
   const existingRepo = manifest.repos[name];
-  const previouslyEnabled = existingRepo ? new Set(existingRepo.skills || []) : null;
-  const previouslyDisabled = existingRepo ? new Set(existingRepo.disabled_skills || []) : null;
 
-  const allDiscovered = discoverSkills(repoPath);
+  const isRepeat = existingRepo != null && !resetFlag;
+  let enabled = isRepeat ? new Set(existingRepo.skills || []) : new Set();
+  let disabled = isRepeat ? new Set(existingRepo.disabled_skills || []) : new Set();
+  const savedProfile = isRepeat ? existingRepo.profile || null : null;
+
+  // Merge credentials first (backs up malformed files), then collect identity
+  const credPath = mergeCredentials(repoPath);
+  await ensureIdentity(skipPrompt, defaultIdentity);
+
+  let profileKeyUsed = null;
   let skills;
+
   if (skillsFilter) {
-    const knownNames = new Set(allDiscovered.map(s => s.name));
-    const unknown = [...skillsFilter].filter(n => !knownNames.has(n));
+    const unknown = [...skillsFilter].filter(n => !discoveredNames.has(n));
     if (unknown.length) console.warn(`Warning: requested skill(s) not found in repo: ${unknown.join(', ')}`);
     skills = allDiscovered.filter(s => skillsFilter.has(s.name));
     if (!skills.length) {
@@ -229,25 +434,66 @@ if (cmd === 'add') {
         allDiscovered.map(s => s.name).join(', '));
       process.exit(1);
     }
-  } else if (!skipPrompt) {
-    skills = await selectSkills(allDiscovered, previouslyEnabled, previouslyDisabled);
-  } else {
+  } else if (installAll) {
     skills = allDiscovered;
+  } else {
+    const profilesData = loadProfiles(repoPath);
+    if (!profilesData) {
+      if (isRepeat) {
+        skills = allDiscovered.filter(s => !disabled.has(s.name));
+      } else if (skipPrompt) {
+        skills = allDiscovered;
+      } else {
+        skills = await selectSkills(allDiscovered);
+      }
+    } else {
+      if (explicitProfile) {
+        profileKeyUsed = explicitProfile;
+      } else if (savedProfile && isRepeat) {
+        profileKeyUsed = savedProfile;
+      } else {
+        const email = defaultIdentity || getUserEmail();
+        profileKeyUsed = await detectRole(email);
+      }
+      let [resolvedKey, profileSkillNames] = getProfileSkills(profilesData, profileKeyUsed);
+      profileKeyUsed = resolvedKey;
+      profileSkillNames = validateProfileSkills(profileSkillNames, discoveredNames);
+
+      if (isRepeat) {
+        const diff = computeSkillDiff(allDiscovered, profileSkillNames, enabled, disabled);
+        const [toEnable, toDisable] = skipPrompt
+          ? [diff.newProfile, new Set()]
+          : await promptSkillChanges(diff, allDiscovered, profileSkillNames, false);
+        const finalEnabled = new Set([...diff.keep, ...diff.removedFromProfile, ...toEnable]);
+        for (const n of toDisable) finalEnabled.delete(n);
+        skills = allDiscovered.filter(s => finalEnabled.has(s.name));
+        disabled = new Set([...disabled, ...toDisable].filter(n => !toEnable.has(n) && discoveredNames.has(n)));
+      } else {
+        if (skipPrompt) {
+          skills = allDiscovered.filter(s => profileSkillNames.has(s.name));
+        } else {
+          [skills, profileKeyUsed] = await selectSkillsWithProfile(
+            allDiscovered, profileSkillNames, profileKeyUsed, profilesData);
+        }
+      }
+    }
   }
+
   const resolvedInitial = resolveSkillDependencyClosure(allDiscovered, skills.map(s => s.name));
   requireResolvedDependencies(name, resolvedInitial);
   logAutoEnabledDependencies(resolvedInitial.autoAdded);
   skills = resolvedInitial.skills;
+  for (const dep of resolvedInitial.autoAdded) disabled.delete(dep);
+
   console.log(`Installing ${skills.length} skills, tools: [${tools.join(', ')}]`);
   linkSkills(skills, tools);
-  const credPath = mergeCredentials(repoPath);
-  await ensureIdentity(skipPrompt, defaultIdentity);
   runToolSetup(repoPath, tools);
   runPostInstall(repoPath);
 
-  // Compute disabled_skills from unselected skills
   const selectedNames = new Set(skills.map(s => s.name));
-  const disabledSkills = allDiscovered.filter(s => !selectedNames.has(s.name)).map(s => s.name);
+  const disabledList = profileKeyUsed != null
+    ? [...disabled].sort()
+    : [...discoveredNames].filter(n => !selectedNames.has(n)).sort();
 
   const actualBranch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repoPath, encoding: 'utf8' }).trim();
   const savedRef = actualBranch !== 'HEAD' ? actualBranch : (getOptionValue(cmdArgs, '--ref') || existingRef || 'release');
@@ -256,7 +502,8 @@ if (cmd === 'add') {
     ...(credPath && { credential_path: credPath }),
     version: getVersion(repoPath),
     skills: skills.map(s => s.name),
-    disabled_skills: disabledSkills,
+    disabled_skills: disabledList,
+    profile: profileKeyUsed,
     updated_at: new Date().toISOString()
   };
   manifest.tools = tools;
@@ -292,14 +539,18 @@ if (cmd === 'add') {
 } else if (cmd === 'update') {
   const m = readManifest();
   const tools = parseToolFlag(cmdArgs) || m.tools || detectTools();
-  const skipPrompt = cmdArgs.includes('-y') || cmdArgs.includes('--yes');
+  const skipPrompt = cmdArgs.includes('-y') || cmdArgs.includes('--yes') || cmdArgs.includes('--non-interactive');
   const forceUpdate = cmdArgs.includes('--force') || cmdArgs.includes('-f');
+  const installAllFlag = cmdArgs.includes('--all');
+  const resetFlag = cmdArgs.includes('--reset');
   const identityIdx = cmdArgs.indexOf('--default-identity');
   const defaultIdentity = identityIdx >= 0 ? cmdArgs[identityIdx + 1] : null;
-  const target = cmdArgs.find(a => !a.startsWith('-'));
+  const _consumedUpdateValues = new Set([defaultIdentity, getOptionValue(cmdArgs, '--tool')].filter(Boolean));
+  const target = cmdArgs.find(a => !a.startsWith('-') && !_consumedUpdateValues.has(a));
   const targets = target ? [target] : Object.keys(m.repos);
   const depsEntries = [];
   const updatedRepos = new Set();
+  const processedRepos = new Set();
   for (const name of targets) {
     const repo = m.repos[name];
     if (!repo) { console.error(`Repo "${name}" not found`); continue; }
@@ -307,30 +558,44 @@ if (cmd === 'add') {
     const isCloned = !!repo.url;  // --local installs have no url
     if (isCloned) {
       const prevRev = execSync('git rev-parse HEAD', { cwd: repo.path, encoding: 'utf8' }).trim();
-      const ref = repo.ref || 'release';
+      let ref = repo.ref || 'release';
       if (!repo.ref) repo.ref = ref;  // backfill for pre-v2.0.1 installs
       const current = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repo.path, encoding: 'utf8' }).trim();
       let activeBranch = ref;
       // Try to fetch as tag first; if that fails, treat as branch
       let isTag = false;
+      let updateOk = false;
+      let fetchOk = false;
       try {
         execSync(`git fetch --depth 1 origin "refs/tags/${ref}:refs/tags/${ref}"`, { cwd: repo.path, stdio: 'pipe' });
         isTag = true;
+        fetchOk = true;
       } catch {
         try {
           execSync(`git fetch --depth 1 origin "${ref}"`, { cwd: repo.path, stdio: 'pipe' });
+          fetchOk = true;
         } catch {
           console.log(`  ⚠ Ref "${ref}" not found on remote, staying on ${current}`);
           activeBranch = current;
+          if (current !== 'HEAD') {
+            console.log(`  → Auto-correcting manifest ref: "${ref}" → "${current}"`);
+            repo.ref = current;
+            ref = current;
+            try {
+              execSync(`git fetch --depth 1 origin "${current}"`, { cwd: repo.path, stdio: 'pipe' });
+              fetchOk = true;
+            } catch {}
+          }
         }
       }
-      if (activeBranch === ref) {
+      if (fetchOk && activeBranch === ref) {
         try {
           if (isTag) {
             execSync(`git checkout "tags/${ref}" --detach`, { cwd: repo.path, stdio: 'pipe' });
           } else {
             execSync(`git checkout -B "${ref}" FETCH_HEAD`, { cwd: repo.path, stdio: 'pipe' });
           }
+          updateOk = true;
           if (current !== ref && !(current === 'HEAD' && isTag)) console.log(`  Switched to ${ref}`);
         } catch (e) {
           console.error(`  ⚠ git update failed: ${e.stderr?.toString().trim() || e.message}`);
@@ -338,9 +603,12 @@ if (cmd === 'add') {
       }
       try { execSync('git fetch --tags', { cwd: repo.path, stdio: 'ignore' }); } catch {}
       const newRev = execSync('git rev-parse HEAD', { cwd: repo.path, encoding: 'utf8' }).trim();
-      if (prevRev === newRev && !forceUpdate) {
-        console.log(`  Already up to date (${newRev.slice(0, 7)})`);
-        repo.updated_at = new Date().toISOString();
+      if (prevRev === newRev && !forceUpdate && !installAllFlag && !resetFlag) {
+        if (updateOk) {
+          console.log(`  Already up to date (${newRev.slice(0, 7)})`);
+          repo.updated_at = new Date().toISOString();
+          processedRepos.add(name);
+        }
         continue;
       }
       console.log(`  Updated ${prevRev.slice(0, 7)} → ${newRev.slice(0, 7)}`);
@@ -355,13 +623,12 @@ if (cmd === 'add') {
       console.log(`      "url": "${remoteUrl || '<git-remote-url>'}",`);
       console.log(`    Or: git -C ${repo.path} pull, then re-run ./scripts/install.sh`);
       repo.updated_at = new Date().toISOString();
-      continue;
     }
     const allSkills = discoverSkills(repo.path);
     const saved = repo.skills;
-    const disabled = new Set(repo.disabled_skills || []);
+    let disabled = new Set(repo.disabled_skills || []);
     const discovered = new Set(allSkills.map(s => s.name));
-    // Clean up stale skills (in manifest but no longer on disk — handles renames)
+    // Clean up stale skills (in manifest but no longer on disk)
     if (saved) {
       const stale = saved.filter(n => !discovered.has(n)).map(n => ({ name: n }));
       if (stale.length) {
@@ -369,34 +636,56 @@ if (cmd === 'add') {
         stale.forEach(s => console.log(`  ✕ ${s.name} (removed)`));
       }
     }
-    // Purge disabled entries that no longer exist on disk (deleted/renamed)
-    if (disabled.size) {
-      for (const n of [...disabled]) { if (!discovered.has(n)) disabled.delete(n); }
-    }
+    // Purge disabled entries that no longer exist on disk
+    for (const n of [...disabled]) { if (!discovered.has(n)) disabled.delete(n); }
 
-    // Detect new skills (not previously known — not in saved skills or disabled list)
-    const previouslyKnown = new Set([...(saved || []), ...disabled]);
-    const newSkills = allSkills.filter(s => !previouslyKnown.has(s.name));
+    if (resetFlag) disabled = new Set();
 
-    // Prompt user for new skills
-    const selectedNew = await promptNewSkills(newSkills, skipPrompt);
-    // Use name-based comparison (not object reference) for safety
-    const selectedNewNames = new Set(selectedNew.map(s => s.name));
-    const rejectedNew = newSkills.filter(s => !selectedNewNames.has(s.name));
-
-    // IMPORTANT: disabled must be fully populated (including rejectedNew) BEFORE
-    // the final skills filter runs, otherwise rejected skills leak into enabled list
-    rejectedNew.forEach(s => disabled.add(s.name));
-    repo.disabled_skills = [...disabled].filter(n => discovered.has(n));
+    let skills;
+    if (installAllFlag) {
+      skills = allSkills;
+      repo.profile = null;
+    } else {
+      const profilesData = loadProfiles(repo.path);
+      let profileKey = repo.profile || null;
+
+      if (profilesData && profileKey) {
+        const [resolvedKey, profileSkillNames] = getProfileSkills(profilesData, profileKey);
+        if (resolvedKey !== profileKey) repo.profile = resolvedKey;
+        const validatedProfileSkills = validateProfileSkills(profileSkillNames, discovered);
+
+        const enabledSet = saved ? new Set(saved) : new Set();
+        const diff = computeSkillDiff(allSkills, validatedProfileSkills, enabledSet, disabled);
+        const [toEnable, toDisable] = skipPrompt
+          ? [diff.newProfile, new Set()]
+          : await promptSkillChanges(diff, allSkills, validatedProfileSkills, false);
+
+        const finalEnabled = new Set([...diff.keep, ...diff.removedFromProfile, ...toEnable]);
+        for (const n of toDisable) finalEnabled.delete(n);
+        skills = allSkills.filter(s => finalEnabled.has(s.name));
+        disabled = new Set([...disabled, ...toDisable].filter(n => !toEnable.has(n) && discovered.has(n)));
+      } else {
+        // No profile — legacy: detect new skills, prompt, install all except disabled
+        const previouslyKnown = new Set([...(saved || []), ...disabled]);
+        const newSkills = allSkills.filter(s => !previouslyKnown.has(s.name));
+        const selectedNew = await promptNewSkills(newSkills, skipPrompt);
+        const selectedNewNames = new Set(selectedNew.map(s => s.name));
+        const rejectedNew = newSkills.filter(s => !selectedNewNames.has(s.name));
+        rejectedNew.forEach(s => disabled.add(s.name));
+        skills = allSkills.filter(s => !disabled.has(s.name));
+      }
+    }
 
-    // Link: all non-disabled skills (previously enabled + newly selected)
-    let skills = allSkills.filter(s => !disabled.has(s.name));
     const resolvedUpdate = resolveSkillDependencyClosure(allSkills, skills.map(s => s.name));
     requireResolvedDependencies(name, resolvedUpdate);
     resolvedUpdate.autoAdded.forEach(dep => disabled.delete(dep));
     logAutoEnabledDependencies(resolvedUpdate.autoAdded);
     skills = resolvedUpdate.skills;
-    repo.disabled_skills = [...disabled].filter(n => discovered.has(n) && !skills.some(s => s.name === n));
+    repo.disabled_skills = [...disabled].filter(n => discovered.has(n) && !skills.some(s => s.name === n)).sort();
+    // Unlink previously enabled skills that are now disabled
+    const prevEnabled = new Set(saved || []);
+    const newlyDisabled = [...prevEnabled].filter(n => !skills.some(s => s.name === n));
+    if (newlyDisabled.length) unlinkSkills(newlyDisabled.map(n => ({ name: n })), tools);
     linkSkills(skills, tools);
     const updCredPath = mergeCredentials(repo.path);
     if (updCredPath) {
@@ -426,22 +715,18 @@ if (cmd === 'add') {
     const repo = Object.values(m.repos).find(r => r.path === repoPath);
     warnMissingCredentials(skills, repo?.credential_path || DEFAULT_CRED_PATH, repoPath);
   }
-  // Clean up pending files: remove updated skills, then purge any entries
-  // no longer present in the manifest (renamed/removed skills).
-  const allKnownSkills = new Set(Object.values(m.repos).flatMap(r => r.skills || []));
-  const updatedSkills = new Set(
-    [...updatedRepos].flatMap(name => m.repos[name]?.skills || [])
-  );
-  const cacheDir = join(SRA_HOME, 'update-cache');
-  for (const fname of ['bulk-pending', 'hook-pending']) {
-    const f = join(cacheDir, fname);
-    if (!existsSync(f)) continue;
-    const remaining = readFileSync(f, 'utf8').split('\n')
-      .filter(l => l && !updatedSkills.has(l) && allKnownSkills.has(l));
+  const availableFile = join(SRA_HOME, 'updates', 'available');
+  if (existsSync(availableFile)) {
+    const remaining = readFileSync(availableFile, 'utf8').split('\n')
+      .filter(l => {
+        if (!l.trim()) return false;
+        try { const n = JSON.parse(l).name; return !updatedRepos.has(n) && !processedRepos.has(n); }
+        catch { return false; }
+      });
     if (remaining.length > 0) {
-      writeFileSync(f, remaining.join('\n') + '\n');
+      writeFileSync(availableFile, remaining.join('\n') + '\n');
     } else {
-      unlinkSync(f);
+      unlinkSync(availableFile);
     }
   }
 
@@ -661,10 +946,12 @@ Commands:
   const m = readManifest();
   for (const [name, info] of Object.entries(m.repos)) {
     const allSkills = discoverSkills(info.path);
+    const hasSkillsField = Array.isArray(info.skills);
+    const installed = new Set(info.skills || []);
     const disabled = new Set(info.disabled_skills || []);
     console.log(`${name} (${info.version || 'unknown'}):`);
     allSkills.forEach(s => {
-      const enabled = !disabled.has(s.name);
+      const enabled = hasSkillsField ? installed.has(s.name) : !disabled.has(s.name);
       console.log(`  ${enabled ? '' : '(disabled) '}${s.name}`);
     });
   }
@@ -694,6 +981,8 @@ Commands:
   remove <repo-name>         Unlink skills, remove repo
   update [repo-name]         Git pull, re-link, re-configure (skips if up to date)
                              -f, --force    Force re-link even if no changes
+                             --all          Install all skills (ignores profile)
+                             --reset        Clear disabled_skills, re-apply profile
   manage                     Interactive skill manager (TUI)
   skill add <name...>        Enable skill(s) from an installed repo
   skill remove <name...>     Disable skill(s) (remove symlinks)
@@ -710,5 +999,10 @@ Options:
   --ref <branch|tag>         Git branch or tag (default: release)
   --skills <list>            Comma-separated skills to install (e.g. sra-release,sra-ego-job-submit)
                              Also reads from SRA_SKILLS env var
-  -y, --yes                  Skip interactive selection (install all)`);
+  --skills-file <path>       Install skills listed in file (one per line)
+  --profile <key>            Explicit profile (e.g. rcmd/algo), skip auto-detection
+  --all                      Install all skills (ignores profile)
+  --reset                    Clear disabled_skills and re-run profile selection
+  -y, --yes                  Non-interactive mode, install by profile defaults
+  --non-interactive          Same as -y`);
 }

package/lib.mjs

@@ -818,3 +818,39 @@ export async function promptSkillDeps(entries) {
     console.log(`  To install later: bash "${script}"`);
   }
 }
+
+// --- Profile helpers ---
+
+export function loadProfiles(repoPath) {
+  const p = join(repoPath, 'config', 'profiles.json');
+  if (!existsSync(p)) return null;
+  try {
+    const data = JSON.parse(readFileSync(p, 'utf8'));
+    if (typeof data !== 'object' || !data.profiles) return null;
+    return data;
+  } catch {
+    console.error(`Warning: ${p} is invalid, skipping profiles`);
+    return null;
+  }
+}
+
+export function getProfileSkills(profilesData, profileKey) {
+  if (!profilesData) return [null, null];
+  const core = new Set(profilesData.core || []);
+  const profiles = profilesData.profiles || {};
+  if (profileKey in profiles) {
+    return [profileKey, new Set([...core, ...(profiles[profileKey].skills || [])])];
+  }
+  if ('other' in profiles) {
+    return ['other', new Set([...core, ...(profiles['other'].skills || [])])];
+  }
+  return ['other', core];
+}
+
+export function validateProfileSkills(profileSkillNames, discoveredNames) {
+  const missing = [...profileSkillNames].filter(n => !discoveredNames.has(n));
+  if (missing.length) {
+    console.error(`  Warning: profile references unknown skills: ${missing.sort().join(', ')}`);
+  }
+  return new Set([...profileSkillNames].filter(n => discoveredNames.has(n)));
+}

package/manage.mjs

@@ -3,6 +3,8 @@ import {
   readManifest, writeManifest, discoverSkills, linkSkills, unlinkSkills,
   parseSkillFrontmatter, TOOLS, REPOS_DIR, reportEvent, detectTools,
   getVersion, mergeCredentials, runToolSetup, runPostInstall,
+  loadProfiles, getProfileSkills, validateProfileSkills,
+  resolveSkillDependencyClosure,
 } from './lib.mjs';
 import { spawn } from 'child_process';
 import { existsSync, lstatSync, unlinkSync, rmSync } from 'fs';
@@ -348,12 +350,25 @@ export async function main() {
       const stale = saved.filter(n => !discovered.has(n)).map(n => ({ name: n }));
       if (stale.length) quiet(() => unlinkSkills(stale, tools));
 
-      repo.disabled_skills = [...disabled].filter(n => discovered.has(n));
-
-      // New skills (not in saved or disabled) are auto-enabled in TUI context
-      const previouslyKnown = new Set([...saved, ...(repo.disabled_skills || [])]);
-      const newSkills = allSkills.filter(s => !previouslyKnown.has(s.name));
-      const skills = allSkills.filter(s => !disabled.has(s.name));
+      const savedSet = new Set(saved);
+      let skills;
+      let newSkills;
+      const profilesData = repo.profile ? loadProfiles(repo.path) : null;
+      if (repo.profile && profilesData) {
+        const [, ps] = getProfileSkills(profilesData, repo.profile);
+        const profileSkills = ps ? validateProfileSkills(ps, discovered) : new Set();
+        newSkills = allSkills.filter(s => !savedSet.has(s.name) && !disabled.has(s.name) && profileSkills.has(s.name));
+        const enabledNames = new Set([...saved.filter(n => !disabled.has(n)), ...newSkills.map(s => s.name)]);
+        skills = allSkills.filter(s => enabledNames.has(s.name));
+        const resolved = resolveSkillDependencyClosure(allSkills, skills.map(s => s.name));
+        skills = resolved.skills;
+        for (const dep of resolved.autoAdded) disabled.delete(dep);
+      } else {
+        const previouslyKnown = new Set([...saved, ...(repo.disabled_skills || [])]);
+        newSkills = allSkills.filter(s => !previouslyKnown.has(s.name));
+        skills = allSkills.filter(s => !disabled.has(s.name));
+      }
+      repo.disabled_skills = [...disabled].filter(n => discovered.has(n) && !skills.some(s => s.name === n));
       quiet(() => {
         linkSkills(skills, tools);
         mergeCredentials(repo.path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sra-skills",
-  "version": "0.14.13",
+  "version": "0.16.0",
   "description": "SRA agent skills installer — manage AI skill repos",
   "bin": {
     "sra": "index.mjs",