@shomra/agent 0.3.28 → 0.3.30

package/src/inventory/agent-posture.mjs

@@ -2,6 +2,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { emptyGrant, extractGrant, grantIsEmpty, parseLooseToml, parseLooseYaml, stripJsonc } from './grant-extract.mjs';
+import { readMcpServers } from '../detect/signals/mcp-config.mjs';
+import { CURSOR_APP_USER_KEY, INTERPRETERS, readStateKeys } from './vscode-state.mjs';
+import { projectRoots } from './project-roots.mjs';
 
 const HOME = os.homedir();
 const PLAT = process.platform;
@@ -15,14 +19,17 @@ export const TIER_MEANING = {
   none: 'No machine-readable permission surface. This agent appears in inventory only.',
 };
 
-function readJsonc(file) {
+function readJsonc(file, maxBytes = MAX_SETTINGS_BYTES) {
   try {
     const st = fs.statSync(file);
-    if (!st.isFile() || st.size > MAX_SETTINGS_BYTES) return { state: 'unreadable', reason: st.isFile() ? 'oversized' : 'not-a-file' };
+    if (!st.isFile() || st.size > maxBytes) return { state: 'unreadable', reason: st.isFile() ? 'oversized' : 'not-a-file' };
     const raw = fs.readFileSync(file, 'utf8');
+    if (/\.(?:toml|ya?ml)$/i.test(file)) {
+      const doc = /\.toml$/i.test(file) ? parseLooseToml(raw) : parseLooseYaml(raw);
+      return doc ? { state: 'read', json: doc } : { state: 'unreadable', reason: 'parse-failed' };
+    }
 
-    const stripped = raw.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:"])\/\/.*$/gm, '$1');
-    return { state: 'read', json: JSON.parse(stripped) };
+    return { state: 'read', json: JSON.parse(stripJsonc(raw)) };
   } catch (err) {
     if (err && err.code === 'ENOENT') return { state: 'absent' };
 
@@ -30,6 +37,10 @@ function readJsonc(file) {
   }
 }
 
+const COPILOT_KEYS = ['chat.', 'github.copilot'];
+
+const EDITOR_APPS = ['Code', 'Code - Insiders', 'Cursor', 'Windsurf'];
+
 export const VENDOR_POSTURE = {
   'claude-code': {
     tier: 'declared',
@@ -40,6 +51,8 @@ export const VENDOR_POSTURE = {
       { rel: ['.claude', 'settings.local.json'], base: 'home', scope: 'user' },
       { rel: ['.claude', 'settings.json'], base: 'cwd', scope: 'project' },
       { rel: ['.claude', 'settings.local.json'], base: 'cwd', scope: 'project' },
+      { rel: ['managed-settings.json'], base: 'claude-managed', scope: 'managed' },
+      { rel: ['managed-settings.d'], base: 'claude-managed', scope: 'managed', dir: '.json' },
     ],
   },
   gemini: {
@@ -48,22 +61,43 @@ export const VENDOR_POSTURE = {
     sources: [
       { rel: ['.gemini', 'settings.json'], base: 'home', scope: 'user' },
       { rel: ['.gemini', 'settings.json'], base: 'cwd', scope: 'project' },
+      { rel: ['.gemini', 'policies'], base: 'home', scope: 'user', dir: '.toml' },
+      { rel: ['settings.json'], base: 'gemini-system', scope: 'managed' },
+      { rel: ['system-defaults.json'], base: 'gemini-system', scope: 'managed' },
+    ],
+  },
+  'qwen-code': {
+    tier: 'declared',
+    label: 'Qwen Code',
+    sources: [
+      { rel: ['.qwen', 'settings.json'], base: 'home', scope: 'user' },
+      { rel: ['.qwen', 'settings.json'], base: 'cwd', scope: 'project' },
+      { rel: ['settings.json'], base: 'qwen-system', scope: 'managed' },
     ],
   },
   codex: {
     tier: 'declared',
     label: 'OpenAI Codex CLI',
     sources: [
+      { rel: ['.codex', 'config.toml'], base: 'home', scope: 'user' },
+      { rel: ['.codex', 'config.toml'], base: 'cwd', scope: 'project' },
       { rel: ['.codex', 'config.json'], base: 'home', scope: 'user' },
       { rel: ['.codex', 'settings.json'], base: 'home', scope: 'user' },
     ],
   },
   cursor: {
-    tier: 'flag',
+    tier: 'declared',
     label: 'Cursor',
     sources: [
+      { stateDb: 'Cursor', dbKeys: [CURSOR_APP_USER_KEY], interpret: 'cursor', scope: 'user' },
+      { rel: ['.cursor', 'cli-config.json'], base: 'home', scope: 'user' },
+      { rel: ['.cursor', 'permissions.json'], base: 'home', scope: 'user' },
+      { rel: ['.cursor', 'sandbox.json'], base: 'home', scope: 'user' },
       { rel: ['.cursor', 'settings.json'], base: 'home', scope: 'user' },
       { rel: ['.cursor', 'mcp.json'], base: 'home', scope: 'user' },
+      { rel: ['.cursor', 'cli.json'], base: 'cwd', scope: 'project' },
+      { rel: ['.cursor', 'permissions.json'], base: 'cwd', scope: 'project' },
+      { rel: ['.cursor', 'sandbox.json'], base: 'cwd', scope: 'project' },
       { rel: ['.cursor', 'mcp.json'], base: 'cwd', scope: 'project' },
       { rel: ['.cursor', 'settings.json'], base: 'cwd', scope: 'project' },
       { rel: ['User', 'settings.json'], base: 'cursor-user', scope: 'user' },
@@ -76,31 +110,113 @@ export const VENDOR_POSTURE = {
       { rel: ['.codeium', 'windsurf', 'settings.json'], base: 'home', scope: 'user' },
       { rel: ['.codeium', 'windsurf', 'mcp_config.json'], base: 'home', scope: 'user' },
       { rel: ['.windsurf', 'mcp.json'], base: 'cwd', scope: 'project' },
+      { rel: ['settings.json'], base: 'windsurf-user', scope: 'user', keys: ['windsurf.', 'cascade'] },
+      { stateDb: 'Windsurf', dbKeys: ['windsurf%', 'codeium%'], interpret: 'windsurf', scope: 'user' },
     ],
   },
   cline: {
-    tier: 'flag',
+    tier: 'declared',
     label: 'Cline',
     sources: [
       { rel: ['settings', 'cline_mcp_settings.json'], base: 'cline-storage', scope: 'user' },
       { rel: ['.cline', 'settings.json'], base: 'home', scope: 'user' },
+      { rel: ['.cline', 'data', 'globalState.json'], base: 'home', scope: 'user', interpret: 'cline', maxBytes: 8 * 1024 * 1024 },
+      { rel: ['settings.json'], base: 'vscode-user', scope: 'user', keys: ['cline.'] },
+      ...EDITOR_APPS.map((app) => ({ stateDb: app, dbKeys: ['saoudrizwan.claude-dev'], interpret: 'cline', scope: 'user' })),
     ],
   },
   roo: {
-    tier: 'flag',
+    tier: 'declared',
     label: 'Roo Code',
     sources: [
       { rel: ['settings', 'mcp_settings.json'], base: 'roo-storage', scope: 'user' },
       { rel: ['.roo', 'settings.json'], base: 'cwd', scope: 'project' },
+      { rel: ['settings.json'], base: 'vscode-user', scope: 'user', keys: ['roo-cline.'] },
+      ...EDITOR_APPS.map((app) => ({ stateDb: app, dbKeys: ['rooveterinaryinc.roo-cline'], interpret: 'roo', scope: 'user' })),
     ],
   },
   copilot: {
     tier: 'flag',
-    label: 'GitHub Copilot CLI',
-    sources: [{ rel: ['.copilot', 'config.json'], base: 'home', scope: 'user' }],
+    label: 'GitHub Copilot',
+    sources: [
+      { rel: ['.copilot', 'config.json'], base: 'home', scope: 'user' },
+      { rel: ['.copilot', 'settings.json'], base: 'home', scope: 'user' },
+      { rel: ['settings.json'], base: 'vscode-user', scope: 'user', keys: COPILOT_KEYS },
+      { rel: ['settings.json'], base: 'vscode-insiders-user', scope: 'user', keys: COPILOT_KEYS },
+      { rel: ['.vscode', 'settings.json'], base: 'cwd', scope: 'project', keys: COPILOT_KEYS },
+      { rel: ['.github', 'copilot', 'settings.json'], base: 'cwd', scope: 'project' },
+      { rel: ['.github', 'copilot', 'settings.local.json'], base: 'cwd', scope: 'project' },
+    ],
+  },
+  kiro: {
+    tier: 'declared',
+    label: 'Kiro',
+    sources: [
+      { rel: ['.kiro', 'settings', 'permissions.yaml'], base: 'home', scope: 'user' },
+      { rel: ['.kiro', 'agents'], base: 'home', scope: 'user', dir: '.json' },
+      { rel: ['.kiro', 'agents'], base: 'cwd', scope: 'project', dir: '.json' },
+      { rel: ['.kiro', 'settings'], base: 'home', scope: 'user', dir: '.json' },
+      { rel: ['.kiro', 'settings'], base: 'cwd', scope: 'project', dir: '.json' },
+      { rel: ['settings.json'], base: 'vscode-user', scope: 'user', keys: ['kiroAgent.'] },
+      { rel: ['.aws', 'amazonq', 'cli-agents'], base: 'home', scope: 'user', dir: '.json' },
+    ],
+  },
+  opencode: {
+    tier: 'declared',
+    label: 'OpenCode',
+    sources: [
+      { rel: ['.config', 'opencode', 'opencode.json'], base: 'home', scope: 'user' },
+      { rel: ['.config', 'opencode', 'opencode.jsonc'], base: 'home', scope: 'user' },
+      { rel: ['opencode.json'], base: 'cwd', scope: 'project' },
+      { rel: ['opencode.jsonc'], base: 'cwd', scope: 'project' },
+    ],
+  },
+  zed: {
+    tier: 'declared',
+    label: 'Zed',
+    sources: [
+      { rel: ['settings.json'], base: 'zed-config', scope: 'user' },
+      { rel: ['.zed', 'settings.json'], base: 'cwd', scope: 'project' },
+    ],
+  },
+  augment: {
+    tier: 'declared',
+    label: 'Augment',
+    sources: [
+      { rel: ['.augment', 'settings.json'], base: 'home', scope: 'user' },
+      { rel: ['.augment', 'settings.json'], base: 'cwd', scope: 'project' },
+    ],
+  },
+  continue: {
+    tier: 'declared',
+    label: 'Continue',
+    sources: [{ rel: ['.continue', 'permissions.yaml'], base: 'home', scope: 'user' }],
+  },
+  goose: {
+    tier: 'flag',
+    label: 'Goose',
+    sources: [
+      { rel: ['config.yaml'], base: 'goose-config', scope: 'user' },
+      { rel: ['permission.yaml'], base: 'goose-config', scope: 'user' },
+    ],
+  },
+  amp: {
+    tier: 'flag',
+    label: 'Amp',
+    sources: [
+      { rel: ['settings.json'], base: 'vscode-user', scope: 'user', keys: ['amp.'] },
+      { rel: ['.config', 'amp', 'settings.json'], base: 'home', scope: 'user' },
+      { rel: ['.vscode', 'settings.json'], base: 'cwd', scope: 'project', keys: ['amp.'] },
+    ],
+  },
+  aider: {
+    tier: 'flag',
+    label: 'Aider',
+    sources: [
+      { rel: ['.aider.conf.yml'], base: 'home', scope: 'user' },
+      { rel: ['.aider.conf.yml'], base: 'cwd', scope: 'project' },
+    ],
   },
-
-  aider: { tier: 'none', label: 'Aider', sources: [] },
 };
 
 function vscodeUserDir(variant) {
@@ -109,6 +225,12 @@ function vscodeUserDir(variant) {
   return path.join(HOME, '.config', variant, 'User');
 }
 
+const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+
+function systemDir(win, mac, linux) {
+  return PLAT === 'win32' ? win : PLAT === 'darwin' ? mac : linux;
+}
+
 function resolveBase(base, cwd) {
   switch (base) {
     case 'home': return HOME;
@@ -116,10 +238,39 @@ function resolveBase(base, cwd) {
     case 'cursor-user': return path.dirname(vscodeUserDir('Cursor'));
     case 'cline-storage': return path.join(vscodeUserDir('Code'), 'globalStorage', 'saoudrizwan.claude-dev');
     case 'roo-storage': return path.join(vscodeUserDir('Code'), 'globalStorage', 'rooveterinaryinc.roo-cline');
+    case 'vscode-user': return vscodeUserDir('Code');
+    case 'vscode-insiders-user': return vscodeUserDir('Code - Insiders');
+    case 'windsurf-user': return vscodeUserDir('Windsurf');
+    case 'claude-managed': return systemDir('C:\\Program Files\\ClaudeCode', '/Library/Application Support/ClaudeCode', '/etc/claude-code');
+    case 'gemini-system': return systemDir('C:\\ProgramData\\gemini-cli', '/Library/Application Support/GeminiCli', '/etc/gemini-cli');
+    case 'qwen-system': return systemDir('C:\\ProgramData\\qwen-code', '/Library/Application Support/QwenCode', '/etc/qwen-code');
+    case 'zed-config': return PLAT === 'win32' ? path.join(APPDATA, 'Zed') : path.join(HOME, '.config', 'zed');
+    case 'goose-config': return PLAT === 'win32' ? path.join(APPDATA, 'Block', 'goose', 'config') : path.join(HOME, '.config', 'goose');
     default: return cwd;
   }
 }
 
+const MAX_DIR_FILES = 20;
+
+function expandSource(src, cwd) {
+  const target = path.join(resolveBase(src.base, cwd), ...src.rel);
+  if (!src.dir) return [target];
+  try {
+    return fs.readdirSync(target)
+      .filter((n) => n.toLowerCase().endsWith(src.dir))
+      .sort()
+      .slice(0, MAX_DIR_FILES)
+      .map((n) => path.join(target, n));
+  } catch {
+    return [];
+  }
+}
+
+function pickKeys(json, prefixes) {
+  if (!prefixes || !json || typeof json !== 'object' || Array.isArray(json)) return json;
+  return Object.fromEntries(Object.entries(json).filter(([k]) => prefixes.some((p) => k.toLowerCase().startsWith(p.toLowerCase()))));
+}
+
 const AUTO_APPROVE_KEYS = [
   { re: /^(yolo|yolomode|enableyolo)$/i, label: 'YOLO mode', severity: 'CRITICAL' },
   { re: /^(autoapprove|alwaysallow|autoallow|autoaccept|autoconfirm)$/i, label: 'auto-approve', severity: 'HIGH' },
@@ -147,53 +298,59 @@ function collectSwitches(node, out, depth = 0, trail = '') {
   }
 }
 
+
 function collectMcpServers(json) {
-  const servers = json?.mcpServers ?? json?.servers ?? json?.mcp?.servers ?? null;
-  if (!servers || typeof servers !== 'object' || Array.isArray(servers)) return [];
-  return Object.entries(servers)
-    .slice(0, 60)
-    .map(([name, def]) => ({
-      name,
-      transport: def?.url ? 'http' : 'stdio',
-
-      autoApprove: Array.isArray(def?.autoApprove) ? def.autoApprove.slice(0, 20) : Array.isArray(def?.alwaysAllow) ? def.alwaysAllow.slice(0, 20) : [],
-      disabled: def?.disabled === true,
-    }));
+  const servers = readMcpServers(json) ?? [];
+  return servers.slice(0, 60).map((s) => ({
+    name: s.name,
+    transport: s.url ? 'http' : 'stdio',
+    autoApprove: (s.trusted ? ['*', ...(s.autoApprove ?? [])] : s.autoApprove ?? []).slice(0, 20),
+    disabled: s.disabled === true,
+  }));
 }
 
-export function readVendorPosture(vendor, cwd = process.cwd()) {
+function readSource(src, cwd) {
+  if (src.stateDb) {
+    const file = path.join(vscodeUserDir(src.stateDb), 'globalStorage', 'state.vscdb');
+    const res = readStateKeys(file, src.dbKeys);
+    const docs = res.state === 'read' ? res.values.map((v) => INTERPRETERS[src.interpret](v.json)) : [];
+    return [{ path: `${file}#${src.dbKeys.join('|')}`, res, docs }];
+  }
+  return expandSource(src, cwd).map((file) => {
+    const res = readJsonc(file, src.maxBytes);
+    const raw = res.state === 'read' ? pickKeys(res.json ?? {}, src.keys) : null;
+    const doc = raw && src.interpret ? INTERPRETERS[src.interpret](raw) : raw;
+    return { path: file, res, docs: doc ? [doc] : [] };
+  });
+}
+
+export function readVendorPosture(vendor, cwd = process.cwd(), roots = null) {
   const def = VENDOR_POSTURE[vendor];
   if (!def) return null;
 
   const sources = [];
   const switches = [];
   const mcpServers = [];
-  let mode = null;
-  const allow = [];
-  const deny = [];
-  const ask = [];
-  let enableAllProjectMcpServers = null;
+  const grant = emptyGrant();
+  const extraRoots = (roots ?? []).filter((r) => r && path.resolve(r) !== path.resolve(cwd));
+  const projectsRead = new Set();
 
   for (const src of def.sources) {
-    const file = path.join(resolveBase(src.base, cwd), ...src.rel);
-    const res = readJsonc(file);
-    sources.push({ path: file, scope: src.scope, state: res.state, reason: res.reason ?? null });
-    if (res.state !== 'read') continue;
-
-    const json = res.json ?? {};
-    const perms = json.permissions ?? {};
-
-    const m = perms.defaultMode ?? json.defaultMode ?? null;
-    if (m && (!mode || String(m).toLowerCase() === 'bypasspermissions')) mode = String(m);
-    for (const [key, sink] of [['allow', allow], ['deny', deny], ['ask', ask]]) {
-      const list = Array.isArray(perms[key]) ? perms[key] : key === 'allow' && Array.isArray(json.allowedTools) ? json.allowedTools : [];
-      for (const g of list) if (typeof g === 'string' && !sink.includes(g)) sink.push(g);
+    const bases = src.base === 'cwd' ? [cwd, ...extraRoots] : [cwd];
+    for (const base of bases) {
+      for (const { path: file, res, docs } of readSource(src, base)) {
+        const primary = base === cwd;
+        if (primary || res.state !== 'absent') sources.push({ path: file, scope: src.scope, state: res.state, reason: res.reason ?? null });
+        if (res.state !== 'read') continue;
+        if (src.base === 'cwd') projectsRead.add(base);
+        for (const json of docs) {
+          if ((src.keys || src.interpret) && !Object.keys(json).length) continue;
+          extractGrant(json, grant);
+          if (def.tier === 'flag') collectSwitches(json, switches);
+          for (const s of collectMcpServers(json)) if (!mcpServers.some((x) => x.name === s.name)) mcpServers.push(s);
+        }
+      }
     }
-    if (json.enableAllProjectMcpServers === true) enableAllProjectMcpServers = true;
-    else if (enableAllProjectMcpServers === null && json.enableAllProjectMcpServers === false) enableAllProjectMcpServers = false;
-
-    if (def.tier === 'flag') collectSwitches(json, switches);
-    for (const s of collectMcpServers(json)) if (!mcpServers.some((x) => x.name === s.name)) mcpServers.push(s);
   }
 
   const read = sources.filter((s) => s.state === 'read');
@@ -207,38 +364,60 @@ export function readVendorPosture(vendor, cwd = process.cwd()) {
     readable: read.length > 0,
     sources,
     unreadableCount: holes.length,
-    mode,
-    allow: allow.slice(0, 60),
-    deny: deny.slice(0, 60),
-    ask: ask.slice(0, 60),
-    enableAllProjectMcpServers,
+    mode: grant.mode,
+    allow: grant.allow.slice(0, 60),
+    deny: grant.deny.slice(0, 60),
+    ask: grant.ask.slice(0, 60),
+    enableAllProjectMcpServers: grant.enableAllProjectMcpServers,
+    grant,
     switches: switches.slice(0, 20),
     mcpServers,
 
     autoApprovedMcp: mcpServers.filter((s) => s.autoApprove.length > 0 && !s.disabled).map((s) => s.name),
 
-    claim: def.tier === 'declared' && read.length > 0 && holes.length === 0 ? 'complete' : 'floor',
+    truncated: grant.truncated === true,
+    projectsScanned: 1 + extraRoots.length,
+    projectsWithSettings: projectsRead.size,
+    claim: def.tier === 'declared' && read.length > 0 && holes.length === 0 && !grant.truncated ? 'complete' : 'floor',
   };
 }
 
 export function canonicalGrant(posture) {
   if (!posture) return null;
+  const g = posture.grant && !grantIsEmpty(posture.grant) ? posture.grant : null;
   const doc = {};
   const perms = {};
   if (posture.mode) perms.defaultMode = posture.mode;
-  if (posture.allow.length) perms.allow = posture.allow;
-  if (posture.deny.length) perms.deny = posture.deny;
-  if (posture.ask.length) perms.ask = posture.ask;
+  if (posture.allow?.length) perms.allow = posture.allow;
+  if (posture.deny?.length) perms.deny = posture.deny;
+  if (posture.ask?.length) perms.ask = posture.ask;
+  if (g) {
+    if (g.directories.length) perms.additionalDirectories = g.directories;
+    if (g.trustedFolders.length) perms.trustedFolders = g.trustedFolders;
+    const fsGrant = Object.fromEntries(Object.entries(g.fileSystem).filter(([, v]) => v.length));
+    if (Object.keys(fsGrant).length) perms.fileSystem = fsGrant;
+    const net = Object.fromEntries(Object.entries(g.network).filter(([, v]) => v.length));
+    if (Object.keys(net).length) perms.network = net;
+    if (g.envNames.length) perms.environmentVariables = { allowList: g.envNames };
+    if (g.commands.length) perms.tools = { allowExecution: g.commands };
+    if (g.rules.length) perms.rules = g.rules;
+    if (g.permission) perms.permission = g.permission;
+    if (g.toolPermissions && Object.keys(g.toolPermissions).length) perms.tool_permissions = g.toolPermissions;
+    if (g.unixSockets.length) perms.sandbox = { network: { allowUnixSockets: g.unixSockets } };
+    if (g.mcpAllowlist.length) perms.mcpAllowlist = g.mcpAllowlist;
+    if (g.folderTrustDisabled) perms.folderTrust = { enabled: false };
+    for (const [k, v] of Object.entries(g.flags)) if (!(k in perms)) perms[k] = v;
+  }
   if (Object.keys(perms).length) doc.permissions = perms;
   if (posture.enableAllProjectMcpServers === true) doc.enableAllProjectMcpServers = true;
   return Object.keys(doc).length ? JSON.stringify(doc, null, 2) : null;
 }
 
-export function readPostures(vendors, cwd = process.cwd()) {
+export function readPostures(vendors, cwd = process.cwd(), roots = projectRoots(cwd)) {
   const out = {};
   for (const v of vendors) {
     try {
-      const p = readVendorPosture(v, cwd);
+      const p = readVendorPosture(v, cwd, roots);
       if (p) out[v] = p;
     } catch {
 

package/src/inventory/artifacts/classify.mjs

@@ -1,21 +1,30 @@
 import path from 'node:path';
 import { extOf } from './limits.mjs';
 import { SETTINGS_BASENAMES } from './marketplaces.mjs';
+import { isInstructionPath } from '../../detect/signals/instruction-paths.mjs';
+import { PLUGIN_MANIFEST_RE } from './plugins.mjs';
+import { EXTENSION_MANIFEST_RE } from './extensions.mjs';
+
+export const COMMAND_PATH_RE = /(^|\/)commands?\/|(^|\/)\.[\w-]+\/prompts?\/|(^|\/)\.(?:windsurf|devin|clinerules)\/workflows\//;
 
 export function classify(rel, vendor) {
   const lower = rel.toLowerCase().replace(/\\/g, '/');
   const base = path.basename(lower);
   const ext = extOf(lower);
 
+  if (vendor === 'claude-desktop') return EXTENSION_MANIFEST_RE.test(lower) ? 'extension' : null;
+  if (PLUGIN_MANIFEST_RE.test(lower)) return 'plugin';
   if (base === 'skill.md') return 'skill';
   if (SETTINGS_BASENAMES.has(base)) return 'hook';
+  if (vendor === 'copilot' && ext === 'json' && /(^|\/)hooks\/[^/]+\.json$/.test(lower)) return 'hook';
   if (/(^|\/)(sub)?agents?\//.test(lower) && ext === 'md') return 'subagent';
-  if (/(^|\/)(commands?|prompts?|workflows?)\//.test(lower) && (ext === 'md' || ext === 'toml')) {
+  if (COMMAND_PATH_RE.test(lower) && !/(^|\/)\.github\/workflows\//.test(lower) && (ext === 'md' || ext === 'toml')) {
 
     if (vendor === 'copilot' && !/(^|\/)(prompts|chatmodes)\//.test(lower)) return null;
     return 'command';
   }
   if (vendor === 'copilot' && /(^|\/)chatmodes\//.test(lower) && ext === 'md') return 'subagent';
+  if (lower.split('/').length <= 5 && !/(^|\/)(extensions|plugins|marketplaces|node_modules|cache|projects)\//.test(lower) && isInstructionPath(lower)) return 'rules';
   return null;
 }
 

package/src/inventory/artifacts/discover.mjs

@@ -4,8 +4,12 @@ import { clampArtifact } from '../../core/wire-limits.mjs';
 import { classify, declaredName } from './classify.mjs';
 import { readText } from './file-read.mjs';
 import { canonicalHooks } from './hooks.mjs';
-import { MAX_ARTIFACTS, MAX_BUNDLED, MAX_DIRS, MAX_TOTAL_BYTES, TEXT_EXTS, extOf } from './limits.mjs';
+import { bundleHookScripts } from './hook-scripts.mjs';
+import { HOME, MAX_ARTIFACTS, MAX_BUNDLED, MAX_DIRS, MAX_TOTAL_BYTES, TEXT_EXTS, extOf } from './limits.mjs';
+import { extractInstructionImports } from '../../detect/signals/instruction-paths.mjs';
 import { CATALOGUE_DIR_RE, PLUGIN_PATH_RE, installedMarketplaces } from './marketplaces.mjs';
+import { MARKETPLACE_ROOT_RE, MAX_MANIFEST_BYTES, bundlePluginComponents, installedPluginManifests, manifestName, pluginRootOf } from './plugins.mjs';
+import { bundleExtensionSource } from './extensions.mjs';
 import { artifactRoots } from './roots.mjs';
 import { walkRoot } from './walk.mjs';
 
@@ -16,10 +20,13 @@ function relativeToSite(site, absolutePath) {
 }
 
 function artifactName(kind, content, absolutePath) {
+  if (kind === 'plugin') return manifestName(content, path.basename(pluginRootOf(absolutePath)) || path.basename(absolutePath));
+  if (kind === 'extension') return manifestName(content, path.basename(path.dirname(absolutePath)));
   const declared = declaredName(content);
   if (declared) return declared;
   if (kind === 'skill') return path.basename(path.dirname(absolutePath));
   if (kind === 'hook') return `${path.basename(absolutePath)} · hooks`;
+  if (kind === 'rules') return path.basename(absolutePath);
   return path.basename(absolutePath).replace(/\.(md|toml)$/i, '');
 }
 
@@ -30,8 +37,10 @@ function resolveActivation(marketplace, installed) {
 }
 
 function readArtifactContent(kind, absolutePath) {
-  const read = readText(absolutePath);
+  const manifest = kind === 'plugin' || kind === 'extension';
+  const read = readText(absolutePath, manifest ? MAX_MANIFEST_BYTES : undefined);
   if (!read) return null;
+  if (manifest && read.truncated) return { ...read, content: null, oversize: true };
   if (kind !== 'hook') return { ...read, content: read.text };
   const content = canonicalHooks(read.text);
   return content ? { ...read, content } : null;
@@ -77,7 +86,12 @@ function collectFromSite({ site, files, state, project }) {
     }
 
     const marketplace = PLUGIN_PATH_RE.exec(relativePath)?.[2] ?? null;
-    const activation = resolveActivation(marketplace, installed);
+
+    if (kind === 'plugin' && marketplace && !MARKETPLACE_ROOT_RE.test(relativePath)) {
+      availableBy.set(marketplace, (availableBy.get(marketplace) ?? 0) + 1);
+      continue;
+    }
+    const activation = kind === 'plugin' && marketplace ? 'active' : resolveActivation(marketplace, installed);
     if (activation === 'not-installed') {
       availableBy.set(marketplace, (availableBy.get(marketplace) ?? 0) + 1);
       continue;
@@ -85,6 +99,10 @@ function collectFromSite({ site, files, state, project }) {
 
     const read = readArtifactContent(kind, absolutePath);
     if (!read) continue;
+    if (read.oversize) {
+      capped.push({ reason: 'manifest-too-large', path: relativePath });
+      continue;
+    }
     if (read.bytes > budget.bytes) {
       capped.push({ reason: 'byte-budget', path: relativePath });
       continue;
@@ -97,6 +115,76 @@ function collectFromSite({ site, files, state, project }) {
     consumed.add(absolutePath);
     artifacts.push(artifact);
     if (kind === 'skill') skills.push({ artifact, dir: path.dirname(absolutePath), site });
+    if (kind === 'rules') state.rules.push({ artifact, absolutePath });
+    if (kind === 'plugin') state.plugins.push({ artifact, absolutePath, site });
+    if (kind === 'extension') state.extensions.push({ artifact, absolutePath, site });
+    if (kind === 'hook') (state.hooks ??= []).push({ artifact, absolutePath, site });
+  }
+}
+
+function collectInstalledPlugins({ sites, state, project }) {
+  const { artifacts, capped, consumed, budget } = state;
+  for (const site of sites) {
+    if (site.vendor !== 'claude-code' || site.scope !== 'user') continue;
+    for (const { manifest, marketplace } of installedPluginManifests(site.dir)) {
+      if (consumed.has(manifest)) continue;
+      if (artifacts.length >= MAX_ARTIFACTS) { capped.push({ reason: 'artifact-cap', path: manifest }); return; }
+      const relativePath = relativeToSite(site, manifest);
+      const read = readArtifactContent('plugin', manifest);
+      if (!read) continue;
+      if (read.oversize) { capped.push({ reason: 'manifest-too-large', path: relativePath }); continue; }
+      if (read.bytes > budget.bytes) { capped.push({ reason: 'byte-budget', path: relativePath }); continue; }
+      budget.bytes -= Buffer.byteLength(read.content);
+      const artifact = buildArtifact({
+        kind: 'plugin', content: read.content, read, relativePath, site, project, marketplace, activation: 'active', absolutePath: manifest,
+      });
+      consumed.add(manifest);
+      artifacts.push(artifact);
+      state.plugins.push({ artifact, absolutePath: manifest, site });
+    }
+  }
+}
+
+const IMPORT_READABLE_RE = /\.(?:md|mdx|markdown|mdc|rst|txt)$/i;
+const IMPORT_SECRET_RE = /(?:^|[\\/])(?:\.env|\.ssh|\.aws|\.gnupg|\.netrc|\.npmrc)|id_(?:rsa|dsa|ecdsa|ed25519)|secret|credential|password|\.pem$|\.key$/i;
+const MAX_IMPORT_DEPTH = 5;
+
+function resolveImport(ref, fromFile) {
+  if (ref.startsWith('~/')) return path.join(HOME, ref.slice(2));
+  if (path.isAbsolute(ref)) return ref;
+  return path.resolve(path.dirname(fromFile), ref);
+}
+
+function bundleRuleImports(state) {
+  const { capped, budget } = state;
+  for (const { artifact, absolutePath } of state.rules) {
+    const seen = new Set([absolutePath]);
+    const queue = [{ file: absolutePath, text: artifact.content, depth: 0 }];
+    while (queue.length) {
+      const { file, text, depth } = queue.shift();
+      if (depth >= MAX_IMPORT_DEPTH) continue;
+      for (const ref of extractInstructionImports(text)) {
+        if (!IMPORT_READABLE_RE.test(ref) || IMPORT_SECRET_RE.test(ref)) continue;
+        const target = resolveImport(ref, file);
+        if (seen.has(target)) continue;
+        seen.add(target);
+        if (artifact.files.length >= MAX_BUNDLED) {
+          capped.push({ reason: 'bundle-cap', path: artifact.path });
+          queue.length = 0;
+          break;
+        }
+        const read = readText(target);
+        if (!read) continue;
+        if (read.bytes > budget.bytes) {
+          capped.push({ reason: 'byte-budget', path: ref });
+          continue;
+        }
+        budget.bytes -= Buffer.byteLength(read.text);
+        artifact.files.push({ path: ref.replace(/^[~.]*\//, ''), content: read.text, binary: false });
+        queue.push({ file: target, text: read.text, depth: depth + 1 });
+      }
+    }
+    if (artifact.files.length) artifact.metadata.importCount = artifact.files.length;
   }
 }
 
@@ -164,12 +252,34 @@ export function discoverAgentArtifacts(cwd = process.cwd(), roots = null) {
     capped: [],
     consumed: new Set(),
     skills: [],
+    rules: [],
+    plugins: [],
+    extensions: [],
     availableBy: new Map(),
   };
 
   const walked = walkSites(sites, state.budget);
   for (const { site, files } of walked) collectFromSite({ site, files, state, project });
+  collectInstalledPlugins({ sites, state, project });
   bundleSkillFiles({ skills: state.skills, walked, state });
+  bundleRuleImports(state);
+  for (const { artifact, absolutePath, site } of state.hooks ?? []) {
+    bundleHookScripts(artifact, absolutePath, {
+      projectDir: site.scope === 'project' ? path.dirname(site.dir) : cwd,
+      relPath: (abs) => {
+        const rel = relativeToSite(site, abs);
+        return rel.startsWith('..') || path.isAbsolute(rel) ? null : rel;
+      },
+      budget: state.budget,
+      capped: state.capped,
+    });
+  }
+  for (const { artifact, absolutePath, site } of state.extensions) {
+    bundleExtensionSource(artifact, absolutePath, (abs) => relativeToSite(site, abs), state.budget, state.capped);
+  }
+  for (const { artifact, absolutePath, site } of state.plugins) {
+    bundlePluginComponents(artifact, absolutePath, (abs) => relativeToSite(site, abs), state.budget, state.capped);
+  }
 
   if (state.budget.dirs <= 0) state.capped.push({ reason: 'walk-budget', path: null });