@shomra/agent 0.3.28 → 0.3.30

package/src/inventory/artifacts/extensions.mjs

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readText } from './file-read.mjs';
+import { HOME } from './limits.mjs';
+
+const MAX_SOURCE_FILES = 20;
+const MAX_SOURCE_BYTES = 200_000;
+const MAX_WALK_DEPTH = 4;
+const CODE_RE = /\.(?:[cm]?js|jsx|ts|tsx|py|pyw)$/i;
+const SKIP_DIRS = new Set(['node_modules', '.venv', 'venv', 'site-packages', '__pycache__', 'dist-packages', '.git']);
+
+export const EXTENSIONS_DIR_NAME = 'Claude Extensions';
+
+export function claudeDesktopDataDir(platform = process.platform) {
+  if (platform === 'darwin') return path.join(HOME, 'Library', 'Application Support', 'Claude');
+  if (platform === 'win32') return path.join(process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming'), 'Claude');
+  return path.join(HOME, '.config', 'Claude');
+}
+
+export const EXTENSION_MANIFEST_RE = /^claude extensions\/[^/]+\/manifest\.json$/i;
+
+function inside(root, target) {
+  const rel = path.relative(root, target);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function realInside(root, target) {
+  try { return inside(fs.realpathSync(root), fs.realpathSync(target)); } catch { return false; }
+}
+
+function sourceFiles(dir, depth = 0, out = []) {
+  if (depth > MAX_WALK_DEPTH || out.length >= MAX_SOURCE_FILES * 3) return out;
+  let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) sourceFiles(full, depth + 1, out); }
+    else if (e.isFile() && CODE_RE.test(e.name)) out.push(full);
+  }
+  return out;
+}
+
+export function bundleExtensionSource(artifact, absManifest, toRel, budget, capped) {
+  const root = path.dirname(absManifest);
+  let doc = null;
+  try { doc = JSON.parse(artifact.content); } catch { return; }
+  const entry = typeof doc?.server?.entry_point === 'string' ? doc.server.entry_point.replace(/^\$\{__dirname\}[\\/]?/, '') : null;
+  const entryAbs = entry ? path.resolve(root, entry) : null;
+  const candidates = [
+    ...(entryAbs && inside(root, entryAbs) ? [entryAbs] : []),
+    ...sourceFiles(root).filter((f) => f !== entryAbs),
+  ];
+  for (const abs of candidates) {
+    if (artifact.files.length >= MAX_SOURCE_FILES) { capped.push({ reason: 'bundle-cap', path: artifact.path }); break; }
+    if (!realInside(root, abs)) continue;
+    const read = readText(abs, MAX_SOURCE_BYTES);
+    if (!read || read.truncated) continue;
+    if (Buffer.byteLength(read.text) > budget.bytes) { capped.push({ reason: 'byte-budget', path: toRel(abs) }); continue; }
+    budget.bytes -= Buffer.byteLength(read.text);
+    artifact.files.push({ path: toRel(abs), content: read.text, binary: false });
+  }
+  artifact.metadata.bundledCount = artifact.files.length;
+
+  const id = path.basename(root);
+  try {
+    const dataDir = path.dirname(path.dirname(root));
+    const settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'Claude Extensions Settings', `${id}.json`), 'utf8'));
+    if (settings?.isEnabled === false) artifact.metadata.activation = 'disabled';
+  } catch {  }
+}

package/src/inventory/artifacts/hook-scripts.mjs

@@ -0,0 +1,128 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { loadConfig } from '../../core/config.mjs';
+import { redactLocally } from '../../detect/local-redact.mjs';
+import { readText } from './file-read.mjs';
+import { HOME, MAX_BUNDLED } from './limits.mjs';
+
+export const HOOK_SCRIPT_MODES = ['full', 'hash', 'off'];
+
+const SCRIPT_EXT = /\.(?:sh|bash|zsh|ps1|psm1|bat|cmd|py|js|mjs|cjs|ts|rb|pl|php|lua)$/i;
+const SECRET_PATH = /(?:^|[\\/])(?:\.env|\.ssh|\.aws|\.gnupg|\.netrc|\.npmrc|\.kube|\.docker)(?:[\\/]|$)|id_(?:rsa|dsa|ecdsa|ed25519)|secret|credential|password|\.pem$|\.key$/i;
+const COMMAND_KEYS = new Set(['command', 'bash', 'sh', 'powershell', 'pwsh', 'windows', 'linux', 'osx']);
+const EXTS = 'sh|bash|zsh|ps1|psm1|bat|cmd|py|js|mjs|cjs|ts|rb|pl|php|lua';
+const REF_RE = new RegExp(`(?:^|["'\\s=;&|(\`])((?:\\$\\{?[A-Za-z_]\\w*\\}?|%[A-Za-z_]\\w*%|~|[A-Za-z]:)?[\\\\/]?(?:[\\w.@-]+[\\\\/])*[\\w.@-]+\\.(?:${EXTS}))(?=["'\\s;|&)\`]|$)`, 'g');
+const QUOTED_REF_RE = new RegExp(`(["'])((?:\\$\\{?[A-Za-z_]\\w*\\}?|%[A-Za-z_]\\w*%|~|[A-Za-z]:)?[^"'\\n]*[\\\\/][^"'\\n]*?\\.(?:${EXTS}))\\1`, 'g');
+const SHOMRA_GUARD_RE = /(?:^|[\\/])(?:shomra(?:-agent)?\.m?js|@shomra[\\/]agent[\\/].*)$/i;
+const MAX_REFS = 40;
+
+export function hookScriptMode(env = process.env, cfg = null) {
+  const raw = String(env.SHOMRA_HOOK_SCRIPTS ?? (cfg ?? safeConfig()).hookScripts ?? 'full').trim().toLowerCase();
+  return HOOK_SCRIPT_MODES.includes(raw) ? raw : 'full';
+}
+
+function safeConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return {};
+  }
+}
+
+export function hookCommands(canonical) {
+  let doc;
+  try {
+    doc = JSON.parse(canonical);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const walk = (n, depth) => {
+    if (!n || depth > 12 || out.length > 200) return;
+    if (Array.isArray(n)) return n.forEach((v) => walk(v, depth + 1));
+    if (typeof n !== 'object') return;
+    for (const [k, v] of Object.entries(n)) {
+      if (COMMAND_KEYS.has(k) && typeof v === 'string') out.push(v);
+      else walk(v, depth + 1);
+    }
+  };
+  walk(doc?.hooks, 0);
+  return out;
+}
+
+export function scriptRefs(command) {
+  const out = new Set();
+  const cmd = String(command).replace(/(["'])(\$\{?[A-Za-z_]\w*\}?|%[A-Za-z_]\w*%)\1(?=[\\/])/g, '$2');
+  for (const m of cmd.matchAll(QUOTED_REF_RE)) if (out.size < MAX_REFS) out.add(m[2].trim());
+  const unquoted = cmd.replace(QUOTED_REF_RE, ' ');
+  for (const m of unquoted.matchAll(REF_RE)) {
+    if (out.size >= MAX_REFS) break;
+    out.add(m[1].trim());
+  }
+  return [...out];
+}
+
+export function pluginRootOf(hookFile) {
+  const norm = hookFile.replace(/\\/g, '/');
+  if (/\/hooks\/hooks\.json$/i.test(norm)) return path.dirname(path.dirname(hookFile));
+  if (/\/\.claude-plugin\/plugin\.json$/i.test(norm)) return path.dirname(path.dirname(hookFile));
+  return path.dirname(hookFile);
+}
+
+export function resolveRef(ref, { hookFile, projectDir }) {
+  const m = /^(\$\{?([A-Za-z_]\w*)\}?|%([A-Za-z_]\w*)%|~)([\\/].*)$/.exec(ref);
+  if (m) {
+    const name = (m[2] ?? m[3] ?? '').toUpperCase();
+    const rest = m[4].replace(/^[\\/]/, '');
+    const base =
+      m[1] === '~' || name === 'HOME' || name === 'USERPROFILE' ? HOME
+        : name === 'CLAUDE_PLUGIN_ROOT' || name === 'EXTENSIONPATH' ? pluginRootOf(hookFile)
+          : /^(?:CLAUDE|GEMINI|CURSOR|QWEN)_PROJECT_DIR$|^PWD$/.test(name) ? projectDir
+            : null;
+    return base ? [path.join(base, rest)] : [];
+  }
+  if (path.isAbsolute(ref) || /^[A-Za-z]:[\\/]/.test(ref)) return [ref];
+  return [...new Set([path.resolve(projectDir, ref), path.resolve(path.dirname(hookFile), ref)])];
+}
+
+const sha256 = (s) => crypto.createHash('sha256').update(s).digest('hex');
+
+export function bundleHookScripts(artifact, hookFile, { projectDir, relPath, budget, capped, mode = hookScriptMode() }) {
+  if (mode === 'off') return;
+  const refs = [...new Set(hookCommands(artifact.content).flatMap(scriptRefs))].filter((r) => SCRIPT_EXT.test(r));
+  const scripts = [];
+  for (const ref of refs) {
+    if (SECRET_PATH.test(ref)) continue;
+    if (SHOMRA_GUARD_RE.test(ref)) {
+      scripts.push({ ref, state: 'shomra-guard' });
+      continue;
+    }
+    if (artifact.files.length >= MAX_BUNDLED) {
+      capped.push({ reason: 'bundle-cap', path: artifact.path });
+      break;
+    }
+    const target = resolveRef(ref, { hookFile, projectDir }).find((p) => readText(p) != null);
+    if (!target || SECRET_PATH.test(target)) {
+      scripts.push({ ref, state: 'missing' });
+      continue;
+    }
+    const read = readText(target);
+    const digest = sha256(read.text);
+    const wirePath = relPath(target) ?? ref.replace(/^(?:\$\{?\w+\}?|%\w+%|~)?[\\/]*/, '').replace(/\\/g, '/');
+    if (mode === 'hash') {
+      artifact.files.push({ path: wirePath, content: null, binary: false, sha256: digest, withheld: true });
+      scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'withheld' });
+      continue;
+    }
+    if (read.bytes > budget.bytes) {
+      capped.push({ reason: 'byte-budget', path: wirePath });
+      scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'over-budget' });
+      continue;
+    }
+    const masked = redactLocally(read.text, { categories: ['secret'] });
+    budget.bytes -= Buffer.byteLength(masked.text);
+    artifact.files.push({ path: wirePath, content: masked.text, binary: false, sha256: digest, ...(read.truncated ? { truncated: true } : {}) });
+    scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'sent', maskedSecrets: masked.masked.length });
+  }
+  if (refs.length) artifact.metadata.hookScripts = { mode, scripts: scripts.slice(0, MAX_BUNDLED) };
+}

package/src/inventory/artifacts/limits.mjs

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 export const HOME = os.homedir();
 
-export const ARTIFACT_KINDS = ['skill', 'command', 'subagent', 'hook'];
+export const ARTIFACT_KINDS = ['skill', 'command', 'subagent', 'hook', 'rules', 'plugin', 'extension'];
 
 export const MAX_DEPTH = 6;
 

package/src/inventory/artifacts/plugins.mjs

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJsonAt, readText, stripJsonComments } from './file-read.mjs';
+import { canonicalHooks } from './hooks.mjs';
+import { HOME } from './limits.mjs';
+
+export { PLUGIN_MANIFEST_RE } from '../../detect/signals/manifests.mjs';
+export const MARKETPLACE_ROOT_RE = /(^|\/)plugins\/marketplaces\/[^/]+\/\.claude-plugin\/marketplace\.json$/i;
+export const MAX_MANIFEST_BYTES = 200_000;
+
+const MAX_COMPONENT_FILES = 12;
+const MAX_BIN_NAMES = 40;
+
+export function pluginRootOf(absManifest) {
+  const dir = path.dirname(absManifest);
+  const base = path.basename(dir).toLowerCase();
+  if (/^\.(claude|codex|cursor|copilot|github)-plugin$|^\.plugin$/.test(base)) return path.dirname(dir);
+  if (base === 'plugin' && path.basename(path.dirname(dir)).toLowerCase() === '.github') return path.dirname(path.dirname(dir));
+  if (base === 'plugins' && path.basename(path.dirname(dir)).toLowerCase() === '.agents') return path.dirname(path.dirname(dir));
+  return dir;
+}
+
+export function manifestName(text, fallback) {
+  try {
+    const doc = JSON.parse(stripJsonComments(text));
+    const n = doc?.name ?? doc?.id;
+    if (typeof n === 'string' && n.trim()) return n.trim().slice(0, 200);
+  } catch {  }
+  return fallback;
+}
+
+function inside(root, target) {
+  const rel = path.relative(root, target);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function insideReal(root, target) {
+  try {
+    return inside(fs.realpathSync(root), fs.realpathSync(target));
+  } catch {
+    return false;
+  }
+}
+
+function declaredComponentPaths(text) {
+  let doc;
+  try { doc = JSON.parse(stripJsonComments(text)); } catch { return []; }
+  const out = [];
+  for (const key of ['hooks', 'mcpServers', 'lspServers', 'monitors']) {
+    const v = doc?.[key];
+    for (const p of typeof v === 'string' ? [v] : Array.isArray(v) ? v : []) {
+      if (typeof p === 'string' && p.trim()) out.push(p.trim().replace(/^\$\{?(?:CLAUDE_PLUGIN_ROOT|PLUGIN_ROOT)\}?\/?/, './'));
+    }
+  }
+  return out;
+}
+
+export function bundlePluginComponents(artifact, absManifest, toRel, budget, capped) {
+  const root = pluginRootOf(absManifest);
+  const wanted = new Set(['hooks/hooks.json', '.mcp.json', 'mcp.json', '.lsp.json', 'monitors/monitors.json']);
+  for (const p of declaredComponentPaths(artifact.content)) wanted.add(p.replace(/^\.\//, ''));
+
+  for (const rel of wanted) {
+    if (artifact.files.length >= MAX_COMPONENT_FILES) { capped.push({ reason: 'bundle-cap', path: artifact.path }); break; }
+    const abs = path.resolve(root, rel);
+    if (!inside(root, abs) || !/\.json$/i.test(abs) || !insideReal(root, abs)) continue;
+    const read = readText(abs, MAX_MANIFEST_BYTES);
+    if (!read || read.truncated) continue;
+    const content = /hooks[^/\\]*\.json$/i.test(abs) ? canonicalHooks(read.text) : read.text;
+    if (!content) continue;
+    if (Buffer.byteLength(content) > budget.bytes) { capped.push({ reason: 'byte-budget', path: toRel(abs) }); continue; }
+    budget.bytes -= Buffer.byteLength(content);
+    artifact.files.push({ path: toRel(abs), content, binary: false });
+  }
+
+  let bin = [];
+  try { bin = fs.readdirSync(path.join(root, 'bin'), { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name); } catch {  }
+  for (const name of bin.slice(0, MAX_BIN_NAMES)) artifact.files.push({ path: toRel(path.join(root, 'bin', name)), content: null, binary: true });
+
+  artifact.metadata.bundledCount = artifact.files.length;
+}
+
+export function installedPluginManifests(claudeDir) {
+  const doc = readJsonAt(path.join(claudeDir, 'plugins', 'installed_plugins.json'));
+  if (!doc || typeof doc !== 'object') return [];
+  const out = [];
+  const seen = new Set();
+  for (const [key, value] of Object.entries(doc.plugins ?? {})) {
+    const records = Array.isArray(value) ? value : [value];
+    for (const r of records) {
+      const installPath = typeof r?.installPath === 'string' ? r.installPath : null;
+      if (!installPath) continue;
+      const abs = path.resolve(installPath);
+      if (!inside(HOME, abs)) continue;
+      for (const candidate of [path.join(abs, '.claude-plugin', 'plugin.json'), path.join(abs, 'plugin.json')]) {
+        if (seen.has(candidate) || !fs.existsSync(candidate) || !insideReal(HOME, candidate)) continue;
+        seen.add(candidate);
+        const at = key.indexOf('@');
+        out.push({ manifest: candidate, marketplace: at > -1 ? key.slice(at + 1) : null });
+        break;
+      }
+    }
+  }
+  return out;
+}

package/src/inventory/artifacts/roots.mjs

@@ -1,8 +1,45 @@
 import path from 'node:path';
 import { HOME } from './limits.mjs';
+import { EXTENSIONS_DIR_NAME, claudeDesktopDataDir } from './extensions.mjs';
+
+const PLAT = process.platform;
+const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+const XDG = PLAT === 'win32' ? APPDATA : path.join(HOME, '.config');
+const CLAUDE_MANAGED = PLAT === 'win32' ? 'C:\\Program Files\\ClaudeCode' : PLAT === 'darwin' ? '/Library/Application Support/ClaudeCode' : '/etc/claude-code';
+
+export function rulesRoots() {
+  return [
+    { vendor: 'claude-code', scope: 'user', dir: CLAUDE_MANAGED, managed: true },
+    { vendor: 'qwen-code', scope: 'user', dir: path.join(HOME, '.qwen') },
+    { vendor: 'roo', scope: 'user', dir: path.join(HOME, '.roo') },
+    { vendor: 'kiro', scope: 'user', dir: path.join(HOME, '.kiro') },
+    { vendor: 'augment', scope: 'user', dir: path.join(HOME, '.augment') },
+    { vendor: 'junie', scope: 'user', dir: path.join(HOME, '.junie') },
+    { vendor: 'cline', scope: 'user', dir: path.join(HOME, 'Documents', 'Cline') },
+    { vendor: 'zed', scope: 'user', dir: path.join(XDG, PLAT === 'win32' ? 'Zed' : 'zed') },
+    { vendor: 'goose', scope: 'user', dir: PLAT === 'win32' ? path.join(APPDATA, 'Block', 'goose', 'config') : path.join(HOME, '.config', 'goose') },
+    { vendor: 'amp', scope: 'user', dir: path.join(HOME, '.config', 'amp') },
+    { vendor: 'opencode', scope: 'user', dir: path.join(HOME, '.config', 'opencode') },
+    { vendor: 'agents-md', scope: 'user', dir: path.join(HOME, '.agents') },
+    { vendor: 'continue', scope: 'user', dir: path.join(HOME, '.continue') },
+  ];
+}
+
+export function projectVendorRoots(cwd = process.cwd()) {
+  return [
+    { vendor: 'roo', scope: 'project', dir: path.join(cwd, '.roo') },
+    { vendor: 'qwen-code', scope: 'project', dir: path.join(cwd, '.qwen') },
+    { vendor: 'kiro', scope: 'project', dir: path.join(cwd, '.kiro') },
+    { vendor: 'cline', scope: 'project', dir: path.join(cwd, '.clinerules') },
+    { vendor: 'continue', scope: 'project', dir: path.join(cwd, '.continue') },
+    { vendor: 'agents-md', scope: 'project', dir: path.join(cwd, '.agents') },
+  ];
+}
 
 export function artifactRoots(cwd = process.cwd()) {
   return [
+    ...rulesRoots(),
+    ...projectVendorRoots(cwd),
     { vendor: 'claude-code', scope: 'user', dir: path.join(HOME, '.claude') },
     { vendor: 'claude-code', scope: 'project', dir: path.join(cwd, '.claude') },
     { vendor: 'cursor', scope: 'user', dir: path.join(HOME, '.cursor') },
@@ -11,10 +48,13 @@ export function artifactRoots(cwd = process.cwd()) {
     { vendor: 'codex', scope: 'project', dir: path.join(cwd, '.codex') },
     { vendor: 'gemini', scope: 'user', dir: path.join(HOME, '.gemini') },
     { vendor: 'gemini', scope: 'project', dir: path.join(cwd, '.gemini') },
+    { vendor: 'windsurf', scope: 'user', dir: path.join(HOME, '.codeium', 'windsurf') },
     { vendor: 'windsurf', scope: 'project', dir: path.join(cwd, '.windsurf') },
     { vendor: 'opencode', scope: 'user', dir: path.join(HOME, '.opencode') },
     { vendor: 'opencode', scope: 'project', dir: path.join(cwd, '.opencode') },
 
+    { vendor: 'copilot', scope: 'user', dir: path.join(HOME, '.copilot') },
     { vendor: 'copilot', scope: 'project', dir: path.join(cwd, '.github') },
+    { vendor: 'claude-desktop', scope: 'user', dir: path.join(claudeDesktopDataDir(), EXTENSIONS_DIR_NAME) },
   ];
 }

package/src/inventory/discovery/ai-dependencies.mjs

@@ -67,11 +67,35 @@ export const VECTOR_ENV = {
   CHROMA_HOST: { engine: 'chroma', kind: 'endpoint' },
 };
 
+export const MAX_SPECS = 8;
+
+const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const uncommented = (text) =>
+  text
+    .split(/\r?\n/)
+    .map((l) => l.replace(/(^|[ \t])#[^\n]*$/, '$1'))
+    .join('\n');
+
+
+export function pySpecFor(text, pkg) {
+  const body = uncommented(text);
+  const name = escRe(pkg).replace(/[-_]/g, '[-_]');
+  const req = body.match(new RegExp(`(^|[^a-z0-9_.-])${name}\\s*(?:\\[[^\\]]*\\])?\\s*(===?|~=|>=|<=|!=|>|<)\\s*([\\w.*+!-]+)`, 'im'));
+  if (req) return `${req[2]}${req[3]}`;
+
+  const toml = body.match(new RegExp(`(^|\\n)\\s*["\']?${name}["\']?\\s*=\\s*(?:["\']([^"\']+)["\']|\\{[^}\\n]*version\\s*=\\s*["\']([^"\']+)["\'])`, 'i'));
+  const val = toml?.[2] ?? toml?.[3];
+  return val && val !== '*' ? val : null;
+}
+
 function npmAiDeps(pkg) {
   const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}), ...(pkg.peerDependencies || {}), ...(pkg.optionalDependencies || {}) };
   const hits = [];
-  for (const name of Object.keys(deps)) {
-    if (NPM_AI.has(name) || NPM_AI_PREFIX.some((p) => name.startsWith(p))) hits.push(name);
+  for (const [name, spec] of Object.entries(deps)) {
+    if (NPM_AI.has(name) || NPM_AI_PREFIX.some((p) => name.startsWith(p))) {
+      hits.push({ name, spec: typeof spec === 'string' ? spec : null });
+    }
   }
   return hits;
 }
@@ -79,8 +103,8 @@ function npmAiDeps(pkg) {
 function pyAiDeps(text) {
   const hits = [];
   for (const pkg of PY_AI) {
-    const re = new RegExp(`(^|[^a-z0-9_.-])${pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9_.-]|$)`, 'im');
-    if (re.test(text)) hits.push(pkg);
+    const re = new RegExp(`(^|[^a-z0-9_.-])${escRe(pkg)}([^a-z0-9_.-]|$)`, 'im');
+    if (re.test(text)) hits.push({ name: pkg, spec: pySpecFor(text, pkg) });
   }
   return hits;
 }
@@ -88,10 +112,12 @@ function pyAiDeps(text) {
 export function discoverAiDependencies(roots = [process.cwd()], files = null) {
   const walk = files || walkWorkspace(roots);
   const byPkg = new Map();
-  const add = (eco, pkg, manifest) => {
+  const add = (eco, pkg, manifest, spec) => {
     const key = `${eco}:${pkg}`;
-    if (!byPkg.has(key)) byPkg.set(key, { pkg, eco, manifests: new Set() });
-    byPkg.get(key).manifests.add(manifest);
+    if (!byPkg.has(key)) byPkg.set(key, { pkg, eco, manifests: new Set(), specs: new Set() });
+    const row = byPkg.get(key);
+    row.manifests.add(manifest);
+    if (spec) row.specs.add(spec);
   };
   for (const { file } of walk.manifests) {
     const base = path.basename(file);
@@ -99,18 +125,18 @@ export function discoverAiDependencies(roots = [process.cwd()], files = null) {
       const json = readJson(file);
       if (!json) continue;
 
-      for (const pkg of npmAiDeps(json)) if (!isVectorLib(pkg)) add('npm', pkg, file);
+      for (const hit of npmAiDeps(json)) if (!isVectorLib(hit.name)) add('npm', hit.name, file, hit.spec);
     } else {
       const text = readText(file, 100_000);
       if (text == null) continue;
-      for (const pkg of pyAiDeps(text)) if (!isVectorLib(pkg)) add('pip', pkg, file);
+      for (const hit of pyAiDeps(text)) if (!isVectorLib(hit.name)) add('pip', hit.name, file, hit.spec);
     }
   }
   const assets = [];
-  for (const { pkg, eco, manifests } of byPkg.values()) {
+  for (const { pkg, eco, manifests, specs } of byPkg.values()) {
     const list = [...manifests];
     assets.push({
-      type: 'AI_TOOL',
+      type: 'AI_LIBRARY',
       name: `${pkg} (${eco})`,
       identifier: `dep:${eco}:${pkg}`,
       vendor: 'ai-sdk',
@@ -118,6 +144,7 @@ export function discoverAiDependencies(roots = [process.cwd()], files = null) {
         category: 'dependency',
         ecosystem: eco,
         package: pkg,
+        specs: [...specs].slice(0, MAX_SPECS),
         usedInProjects: list.length,
         manifests: list.slice(0, 10),
       },
@@ -139,7 +166,7 @@ export function discoverAiUsageInCode(roots = [process.cwd()], files = null) {
   for (const row of rollupAiUsage(usages)) {
     const site = row.firstSite;
     assets.push({
-      type: 'AI_TOOL',
+      type: 'AI_LIBRARY',
       name: `${row.label} (in code)`,
       identifier: `ai-usage:${row.provider}`,
       vendor: 'ai-sdk',

package/src/inventory/discovery/all.mjs

@@ -1,6 +1,7 @@
 import { clampAsset } from '../../core/wire-limits.mjs';
 import { discoverAiDependencies, discoverAiUsageInCode } from './ai-dependencies.mjs';
 import { discoverAiTools } from './ai-tools.mjs';
+import { discoverCloudClis } from './cloud-clis.mjs';
 import { discoverCodingAgents } from './coding-agents.mjs';
 import { discoverMcpClients } from './mcp-clients.mjs';
 import { discoverMcpServers } from './mcp-servers.mjs';
@@ -24,6 +25,9 @@ export function discoverAll(roots = [process.cwd()], opts = {}) {
     ...discoverAiTools(),
     ...discoverCodingAgents(scanRoots),
     ...discoverModelKeys(),
+    // ⚠ What this HOST is logged into - the reach an agent with a shell
+    // inherits and no agent policy granted. See `cloud-clis.mjs`.
+    ...discoverCloudClis(),
   ];
 
   const clamped = all.map(clampAsset);