simba-skills 0.6.0 → 0.6.1

package/README.md

@@ -7,7 +7,7 @@
 [![npm version](https://img.shields.io/npm/v/simba-skills)](https://www.npmjs.com/package/simba-skills)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-AI skills manager with a central store and symlink-based distribution across 14+ coding agents.
+AI skills manager with a central store and symlink-based distribution across 17+ coding agents.
 
 ## Why Simba?
 
@@ -108,22 +108,11 @@ simba undo
 
 ## Supported Agents
 
-| Agent | Global Path | Project Path |
-|-------|-------------|--------------|
-| Claude Code | `~/.claude/skills` | `.claude/skills` |
-| Cursor | `~/.cursor/skills` | `.cursor/skills` |
-| Codex | `~/.codex/skills` | `.codex/skills` |
-| GitHub Copilot | `~/.copilot/skills` | `.github/skills` |
-| Gemini CLI | `~/.gemini/skills` | `.gemini/skills` |
-| Windsurf | `~/.codeium/windsurf/skills` | `.windsurf/skills` |
-| Amp | `~/.config/agents/skills` | `.agents/skills` |
-| Goose | `~/.config/goose/skills` | `.goose/skills` |
-| OpenCode | `~/.config/opencode/skill` | `.opencode/skill` |
-| Kilo Code | `~/.kilocode/skills` | `.kilocode/skills` |
-| Roo Code | `~/.roo/skills` | `.roo/skills` |
-| Antigravity | `~/.gemini/antigravity/skills` | `.agent/skills` |
-| Clawdbot | `~/.clawdbot/skills` | `skills` |
-| Droid | `~/.factory/skills` | `.factory/skills` |
+Supports Claude Code, Codex, OpenCode, Cursor, Gemini CLI, GitHub Copilot, Amp, Kimi Code CLI, Replit, and 30+ others.
+
+Includes agents using the `.agents/skills` universal standard, plus agent-specific paths.
+
+See full agent definitions and paths in [`src/core/config-store.ts`](./src/core/config-store.ts).
 
 ## Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simba-skills",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "AI skills manager - central store with symlink-based distribution across 15+ coding agents",
   "publishConfig": {
     "access": "public"

package/src/commands/assign.ts

@@ -56,13 +56,32 @@ export default defineCommand({
     // Get detected agents
     const agentRegistry = new AgentRegistry(config.agents)
     const detected = await agentRegistry.detectAgents()
-    const detectedAgents = Object.entries(detected).filter(([, a]) => a.detected)
+
+    const universalFallbackByProjectPath = new Map<string, string>()
+    for (const agent of Object.values(detected)) {
+      if (!agent.universal || !agent.detected) continue
+      if (!universalFallbackByProjectPath.has(agent.projectPath)) {
+        universalFallbackByProjectPath.set(agent.projectPath, expandPath(agent.globalPath))
+      }
+    }
 
     const agentPaths: Record<string, string> = {}
-    for (const [id, agent] of detectedAgents) {
-      agentPaths[id] = expandPath(agent.globalPath)
+    for (const [id, agent] of Object.entries(detected)) {
+      if (agent.detected) {
+        agentPaths[id] = expandPath(agent.globalPath)
+        continue
+      }
+
+      if (agent.universal) {
+        const fallback = universalFallbackByProjectPath.get(agent.projectPath)
+        if (fallback) {
+          agentPaths[id] = fallback
+        }
+      }
     }
 
+    const assignableAgents = Object.entries(detected).filter(([id]) => agentPaths[id])
+
     // Interactive mode if args missing
     let skill = args.skill as string | undefined
     let agents: string[]
@@ -83,14 +102,14 @@ export default defineCommand({
     }
 
     if (!args.agents) {
-      if (detectedAgents.length === 0) {
+      if (assignableAgents.length === 0) {
         console.log("No agents detected.")
         return
       }
 
       const result = await p.multiselect({
         message: "Select agents to assign to",
-        options: detectedAgents.map(([id, a]) => ({ value: id, label: a.name })),
+        options: assignableAgents.map(([id, a]) => ({ value: id, label: a.name })),
         required: true,
       })
       if (p.isCancel(result)) process.exit(0)

package/src/commands/bootstrap.ts

@@ -349,6 +349,28 @@ export interface AssignResult {
   message?: string
 }
 
+function resolveAssignmentPath(
+  agentId: string,
+  detected: Record<string, import("../core/types").Agent>
+): string | null {
+  const agent = detected[agentId]
+  if (!agent) return null
+
+  if (agent.detected) {
+    return expandPath(agent.globalPath)
+  }
+
+  if (!agent.universal) {
+    return null
+  }
+
+  const fallback = Object.values(detected).find(
+    (candidate) => candidate.universal && candidate.detected && candidate.projectPath === agent.projectPath
+  )
+
+  return fallback ? expandPath(fallback.globalPath) : null
+}
+
 /** Detect agents and create symlinks for each skill's assignments */
 export async function assignSkillsToAgents(
   registry: { skills: Record<string, ManagedSkill> },
@@ -366,14 +388,13 @@ export async function assignSkillsToAgents(
 
     const assignments = skill.assignments
     for (const [agentId, assignment] of Object.entries(assignments)) {
-      const agent = detected[agentId]
-      if (!agent?.detected) {
+      const assignmentPath = resolveAssignmentPath(agentId, detected)
+      if (!assignmentPath) {
         results.push({ skill: skillName, agent: agentId, status: "skipped", message: "agent not detected" })
         continue
       }
 
-      const agentSkillsDir = expandPath(agent.globalPath)
-      await skillsStore.assignSkill(skillName, agentSkillsDir, assignment)
+      await skillsStore.assignSkill(skillName, assignmentPath, assignment)
       results.push({ skill: skillName, agent: agentId, status: "assigned" })
     }
   }

package/src/commands/detect.ts

@@ -51,9 +51,18 @@ export default defineCommand({
 
     await configStore.save(config)
 
-    // Output results
-    console.log("\nDetected agents:")
-    for (const [id, agent] of Object.entries(detected)) {
+    // Output results grouped by universal/custom
+    const universal = Object.values(detected).filter(a => a.universal)
+    const custom = Object.values(detected).filter(a => !a.universal)
+
+    console.log("\nUniversal (.agents/skills):")
+    for (const agent of universal) {
+      const status = agent.detected ? "✓" : "─"
+      console.log(`  ${status} ${agent.name}`)
+    }
+
+    console.log("\nCustom:")
+    for (const agent of custom) {
       const status = agent.detected ? "✓" : "─"
       console.log(`  ${status} ${agent.name}`)
     }

package/src/commands/install.ts

@@ -31,7 +31,7 @@ interface MarketplaceJson {
   plugins?: MarketplacePlugin[]
 }
 
-const SKILL_DIRS = ["skills", ".claude/skills", ".cursor/skills", ".codex/skills"]
+const SKILL_DIRS = ["skills", ".agents/skills", ".claude/skills", ".cursor/skills", ".codex/skills"]
 
 interface SubmoduleInfo {
   path: string

package/src/core/agent-registry.ts

@@ -11,15 +11,20 @@ export class AgentRegistry {
     const results: Record<string, Agent> = {}
 
     for (const [id, agent] of Object.entries(this.agents)) {
-      const globalPath = expandPath(agent.globalPath)
-      const parentDir = dirname(globalPath)
+      const configuredPaths = agent.detectPaths && agent.detectPaths.length > 0
+        ? agent.detectPaths
+        : [agent.detectPath ?? dirname(agent.globalPath)]
 
       let detected = false
-      try {
-        await access(parentDir)
-        detected = true
-      } catch {
-        detected = false
+      for (const path of configuredPaths) {
+        const detectionPath = expandPath(path)
+        try {
+          await access(detectionPath)
+          detected = true
+          break
+        } catch {
+          continue
+        }
       }
 
       results[id] = { ...agent, detected }

package/src/core/config-store.ts

@@ -3,32 +3,405 @@ import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import type { Config, Agent } from "./types";
 
-// Add new agents here: [id, name, shortName, globalPath, projectPath]
-const AGENT_DEFINITIONS: [string, string, string, string, string][] = [
-    ["claude", "Claude Code", "Claude", "~/.claude/skills", ".claude/skills"],
-    ["cursor", "Cursor", "Cursor", "~/.cursor/skills", ".cursor/skills"],
-    ["codex", "Codex", "Codex", "~/.codex/skills", ".codex/skills"],
-    ["copilot", "GitHub Copilot", "Copilot", "~/.copilot/skills", ".github/skills"],
-    ["gemini", "Gemini CLI", "Gemini", "~/.gemini/skills", ".gemini/skills"],
-    ["windsurf", "Windsurf", "Windsurf", "~/.codeium/windsurf/skills", ".windsurf/skills"],
-    ["amp", "Amp", "Amp", "~/.config/agents/skills", ".agents/skills"],
-    ["goose", "Goose", "Goose", "~/.config/goose/skills", ".goose/skills"],
-    ["opencode", "OpenCode", "OpenCode", "~/.config/opencode/skills", ".opencode/skills"],
-    ["kilo", "Kilo Code", "Kilo", "~/.kilocode/skills", ".kilocode/skills"],
-    ["roo", "Roo Code", "Roo", "~/.roo/skills", ".roo/skills"],
-    ["antigravity", "Antigravity", "Antigrav", "~/.gemini/antigravity/skills", ".agent/skills"],
-    ["clawdbot", "Clawdbot", "Clawdbot", "~/.clawdbot/skills", "skills"],
-    ["droid", "Droid", "Droid", "~/.factory/skills", ".factory/skills"],
-    ["pi", "pi", "pi", "~/.pi/agent/skills", ".pi/skills"],
+interface AgentDefinition {
+    id: string;
+    name: string;
+    shortName: string;
+    globalPath: string;
+    projectPath: string;
+    detectPath?: string;
+    detectPaths?: string[];
+    universal: boolean;
+}
+
+const AGENT_DEFINITIONS: AgentDefinition[] = [
+    // Universal agents (use .agents/skills as project path)
+    {
+        id: "amp",
+        name: "Amp",
+        shortName: "Amp",
+        globalPath: "~/.config/agents/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.config/amp",
+        universal: true,
+    },
+    {
+        id: "codex",
+        name: "Codex",
+        shortName: "Codex",
+        globalPath: "~/.codex/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.codex",
+        universal: true,
+    },
+    {
+        id: "copilot",
+        name: "GitHub Copilot",
+        shortName: "Copilot",
+        globalPath: "~/.copilot/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.copilot",
+        universal: true,
+    },
+    {
+        id: "gemini",
+        name: "Gemini CLI",
+        shortName: "Gemini",
+        globalPath: "~/.gemini/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.gemini",
+        universal: true,
+    },
+    {
+        id: "opencode",
+        name: "OpenCode",
+        shortName: "OpenCode",
+        globalPath: "~/.config/opencode/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.config/opencode",
+        universal: true,
+    },
+    {
+        id: "kimi",
+        name: "Kimi Code CLI",
+        shortName: "Kimi",
+        globalPath: "~/.config/agents/skills",
+        projectPath: ".agents/skills",
+        detectPath: "~/.kimi",
+        universal: true,
+    },
+    {
+        id: "replit",
+        name: "Replit",
+        shortName: "Replit",
+        globalPath: "~/.config/agents/skills",
+        projectPath: ".agents/skills",
+        detectPath: ".replit",
+        universal: true,
+    },
+
+    // Custom agents
+    {
+        id: "claude",
+        name: "Claude Code",
+        shortName: "Claude",
+        globalPath: "~/.claude/skills",
+        projectPath: ".claude/skills",
+        detectPath: "~/.claude",
+        universal: false,
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        shortName: "Cursor",
+        globalPath: "~/.cursor/skills",
+        projectPath: ".cursor/skills",
+        detectPath: "~/.cursor",
+        universal: false,
+    },
+    {
+        id: "windsurf",
+        name: "Windsurf",
+        shortName: "Windsurf",
+        globalPath: "~/.codeium/windsurf/skills",
+        projectPath: ".windsurf/skills",
+        detectPath: "~/.codeium/windsurf",
+        universal: false,
+    },
+    {
+        id: "goose",
+        name: "Goose",
+        shortName: "Goose",
+        globalPath: "~/.config/goose/skills",
+        projectPath: ".goose/skills",
+        detectPath: "~/.config/goose",
+        universal: false,
+    },
+    {
+        id: "kilo",
+        name: "Kilo Code",
+        shortName: "Kilo",
+        globalPath: "~/.kilocode/skills",
+        projectPath: ".kilocode/skills",
+        detectPath: "~/.kilocode",
+        universal: false,
+    },
+    {
+        id: "roo",
+        name: "Roo Code",
+        shortName: "Roo",
+        globalPath: "~/.roo/skills",
+        projectPath: ".roo/skills",
+        detectPath: "~/.roo",
+        universal: false,
+    },
+    {
+        id: "antigravity",
+        name: "Antigravity",
+        shortName: "Antigrav",
+        globalPath: "~/.gemini/antigravity/skills",
+        projectPath: ".agent/skills",
+        detectPath: "~/.gemini/antigravity",
+        universal: false,
+    },
+    {
+        id: "droid",
+        name: "Droid",
+        shortName: "Droid",
+        globalPath: "~/.factory/skills",
+        projectPath: ".factory/skills",
+        detectPath: "~/.factory",
+        universal: false,
+    },
+    {
+        id: "pi",
+        name: "pi",
+        shortName: "pi",
+        globalPath: "~/.pi/agent/skills",
+        projectPath: ".pi/skills",
+        detectPath: "~/.pi/agent",
+        universal: false,
+    },
+    {
+        id: "openclaw",
+        name: "OpenClaw",
+        shortName: "OpenClaw",
+        globalPath: "~/.openclaw/skills",
+        projectPath: "skills",
+        detectPath: "~/.openclaw",
+        universal: false,
+    },
+    {
+        id: "augment",
+        name: "Augment",
+        shortName: "Augment",
+        globalPath: "~/.augment/skills",
+        projectPath: ".augment/skills",
+        detectPath: "~/.augment",
+        universal: false,
+    },
+    {
+        id: "cline",
+        name: "Cline",
+        shortName: "Cline",
+        globalPath: "~/.cline/skills",
+        projectPath: ".cline/skills",
+        detectPath: "~/.cline",
+        universal: false,
+    },
+    {
+        id: "codebuddy",
+        name: "CodeBuddy",
+        shortName: "CodeBuddy",
+        globalPath: "~/.codebuddy/skills",
+        projectPath: ".codebuddy/skills",
+        detectPaths: [".codebuddy", "~/.codebuddy"],
+        universal: false,
+    },
+    {
+        id: "commandcode",
+        name: "Command Code",
+        shortName: "CmdCode",
+        globalPath: "~/.commandcode/skills",
+        projectPath: ".commandcode/skills",
+        detectPath: "~/.commandcode",
+        universal: false,
+    },
+    {
+        id: "continue",
+        name: "Continue",
+        shortName: "Continue",
+        globalPath: "~/.continue/skills",
+        projectPath: ".continue/skills",
+        detectPaths: [".continue", "~/.continue"],
+        universal: false,
+    },
+    {
+        id: "cortex",
+        name: "Cortex Code",
+        shortName: "Cortex",
+        globalPath: "~/.snowflake/cortex/skills",
+        projectPath: ".cortex/skills",
+        detectPath: "~/.snowflake/cortex",
+        universal: false,
+    },
+    {
+        id: "crush",
+        name: "Crush",
+        shortName: "Crush",
+        globalPath: "~/.config/crush/skills",
+        projectPath: ".crush/skills",
+        detectPath: "~/.config/crush",
+        universal: false,
+    },
+    {
+        id: "junie",
+        name: "Junie",
+        shortName: "Junie",
+        globalPath: "~/.junie/skills",
+        projectPath: ".junie/skills",
+        detectPath: "~/.junie",
+        universal: false,
+    },
+    {
+        id: "iflow",
+        name: "iFlow CLI",
+        shortName: "iFlow",
+        globalPath: "~/.iflow/skills",
+        projectPath: ".iflow/skills",
+        detectPath: "~/.iflow",
+        universal: false,
+    },
+    {
+        id: "kiro",
+        name: "Kiro CLI",
+        shortName: "Kiro",
+        globalPath: "~/.kiro/skills",
+        projectPath: ".kiro/skills",
+        detectPath: "~/.kiro",
+        universal: false,
+    },
+    {
+        id: "kode",
+        name: "Kode",
+        shortName: "Kode",
+        globalPath: "~/.kode/skills",
+        projectPath: ".kode/skills",
+        detectPath: "~/.kode",
+        universal: false,
+    },
+    {
+        id: "mcpjam",
+        name: "MCPJam",
+        shortName: "MCPJam",
+        globalPath: "~/.mcpjam/skills",
+        projectPath: ".mcpjam/skills",
+        detectPath: "~/.mcpjam",
+        universal: false,
+    },
+    {
+        id: "mistralvibe",
+        name: "Mistral Vibe",
+        shortName: "Vibe",
+        globalPath: "~/.vibe/skills",
+        projectPath: ".vibe/skills",
+        detectPath: "~/.vibe",
+        universal: false,
+    },
+    {
+        id: "mux",
+        name: "Mux",
+        shortName: "Mux",
+        globalPath: "~/.mux/skills",
+        projectPath: ".mux/skills",
+        detectPath: "~/.mux",
+        universal: false,
+    },
+    {
+        id: "openhands",
+        name: "OpenHands",
+        shortName: "OpenHands",
+        globalPath: "~/.openhands/skills",
+        projectPath: ".openhands/skills",
+        detectPath: "~/.openhands",
+        universal: false,
+    },
+    {
+        id: "qoder",
+        name: "Qoder",
+        shortName: "Qoder",
+        globalPath: "~/.qoder/skills",
+        projectPath: ".qoder/skills",
+        detectPath: "~/.qoder",
+        universal: false,
+    },
+    {
+        id: "qwen",
+        name: "Qwen Code",
+        shortName: "Qwen",
+        globalPath: "~/.qwen/skills",
+        projectPath: ".qwen/skills",
+        detectPath: "~/.qwen",
+        universal: false,
+    },
+    {
+        id: "trae",
+        name: "Trae",
+        shortName: "Trae",
+        globalPath: "~/.trae/skills",
+        projectPath: ".trae/skills",
+        detectPath: "~/.trae",
+        universal: false,
+    },
+    {
+        id: "traecn",
+        name: "Trae CN",
+        shortName: "TraeCN",
+        globalPath: "~/.trae-cn/skills",
+        projectPath: ".trae/skills",
+        detectPath: "~/.trae-cn",
+        universal: false,
+    },
+    {
+        id: "zencoder",
+        name: "Zencoder",
+        shortName: "Zencoder",
+        globalPath: "~/.zencoder/skills",
+        projectPath: ".zencoder/skills",
+        detectPath: "~/.zencoder",
+        universal: false,
+    },
+    {
+        id: "neovate",
+        name: "Neovate",
+        shortName: "Neovate",
+        globalPath: "~/.neovate/skills",
+        projectPath: ".neovate/skills",
+        detectPath: "~/.neovate",
+        universal: false,
+    },
+    {
+        id: "pochi",
+        name: "Pochi",
+        shortName: "Pochi",
+        globalPath: "~/.pochi/skills",
+        projectPath: ".pochi/skills",
+        detectPath: "~/.pochi",
+        universal: false,
+    },
+    {
+        id: "adal",
+        name: "AdaL",
+        shortName: "AdaL",
+        globalPath: "~/.adal/skills",
+        projectPath: ".adal/skills",
+        detectPath: "~/.adal",
+        universal: false,
+    },
 ];
 
 const DEFAULT_AGENTS: Record<string, Agent> = Object.fromEntries(
-    AGENT_DEFINITIONS.map(([id, name, shortName, globalPath, projectPath]) => [
-        id,
-        { id, name, shortName, globalPath, projectPath, detected: false },
+    AGENT_DEFINITIONS.map((definition) => [
+        definition.id,
+        {
+            id: definition.id,
+            name: definition.name,
+            shortName: definition.shortName,
+            globalPath: definition.globalPath,
+            projectPath: definition.projectPath,
+            detectPath: definition.detectPath,
+            detectPaths: definition.detectPaths,
+            universal: definition.universal,
+            detected: false,
+        },
     ]),
 );
 
+// Map old agent IDs to new ones for config migration
+const AGENT_RENAMES: Record<string, string> = {
+    clawdbot: "openclaw",
+};
+
 function createDefaultConfig(): Config {
     return {
         agents: { ...DEFAULT_AGENTS },
@@ -69,17 +442,34 @@ export class ConfigStore {
     private mergeWithDefaults(parsed: Partial<Config>): Config {
         const defaults = createDefaultConfig();
 
-        // Merge agents and ensure shortName exists for each
+        // Merge agents, handling renames and ensuring shortName/universal exist
         const mergedAgents = { ...defaults.agents };
         for (const [id, agent] of Object.entries(parsed.agents ?? {})) {
-            mergedAgents[id] = {
-                ...defaults.agents[id],
-                ...agent,
-                // Ensure shortName exists, fallback to first word of name or id
-                shortName: agent.shortName ?? defaults.agents[id]?.shortName ?? agent.name?.split(" ")[0] ?? id,
+            const newId = AGENT_RENAMES[id] ?? id;
+
+            // Skip old ID if it was renamed and the new ID already has parsed data
+            if (AGENT_RENAMES[id] && parsed.agents?.[newId]) continue;
+
+            const isRenamed = id !== newId;
+            const def = defaults.agents[newId];
+            mergedAgents[newId] = {
+                ...def,
+                ...(isRenamed ? { detected: agent.detected } : agent),
+                id: newId,
+                // Defaults always win for display name and universal flag
+                name: def?.name ?? agent.name ?? newId,
+                shortName: def?.shortName ?? agent.shortName ?? agent.name?.split(" ")[0] ?? newId,
+                detectPath: def?.detectPath ?? agent.detectPath,
+                detectPaths: def?.detectPaths ?? agent.detectPaths,
+                universal: def?.universal ?? false,
             };
         }
 
+        // Remove stale renamed keys
+        for (const oldId of Object.keys(AGENT_RENAMES)) {
+            delete mergedAgents[oldId];
+        }
+
         return {
             agents: mergedAgents,
             sync: { ...defaults.sync, ...parsed.sync },

package/src/core/registry-store.ts

@@ -2,17 +2,58 @@ import { readFile, writeFile, mkdir } from "node:fs/promises"
 import { dirname } from "node:path"
 import type { Registry } from "./types"
 
+const ASSIGNMENT_RENAMES: Record<string, string> = {
+  clawdbot: "openclaw",
+}
+
 function createEmptyRegistry(): Registry {
   return { version: 1, skills: {} }
 }
 
+function migrateAssignmentAgentIds(registry: Registry): Registry {
+  let changed = false
+  const migratedSkills: Registry["skills"] = {}
+
+  for (const [skillName, skill] of Object.entries(registry.skills)) {
+    const hasOpenClaw = Object.prototype.hasOwnProperty.call(skill.assignments, "openclaw")
+    let skillChanged = false
+    const migratedAssignments: typeof skill.assignments = {}
+
+    for (const [agentId, assignment] of Object.entries(skill.assignments)) {
+      const newAgentId = ASSIGNMENT_RENAMES[agentId] ?? agentId
+
+      if (newAgentId !== agentId) {
+        skillChanged = true
+      }
+
+      // If both old and new keys exist, keep explicit new key.
+      if (newAgentId === "openclaw" && hasOpenClaw && agentId !== "openclaw") {
+        continue
+      }
+
+      migratedAssignments[newAgentId] = assignment
+    }
+
+    if (skillChanged) {
+      changed = true
+      migratedSkills[skillName] = { ...skill, assignments: migratedAssignments }
+    } else {
+      migratedSkills[skillName] = skill
+    }
+  }
+
+  if (!changed) return registry
+  return { ...registry, skills: migratedSkills }
+}
+
 export class RegistryStore {
   constructor(private registryPath: string) {}
 
   async load(): Promise<Registry> {
     try {
       const content = await readFile(this.registryPath, "utf-8")
-      return JSON.parse(content) as Registry
+      const parsed = JSON.parse(content) as Registry
+      return migrateAssignmentAgentIds(parsed)
     } catch (err) {
       if ((err as NodeJS.ErrnoException).code === "ENOENT") {
         return createEmptyRegistry()

package/src/core/types.ts

@@ -6,6 +6,9 @@ export interface Agent {
   shortName: string // Short display name for matrix views (max 8 chars)
   globalPath: string
   projectPath: string
+  detectPath?: string // CLI-owned config path used for installation detection
+  detectPaths?: string[] // Multiple detection markers; detected when any path exists
+  universal: boolean // Uses .agents/skills as project path
   detected: boolean
 }