skillmux 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,27 +1,6 @@
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/agents.ts
-import { homedir } from "os";
-
-// src/config/resolve-skillmux-home.ts
-import { join, resolve } from "path";
-function buildConfigPath(skillmuxHome) {
-  return join(resolve(skillmuxHome), "config.json");
-}
-function resolveSkillmuxHome(homeDir) {
-  const resolvedHomeDir = resolve(homeDir);
-  const skillmuxHome = join(resolvedHomeDir, ".skillmux");
-  return {
-    skillmuxHome,
-    configPath: buildConfigPath(skillmuxHome)
-  };
-}
-
-// src/discovery/discover-agents.ts
-import * as fs2 from "fs/promises";
-import { join as join2, resolve as resolve2 } from "path";
-
 // src/config/default-agent-rules.ts
 var supportedPlatforms = ["win32", "linux", "darwin"];
 var builtInAgentIds = [
@@ -82,6 +61,27 @@ var defaultAgentRuleMap = Object.fromEntries(
   defaultAgentRules.map((rule) => [rule.id, rule])
 );
 
+// src/commands/agents.ts
+import { homedir } from "os";
+
+// src/config/resolve-skillmux-home.ts
+import { join, resolve } from "path";
+function buildConfigPath(skillmuxHome) {
+  return join(resolve(skillmuxHome), "config.json");
+}
+function resolveSkillmuxHome(homeDir) {
+  const resolvedHomeDir = resolve(homeDir);
+  const skillmuxHome = join(resolvedHomeDir, ".skillmux");
+  return {
+    skillmuxHome,
+    configPath: buildConfigPath(skillmuxHome)
+  };
+}
+
+// src/discovery/discover-agents.ts
+import * as fs2 from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
+
 // src/config/load-user-config.ts
 import * as fs from "fs/promises";
 import { z } from "zod";
@@ -93,6 +93,15 @@ var SkillMuxError = class extends Error {
     this.name = new.target.name;
   }
 };
+var InvalidIdentifierError = class extends SkillMuxError {
+  constructor(kind, value) {
+    super(`Invalid ${kind}: ${value}`);
+    this.kind = kind;
+    this.value = value;
+  }
+  kind;
+  value;
+};
 var ManifestValidationError = class extends SkillMuxError {
   constructor(message) {
     super(message);
@@ -123,6 +132,9 @@ function createEmptyUserConfig() {
     agents: {}
   };
 }
+function stripUtf8Bom(contents) {
+  return contents.charCodeAt(0) === 65279 ? contents.slice(1) : contents;
+}
 function formatValidationIssues(error) {
   return error.issues.map((issue) => {
     const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
@@ -133,7 +145,7 @@ async function loadUserConfig(skillmuxHome) {
   const configPath = buildConfigPath(skillmuxHome);
   try {
     const contents = await fs.readFile(configPath, "utf8");
-    const parsed = JSON.parse(contents);
+    const parsed = JSON.parse(stripUtf8Bom(contents));
     const validated = userConfigSchema.safeParse(parsed);
     if (!validated.success) {
       throw new UserConfigValidationError(
@@ -299,9 +311,212 @@ async function runAgents(options = {}) {
   };
 }
 
-// src/commands/config.ts
+// src/commands/config-add-agent.ts
 import { homedir as homedir2 } from "os";
+import { isAbsolute } from "path";
+
+// src/core/ids.ts
+var ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function normalizeId(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized.length > 0 ? normalized : "skill";
+}
+function isValidId(value) {
+  return ID_PATTERN.test(value);
+}
+
+// src/config/write-user-config.ts
+import * as fs3 from "fs/promises";
+async function writeUserConfig(skillmuxHome, config) {
+  const configPath = buildConfigPath(skillmuxHome);
+  await fs3.mkdir(skillmuxHome, { recursive: true });
+  await fs3.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return {
+    skillmuxHome,
+    configPath
+  };
+}
+
+// src/commands/config-add-agent.ts
+function normalizeRelativePath(value, field) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new UserConfigValidationError(`${field} must not be empty`);
+  }
+  if (isAbsolute(trimmed)) {
+    throw new UserConfigValidationError(`${field} must be a relative path`);
+  }
+  const normalized = trimmed.replaceAll("\\", "/");
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new UserConfigValidationError(`${field} must stay within the configured home-relative tree`);
+  }
+  return normalized.replace(/^\.\/+/, "");
+}
+function normalizeAgentId(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
+    throw new InvalidIdentifierError("agent id", value);
+  }
+  return normalizeId(trimmed);
+}
+function normalizePlatforms(value) {
+  if (value === void 0 || value.length === 0) {
+    return [process.platform];
+  }
+  const normalized = [...new Set(value.map((entry) => entry.trim().toLowerCase()))];
+  const invalid = normalized.filter(
+    (entry) => supportedPlatforms.includes(entry) === false
+  );
+  if (invalid.length > 0) {
+    throw new UserConfigValidationError(
+      `platform must be one of: ${supportedPlatforms.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function buildAgentOverride(options) {
+  const agentId = normalizeAgentId(options.id);
+  const agent = {
+    supportedPlatforms: normalizePlatforms(options.platforms),
+    homeRelativeRootPath: normalizeRelativePath(options.root, "root"),
+    skillsDirectoryPath: normalizeRelativePath(options.skills ?? "skills", "skills")
+  };
+  if (options.name !== void 0 && options.name.trim().length > 0) {
+    agent.stableName = options.name.trim();
+  }
+  if (options.disabledByDefault === true) {
+    agent.enabledByDefault = false;
+  }
+  return { agentId, agent };
+}
 function buildTableOutput2(result) {
+  const summary = printTable(
+    [
+      {
+        agentId: result.agentId,
+        configPath: result.configPath,
+        changed: String(result.changed)
+      }
+    ],
+    [
+      { key: "agentId", label: "Agent" },
+      { key: "configPath", label: "Config Path" },
+      { key: "changed", label: "Changed" }
+    ]
+  );
+  const detail = printTable(
+    [
+      {
+        stableName: result.agent.stableName ?? "",
+        platforms: (result.agent.supportedPlatforms ?? []).join(","),
+        root: result.agent.homeRelativeRootPath ?? "",
+        skills: result.agent.skillsDirectoryPath ?? "",
+        enabledByDefault: result.agent.enabledByDefault === void 0 ? "" : String(result.agent.enabledByDefault)
+      }
+    ],
+    [
+      { key: "stableName", label: "Name" },
+      { key: "platforms", label: "Platforms" },
+      { key: "root", label: "Root" },
+      { key: "skills", label: "Skills Dir" },
+      { key: "enabledByDefault", label: "Enabled By Default" }
+    ]
+  );
+  return `${summary}${detail}`;
+}
+async function runConfigAddAgent(options) {
+  const homeDir = options.homeDir ?? homedir2();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const { agentId, agent } = buildAgentOverride(options);
+  const previous = config.agents[agentId];
+  const changed = JSON.stringify(previous ?? null) !== JSON.stringify(agent);
+  const nextConfig = {
+    ...config,
+    agents: {
+      ...config.agents,
+      [agentId]: agent
+    }
+  };
+  await writeUserConfig(skillmuxHome, nextConfig);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed,
+    agent,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(resultWithoutOutput)
+  };
+}
+
+// src/commands/config-remove-agent.ts
+import { homedir as homedir3 } from "os";
+function normalizeAgentId2(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
+    throw new InvalidIdentifierError("agent id", value);
+  }
+  return normalizeId(trimmed);
+}
+function buildTableOutput3(result) {
+  return printTable(
+    [
+      {
+        agentId: result.agentId,
+        configPath: result.configPath,
+        changed: String(result.changed),
+        removed: String(result.removed)
+      }
+    ],
+    [
+      { key: "agentId", label: "Agent" },
+      { key: "configPath", label: "Config Path" },
+      { key: "changed", label: "Changed" },
+      { key: "removed", label: "Removed" }
+    ]
+  );
+}
+async function runConfigRemoveAgent(options) {
+  const homeDir = options.homeDir ?? homedir3();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const agentId = normalizeAgentId2(options.id);
+  const removed = agentId in config.agents;
+  const nextConfig = {
+    ...config,
+    agents: Object.fromEntries(
+      Object.entries(config.agents).filter(([currentAgentId]) => currentAgentId !== agentId)
+    )
+  };
+  if (removed) {
+    await writeUserConfig(skillmuxHome, nextConfig);
+  }
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed: removed,
+    removed,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput3(resultWithoutOutput)
+  };
+}
+
+// src/commands/config.ts
+import { homedir as homedir4 } from "os";
+function buildTableOutput4(result) {
   const summary = printTable(
     [
       {
@@ -336,35 +551,35 @@ ${printTable(agentRows, [
   ])}`;
 }
 async function runConfig(options = {}) {
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir4();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const config = await loadUserConfig(skillmuxHome);
   const resultWithoutOutput = {
     skillmuxHome,
-    configPath: resolvedPaths.configPath,
+    configPath: buildConfigPath(skillmuxHome),
     config
   };
   return {
     ...resultWithoutOutput,
-    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(resultWithoutOutput)
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput4(resultWithoutOutput)
   };
 }
 
 // src/commands/doctor.ts
-import * as fs8 from "fs/promises";
-import { homedir as homedir3 } from "os";
+import * as fs9 from "fs/promises";
+import { homedir as homedir5 } from "os";
 import { join as join5 } from "path";
 
 // src/discovery/scan-agent-skills.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 
 // src/discovery/infer-skill-entry.ts
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import { basename, resolve as resolve4 } from "path";
 
 // src/fs/path-utils.ts
-import * as fs3 from "fs/promises";
+import * as fs4 from "fs/promises";
 import { dirname, parse, relative, resolve as resolve3, sep } from "path";
 function normalizeAbsolutePath(path) {
   const normalized = resolve3(path);
@@ -395,7 +610,7 @@ async function assertNoSymlinkAncestors(path, options) {
   let current = options?.includeLeaf === true ? resolve3(path) : dirname(resolve3(path));
   while (true) {
     try {
-      const entry = await fs3.lstat(current);
+      const entry = await fs4.lstat(current);
       if (entry.isSymbolicLink()) {
         throw new Error(`Refusing to use path with symlink ancestor at ${current}`);
       }
@@ -419,10 +634,10 @@ function buildIssue(code, severity, message, path) {
 async function inferSkillEntry(options) {
   const absolutePath = resolve4(options.path);
   const skillName = basename(absolutePath);
-  const stats = await fs4.lstat(absolutePath);
+  const stats = await fs5.lstat(absolutePath);
   if (stats.isSymbolicLink()) {
     try {
-      const targetPath = await fs4.realpath(absolutePath);
+      const targetPath = await fs5.realpath(absolutePath);
       if (isPathInside(options.skillmuxHome, targetPath)) {
         return {
           entry: {
@@ -508,7 +723,7 @@ async function scanAgentSkills(agent, skillmuxHome) {
       issues: []
     };
   }
-  const directoryEntries = await fs5.readdir(agent.absoluteSkillsDirectoryPath, {
+  const directoryEntries = await fs6.readdir(agent.absoluteSkillsDirectoryPath, {
     withFileTypes: true
   });
   const sortedDirectoryEntries = [...directoryEntries].sort(
@@ -535,7 +750,7 @@ async function scanAgentSkills(agent, skillmuxHome) {
 }
 
 // src/manifest/read-manifest.ts
-import * as fs7 from "fs/promises";
+import * as fs8 from "fs/promises";
 import { join as join4, resolve as resolve5 } from "path";
 
 // src/manifest/build-empty-manifest.ts
@@ -555,18 +770,6 @@ function buildEmptyManifest(skillmuxHome) {
 
 // src/manifest/manifest-schema.ts
 import { z as z2 } from "zod";
-
-// src/core/ids.ts
-var ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function normalizeId(value) {
-  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized.length > 0 ? normalized : "skill";
-}
-function isValidId(value) {
-  return ID_PATTERN.test(value);
-}
-
-// src/manifest/manifest-schema.ts
 var idSchema = z2.string().min(1).refine(isValidId, "Expected a canonical lowercase slug identifier");
 var scanIssueSchema = z2.object({
   code: z2.string().min(1),
@@ -673,7 +876,7 @@ var manifestSchema = z2.object({
 
 // src/manifest/write-manifest.ts
 import { randomUUID } from "crypto";
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import { join as join3 } from "path";
 function getManifestPath(home) {
   return join3(home, "manifest.json");
@@ -682,16 +885,16 @@ function createManifestTempPath(manifestPath) {
   return `${manifestPath}.${process.pid}.${randomUUID()}.tmp`;
 }
 async function writeManifest(home, manifest) {
-  await fs6.mkdir(home, { recursive: true });
+  await fs7.mkdir(home, { recursive: true });
   const manifestPath = getManifestPath(home);
   const tempPath = createManifestTempPath(manifestPath);
   const contents = `${JSON.stringify(manifest, null, 2)}
 `;
-  await fs6.writeFile(tempPath, contents, "utf8");
+  await fs7.writeFile(tempPath, contents, "utf8");
   try {
-    await fs6.rename(tempPath, manifestPath);
+    await fs7.rename(tempPath, manifestPath);
   } catch (error) {
-    await fs6.unlink(tempPath).catch(() => void 0);
+    await fs7.unlink(tempPath).catch(() => void 0);
     throw error;
   }
 }
@@ -713,7 +916,7 @@ function formatValidationIssues2(error) {
 async function readManifest(home) {
   const manifestPath = getManifestPath2(home);
   try {
-    const contents = await fs7.readFile(manifestPath, "utf8");
+    const contents = await fs8.readFile(manifestPath, "utf8");
     const parsedJson = JSON.parse(contents);
     const parsedManifest = manifestSchema.safeParse(parsedJson);
     if (!parsedManifest.success) {
@@ -748,7 +951,7 @@ function buildIssue2(code, severity, message, path) {
 }
 async function pathExists2(path) {
   try {
-    await fs8.access(path);
+    await fs9.access(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -812,7 +1015,7 @@ function addConflictingAgentPathIssues(agents, issues) {
     );
   }
 }
-function buildTableOutput3(issues) {
+function buildTableOutput5(issues) {
   if (issues.length === 0) {
     return "No doctor issues found.\n";
   }
@@ -844,7 +1047,7 @@ function buildJsonOutput(result) {
   });
 }
 async function runDoctor(options = {}) {
-  const homeDir = options.homeDir ?? homedir3();
+  const homeDir = options.homeDir ?? homedir5();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const [manifest, config, agents] = await Promise.all([
@@ -881,51 +1084,127 @@ async function runDoctor(options = {}) {
   };
   return {
     ...resultWithoutOutput,
-    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput3(dedupedIssues)
+    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput5(dedupedIssues)
   };
 }
 
 // src/commands/disable.ts
-import * as fs11 from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
+import * as fs13 from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join7, resolve as resolve8 } from "path";
+
+// src/fs/safe-copy.ts
+import * as fs10 from "fs/promises";
+import { dirname as dirname2, join as join6, resolve as resolve6 } from "path";
+async function assertDirectory(path) {
+  const entry = await fs10.lstat(path);
+  if (!entry.isDirectory()) {
+    throw new Error(`Expected a directory at ${path}`);
+  }
+}
+async function assertRegularFile(path, label) {
+  const entry = await fs10.lstat(path);
+  if (!entry.isFile()) {
+    throw new Error(`Expected ${label} to be a regular file at ${path}`);
+  }
+}
+async function assertTargetDoesNotExist(path) {
+  try {
+    await fs10.lstat(path);
+    throw new Error(`Refusing to overwrite existing path at ${path}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function copyDirectoryContents(sourcePath, targetPath) {
+  await fs10.mkdir(targetPath, { recursive: true });
+  const entries = await fs10.readdir(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntryPath = join6(sourcePath, entry.name);
+    const targetEntryPath = join6(targetPath, entry.name);
+    const entryStats = await fs10.lstat(sourceEntryPath);
+    if (entryStats.isSymbolicLink()) {
+      throw new Error(`Refusing to copy source symlink at ${sourceEntryPath}`);
+    }
+    if (entryStats.isDirectory()) {
+      await copyDirectoryContents(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+    if (entryStats.isFile()) {
+      await fs10.mkdir(dirname2(targetEntryPath), { recursive: true });
+      await fs10.copyFile(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+    throw new Error(`Unsupported filesystem entry at ${sourceEntryPath}`);
+  }
+}
+async function assertSkillSourceLayout(sourcePath) {
+  const resolvedSourcePath = resolve6(sourcePath);
+  const skillFilePath = join6(resolvedSourcePath, "SKILL.md");
+  await assertNoSymlinkAncestors(resolvedSourcePath, { includeLeaf: true });
+  await assertDirectory(resolvedSourcePath);
+  try {
+    await assertRegularFile(skillFilePath, "SKILL.md");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Refusing to import ${resolvedSourcePath} without a root SKILL.md`);
+    }
+    throw error;
+  }
+}
+async function copySkillContentsToManagedStore(sourcePath, targetPath) {
+  const resolvedSourcePath = resolve6(sourcePath);
+  const resolvedTargetPath = resolve6(targetPath);
+  if (pathsAreEqual(resolvedSourcePath, resolvedTargetPath)) {
+    throw new Error("Source and target paths must differ");
+  }
+  if (isPathInside(resolvedSourcePath, resolvedTargetPath)) {
+    throw new Error("Refusing to copy into a child of the source directory");
+  }
+  await assertSkillSourceLayout(resolvedSourcePath);
+  await assertNoSymlinkAncestors(resolvedTargetPath);
+  await assertTargetDoesNotExist(resolvedTargetPath);
+  await copyDirectoryContents(resolvedSourcePath, resolvedTargetPath);
+}
 
 // src/fs/link-ops.ts
-import * as fs9 from "fs/promises";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import * as fs11 from "fs/promises";
+import { dirname as dirname3, resolve as resolve7 } from "path";
 var directoryLinkType = process.platform === "win32" ? "junction" : "dir";
 async function createManagedLink(linkPath, targetPath) {
-  const resolvedLinkPath = resolve6(linkPath);
-  const resolvedTargetPath = resolve6(targetPath);
+  const resolvedLinkPath = resolve7(linkPath);
+  const resolvedTargetPath = resolve7(targetPath);
   await assertNoSymlinkAncestors(resolvedLinkPath);
   await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
-  await fs9.mkdir(dirname2(resolvedLinkPath), { recursive: true });
+  await fs11.mkdir(dirname3(resolvedLinkPath), { recursive: true });
   try {
-    const existingEntry = await fs9.lstat(resolvedLinkPath);
+    const existingEntry = await fs11.lstat(resolvedLinkPath);
     if (!existingEntry.isSymbolicLink()) {
       throw new Error(`Refusing to replace non-link entry at ${resolvedLinkPath}`);
     }
-    const currentTargetPath = await fs9.realpath(resolvedLinkPath);
+    const currentTargetPath = await fs11.realpath(resolvedLinkPath);
     if (pathsAreEqual(currentTargetPath, resolvedTargetPath)) {
       return;
     }
     throw new Error(`Refusing to replace link at ${resolvedLinkPath}`);
   } catch (error) {
-    if (error.code === "ENOENT" && await fs9.lstat(resolvedLinkPath).then((entry) => entry.isSymbolicLink()).catch(() => false)) {
-      await fs9.rm(resolvedLinkPath, { recursive: true, force: false });
+    if (error.code === "ENOENT" && await fs11.lstat(resolvedLinkPath).then((entry) => entry.isSymbolicLink()).catch(() => false)) {
+      await fs11.rm(resolvedLinkPath, { recursive: true, force: false });
     } else if (error.code !== "ENOENT") {
       throw error;
     }
   }
-  await fs9.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+  await fs11.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
 }
 async function isLinkPointingToTarget(linkPath, targetPath) {
   try {
-    const entry = await fs9.lstat(linkPath);
+    const entry = await fs11.lstat(linkPath);
     if (!entry.isSymbolicLink()) {
       return false;
     }
-    const resolvedTargetPath = await fs9.realpath(linkPath);
+    const resolvedTargetPath = await fs11.realpath(linkPath);
     return pathsAreEqual(resolvedTargetPath, targetPath);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -936,14 +1215,14 @@ async function isLinkPointingToTarget(linkPath, targetPath) {
 }
 
 // src/fs/safe-remove-link.ts
-import * as fs10 from "fs/promises";
+import * as fs12 from "fs/promises";
 async function safeRemoveLink(path) {
   try {
-    const entry = await fs10.lstat(path);
+    const entry = await fs12.lstat(path);
     if (!entry.isSymbolicLink()) {
       return false;
     }
-    await fs10.rm(path, { recursive: true, force: false });
+    await fs12.rm(path, { recursive: true, force: false });
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -983,6 +1262,38 @@ function upsertActivation(manifest, activation) {
   }
   manifest.activations[index] = activation;
 }
+function buildManagedSkillPath(skillmuxHome, skillId) {
+  return resolve8(skillmuxHome, "skills", skillId);
+}
+async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName, linkPath, timestamp) {
+  try {
+    const entry = await fs13.lstat(linkPath);
+    if (!entry.isSymbolicLink()) {
+      return void 0;
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const sourcePath = await fs13.realpath(linkPath);
+  await assertSkillSourceLayout(sourcePath);
+  const managedSkillPath = buildManagedSkillPath(skillmuxHome, skillId);
+  await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
+  const skill = {
+    id: skillId,
+    name: skillName,
+    path: managedSkillPath,
+    source: {
+      kind: "imported",
+      path: sourcePath
+    },
+    importedAt: timestamp
+  };
+  manifest.skills[skillId] = skill;
+  return { skill, sourcePath };
+}
 async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
   const agentId = normalizeId(agentName);
   const agents = await discoverAgents({ homeDir, skillmuxHome });
@@ -997,7 +1308,7 @@ async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
 }
 async function pathExists3(path) {
   try {
-    await fs11.lstat(path);
+    await fs13.lstat(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1007,28 +1318,38 @@ async function pathExists3(path) {
   }
 }
 async function runDisable(options) {
-  const homeDir = options.homeDir ?? homedir4();
+  const homeDir = options.homeDir ?? homedir6();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
   const manifest = await readManifest(skillmuxHome);
   const skillId = normalizeId(options.skill);
-  const skill = manifest.skills[skillId];
+  const agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
+  const linkPath = join7(agent.absoluteSkillsDirectoryPath, skillId);
+  const adoption = manifest.skills[skillId] ? void 0 : await tryAdoptManagedSkill(
+    manifest,
+    skillmuxHome,
+    skillId,
+    options.skill,
+    linkPath,
+    timestamp
+  );
+  const skill = manifest.skills[skillId] ?? adoption?.skill;
   if (skill === void 0) {
     throw new Error(`Managed skill not found: ${skillId}`);
   }
-  const agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
   const currentActivation = manifest.activations.find(
     (entry) => entry.skillId === skill.id && entry.agentId === agent.id
   );
-  const linkPath = currentActivation?.linkPath ?? join6(agent.absoluteSkillsDirectoryPath, skill.id);
+  const activationLinkPath = currentActivation?.linkPath ?? linkPath;
   const agentRecord = buildAgentRecord(agent, timestamp);
   manifest.agents[agent.id] = agentRecord;
-  const linkMatchesSkill = await isLinkPointingToTarget(linkPath, skill.path);
-  if (!linkMatchesSkill && await pathExists3(linkPath)) {
+  const adoptedLinkRemoved = adoption !== void 0 ? await safeRemoveLink(linkPath) : false;
+  const linkMatchesSkill = adoption === void 0 ? await isLinkPointingToTarget(activationLinkPath, skill.path) : false;
+  if (adoption === void 0 && !linkMatchesSkill && await pathExists3(activationLinkPath)) {
     throw new Error(`Refusing to disable non-managed entry at ${linkPath}`);
   }
-  const removedLink = linkMatchesSkill ? await safeRemoveLink(linkPath) : false;
+  const removedLink = adoptedLinkRemoved ? true : linkMatchesSkill ? await safeRemoveLink(activationLinkPath) : false;
   if (removedLink === false && currentActivation?.state !== "enabled") {
     return {
       changed: false,
@@ -1055,9 +1376,9 @@ async function runDisable(options) {
 }
 
 // src/commands/enable.ts
-import * as fs12 from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import * as fs14 from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
 function buildAgentRecord2(agent, timestamp) {
   return {
     id: agent.id,
@@ -1100,7 +1421,7 @@ async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
   return agent;
 }
 async function runEnable(options) {
-  const homeDir = options.homeDir ?? homedir5();
+  const homeDir = options.homeDir ?? homedir7();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -1111,13 +1432,13 @@ async function runEnable(options) {
     throw new Error(`Managed skill not found: ${skillId}`);
   }
   const agent = await resolveTargetAgent2(homeDir, skillmuxHome, options.agent);
-  const linkPath = join7(agent.absoluteSkillsDirectoryPath, skill.id);
+  const linkPath = join8(agent.absoluteSkillsDirectoryPath, skill.id);
   const currentActivation = manifest.activations.find(
     (entry) => entry.skillId === skill.id && entry.agentId === agent.id
   );
   const agentRecord = buildAgentRecord2(agent, timestamp);
   manifest.agents[agent.id] = agentRecord;
-  await fs12.mkdir(agent.absoluteSkillsDirectoryPath, { recursive: true });
+  await fs14.mkdir(agent.absoluteSkillsDirectoryPath, { recursive: true });
   const linkAlreadyEnabled = await isLinkPointingToTarget(linkPath, skill.path);
   const activationAlreadyEnabled = currentActivation?.state === "enabled" && currentActivation.linkPath === linkPath;
   if (linkAlreadyEnabled && activationAlreadyEnabled) {
@@ -1153,98 +1474,20 @@ async function runEnable(options) {
 }
 
 // src/commands/import.ts
-import { resolve as resolve8 } from "path";
-import { homedir as homedir6 } from "os";
-
-// src/fs/safe-copy.ts
-import * as fs13 from "fs/promises";
-import { dirname as dirname3, join as join8, resolve as resolve7 } from "path";
-async function assertDirectory(path) {
-  const entry = await fs13.lstat(path);
-  if (!entry.isDirectory()) {
-    throw new Error(`Expected a directory at ${path}`);
-  }
-}
-async function assertRegularFile(path, label) {
-  const entry = await fs13.lstat(path);
-  if (!entry.isFile()) {
-    throw new Error(`Expected ${label} to be a regular file at ${path}`);
-  }
-}
-async function assertTargetDoesNotExist(path) {
-  try {
-    await fs13.lstat(path);
-    throw new Error(`Refusing to overwrite existing path at ${path}`);
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-}
-async function copyDirectoryContents(sourcePath, targetPath) {
-  await fs13.mkdir(targetPath, { recursive: true });
-  const entries = await fs13.readdir(sourcePath, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourceEntryPath = join8(sourcePath, entry.name);
-    const targetEntryPath = join8(targetPath, entry.name);
-    const entryStats = await fs13.lstat(sourceEntryPath);
-    if (entryStats.isSymbolicLink()) {
-      throw new Error(`Refusing to copy source symlink at ${sourceEntryPath}`);
-    }
-    if (entryStats.isDirectory()) {
-      await copyDirectoryContents(sourceEntryPath, targetEntryPath);
-      continue;
-    }
-    if (entryStats.isFile()) {
-      await fs13.mkdir(dirname3(targetEntryPath), { recursive: true });
-      await fs13.copyFile(sourceEntryPath, targetEntryPath);
-      continue;
-    }
-    throw new Error(`Unsupported filesystem entry at ${sourceEntryPath}`);
-  }
-}
-async function assertSkillSourceLayout(sourcePath) {
-  const resolvedSourcePath = resolve7(sourcePath);
-  const skillFilePath = join8(resolvedSourcePath, "SKILL.md");
-  await assertNoSymlinkAncestors(resolvedSourcePath, { includeLeaf: true });
-  await assertDirectory(resolvedSourcePath);
-  try {
-    await assertRegularFile(skillFilePath, "SKILL.md");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`Refusing to import ${resolvedSourcePath} without a root SKILL.md`);
-    }
-    throw error;
-  }
-}
-async function copySkillContentsToManagedStore(sourcePath, targetPath) {
-  const resolvedSourcePath = resolve7(sourcePath);
-  const resolvedTargetPath = resolve7(targetPath);
-  if (pathsAreEqual(resolvedSourcePath, resolvedTargetPath)) {
-    throw new Error("Source and target paths must differ");
-  }
-  if (isPathInside(resolvedSourcePath, resolvedTargetPath)) {
-    throw new Error("Refusing to copy into a child of the source directory");
-  }
-  await assertSkillSourceLayout(resolvedSourcePath);
-  await assertNoSymlinkAncestors(resolvedTargetPath);
-  await assertTargetDoesNotExist(resolvedTargetPath);
-  await copyDirectoryContents(resolvedSourcePath, resolvedTargetPath);
-}
-
-// src/commands/import.ts
-function buildManagedSkillPath(skillmuxHome, skillId) {
-  return resolve8(skillmuxHome, "skills", skillId);
+import { resolve as resolve9 } from "path";
+import { homedir as homedir8 } from "os";
+function buildManagedSkillPath2(skillmuxHome, skillId) {
+  return resolve9(skillmuxHome, "skills", skillId);
 }
 async function runImport(options) {
-  const homeDir = options.homeDir ?? homedir6();
+  const homeDir = options.homeDir ?? homedir8();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const sourcePath = resolve8(options.sourcePath);
+  const sourcePath = resolve9(options.sourcePath);
   const skillId = normalizeId(options.skillName);
   const importedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
   const manifest = await readManifest(skillmuxHome);
-  const managedSkillPath = buildManagedSkillPath(skillmuxHome, skillId);
+  const managedSkillPath = buildManagedSkillPath2(skillmuxHome, skillId);
   await assertSkillSourceLayout(sourcePath);
   if (manifest.skills[skillId] !== void 0) {
     throw new Error(`Managed skill already exists for ${skillId}`);
@@ -1271,7 +1514,7 @@ async function runImport(options) {
 }
 
 // src/commands/scan.ts
-import { homedir as homedir7 } from "os";
+import { homedir as homedir9 } from "os";
 
 // src/output/format-issue.ts
 function formatIssue(issue) {
@@ -1332,7 +1575,7 @@ ${result.issues.map(formatIssue).join("\n")}
 `;
 }
 async function runScan(options = {}) {
-  const homeDir = options.homeDir ?? homedir7();
+  const homeDir = options.homeDir ?? homedir9();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const manifest = await readManifest(skillmuxHome);
@@ -1381,6 +1624,13 @@ function buildRecordsView(scanResult) {
 }
 function buildAgentsView(scanResult) {
   const groups = /* @__PURE__ */ new Map();
+  for (const agent of scanResult.agents) {
+    groups.set(agent.id, {
+      agentId: agent.id,
+      agentName: agent.stableName,
+      entries: []
+    });
+  }
   for (const entry of scanResult.entries) {
     const current = groups.get(entry.agentId) ?? {
       agentId: entry.agentId,
@@ -1400,6 +1650,12 @@ function buildAgentsView(scanResult) {
 }
 function buildSkillsView(scanResult) {
   const groups = /* @__PURE__ */ new Map();
+  for (const skill of Object.values(scanResult.manifest.skills)) {
+    groups.set(skill.id, {
+      skillName: skill.id,
+      entries: []
+    });
+  }
   for (const entry of scanResult.entries) {
     const current = groups.get(entry.skillName) ?? {
       skillName: entry.skillName,
@@ -1425,7 +1681,7 @@ function buildListData(scanResult, view) {
   }
   return buildRecordsView(scanResult);
 }
-function buildTableOutput4(data, view) {
+function buildTableOutput6(data, view) {
   if (view === "agents") {
     const agentRows = data.agents;
     return printTable(
@@ -1475,7 +1731,7 @@ async function runList(options = {}) {
   const data = buildListData(scanResult, view);
   return {
     data,
-    output: format === "json" ? printJson(data) : buildTableOutput4(data, view)
+    output: format === "json" ? printJson(data) : buildTableOutput6(data, view)
   };
 }
 
@@ -1509,10 +1765,37 @@ function buildCli() {
     const result = await runDoctor({ json: options.json === true });
     process.stdout.write(result.output);
   });
-  program.command("config").option("--json", "Emit structured JSON output").action(async (options) => {
+  const configCommand = program.command("config");
+  configCommand.option("--json", "Emit structured JSON output").action(async (options) => {
     const result = await runConfig({ json: options.json === true });
     process.stdout.write(result.output);
   });
+  configCommand.command("add-agent").requiredOption("--id <id>", "Agent id").requiredOption("--root <path>", "Home-relative root path").option("--skills <path>", "Skills directory path relative to the agent root", "skills").option("--name <name>", "Stable display name").option(
+    "--platform <platform>",
+    `Supported platform (${supportedPlatforms.join(", ")})`,
+    (value, previous = []) => [...previous, value],
+    []
+  ).option("--disabled-by-default", "Mark this custom agent as disabled by default").option("--json", "Emit structured JSON output").action(
+    async (options) => {
+      const result = await runConfigAddAgent({
+        id: options.id,
+        root: options.root,
+        skills: options.skills,
+        name: options.name,
+        platforms: options.platform,
+        disabledByDefault: options.disabledByDefault === true,
+        json: options.json === true
+      });
+      process.stdout.write(result.output);
+    }
+  );
+  configCommand.command("remove-agent").requiredOption("--id <id>", "Agent id").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runConfigRemoveAgent({
+      id: options.id,
+      json: options.json === true
+    });
+    process.stdout.write(result.output);
+  });
   program.command("enable").requiredOption("--skill <skill>", "Managed skill name or id").requiredOption("--agent <agent>", "Target agent id").action(async (options) => {
     const result = await runEnable({
       skill: options.skill,