skillmux 0.1.1 → 0.1.2

package/dist/index.js

@@ -61,30 +61,9 @@ var defaultAgentRuleMap = Object.fromEntries(
   defaultAgentRules.map((rule) => [rule.id, rule])
 );
 
-// src/commands/agents.ts
+// src/commands/adopt.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";
+import { join as join7, resolve as resolve8 } from "path";
 
 // src/core/errors.ts
 var SkillMuxError = class extends Error {
@@ -112,8 +91,43 @@ var UserConfigValidationError = class extends SkillMuxError {
     super(message);
   }
 };
+var AdoptionError = class extends SkillMuxError {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// 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/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";
 var supportedPlatformSchema = z.enum(supportedPlatforms);
 var agentOverrideSchema = z.object({
   stableName: z.string().min(1).optional(),
@@ -249,422 +263,95 @@ async function discoverAgents(options) {
   return discoveredAgents;
 }
 
-// src/output/print-json.ts
-function printJson(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-
-// src/output/print-table.ts
-function printTable(rows, columns) {
-  const renderedRows = rows.map(
-    (row) => columns.map((column) => String(row[column.key] ?? ""))
-  );
-  const widths = columns.map(
-    (column, index) => Math.max(
-      column.label.length,
-      ...renderedRows.map((row) => row[index]?.length ?? 0)
-    )
-  );
-  const header = columns.map((column, index) => column.label.padEnd(widths[index])).join("  ");
-  const separator = widths.map((width) => "-".repeat(width)).join("  ");
-  const body = renderedRows.map(
-    (row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ")
-  );
-  return `${[header, separator, ...body].join("\n")}
-`;
-}
-
-// src/commands/agents.ts
-function buildTableOutput(agents) {
-  return printTable(
-    agents.map((agent) => ({
-      id: agent.id,
-      name: agent.stableName,
-      path: agent.absoluteSkillsDirectoryPath,
-      exists: String(agent.exists),
-      supported: String(agent.supportedOnPlatform),
-      discovery: agent.discovery
-    })),
-    [
-      { key: "id", label: "Agent" },
-      { key: "name", label: "Name" },
-      { key: "path", label: "Path" },
-      { key: "exists", label: "Exists" },
-      { key: "supported", label: "Supported" },
-      { key: "discovery", label: "Discovery" }
-    ]
-  );
-}
-async function runAgents(options = {}) {
-  const homeDir = options.homeDir ?? homedir();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const agents = await discoverAgents({
-    homeDir,
-    skillmuxHome,
-    platform: options.platform
-  });
-  return {
-    agents,
-    output: options.json === true ? printJson(agents) : buildTableOutput(agents)
-  };
-}
-
-// src/commands/config-add-agent.ts
-import { homedir as homedir2 } from "os";
-import { isAbsolute } from "path";
+// src/discovery/scan-agent-skills.ts
+import * as fs5 from "fs/promises";
+import { join as join3 } 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/discovery/infer-skill-entry.ts
+import * as fs4 from "fs/promises";
+import { basename, resolve as resolve4 } from "path";
 
-// src/config/write-user-config.ts
+// src/fs/path-utils.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
-  };
+import { dirname, parse, relative, resolve as resolve3, sep } from "path";
+function normalizeAbsolutePath(path) {
+  const normalized = resolve3(path);
+  return process.platform === "win32" ? normalized.replaceAll("/", "\\").toLowerCase() : normalized;
 }
-
-// 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`);
+function pathsAreEqual(left, right) {
+  return normalizeAbsolutePath(left) === normalizeAbsolutePath(right);
+}
+function isPathInside(parentPath, childPath) {
+  const parent = normalizeAbsolutePath(parentPath);
+  const child = normalizeAbsolutePath(childPath);
+  if (parse(parent).root !== parse(child).root) {
+    return false;
   }
-  if (isAbsolute(trimmed)) {
-    throw new UserConfigValidationError(`${field} must be a relative path`);
+  const relativePath = relative(parent, child);
+  if (relativePath === "") {
+    return true;
   }
-  const normalized = trimmed.replaceAll("\\", "/");
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
-    throw new UserConfigValidationError(`${field} must stay within the configured home-relative tree`);
+  if (relativePath === "..") {
+    return false;
   }
-  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);
+  if (relativePath.startsWith(`..${sep}`)) {
+    return false;
   }
-  return normalizeId(trimmed);
+  return true;
 }
-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(", ")}`
-    );
+async function assertNoSymlinkAncestors(path, options) {
+  let current = options?.includeLeaf === true ? resolve3(path) : dirname(resolve3(path));
+  while (true) {
+    try {
+      const entry = await fs3.lstat(current);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Refusing to use path with symlink ancestor at ${current}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
   }
-  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 };
+
+// src/discovery/infer-skill-entry.ts
+function buildIssue(code, severity, message, path) {
+  return { code, severity, message, path };
 }
-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(
-    [
-      {
-        skillmuxHome: result.skillmuxHome,
-        configPath: result.configPath,
-        overrides: String(Object.keys(result.config.agents).length)
-      }
-    ],
-    [
-      { key: "skillmuxHome", label: "SkillMux Home" },
-      { key: "configPath", label: "Config Path" },
-      { key: "overrides", label: "Overrides" }
-    ]
-  );
-  const agentRows = Object.entries(result.config.agents).sort(([left], [right]) => left.localeCompare(right)).map(([agentId, agent]) => ({
-    agentId,
-    stableName: agent.stableName ?? "",
-    root: agent.homeRelativeRootPath ?? "",
-    skills: agent.skillsDirectoryPath ?? ""
-  }));
-  if (agentRows.length === 0) {
-    return `${summary}
-No user overrides configured.
-`;
-  }
-  return `${summary}
-${printTable(agentRows, [
-    { key: "agentId", label: "Agent" },
-    { key: "stableName", label: "Name" },
-    { key: "root", label: "Root" },
-    { key: "skills", label: "Skills Dir" }
-  ])}`;
-}
-async function runConfig(options = {}) {
-  const homeDir = options.homeDir ?? homedir4();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const config = await loadUserConfig(skillmuxHome);
-  const resultWithoutOutput = {
-    skillmuxHome,
-    configPath: buildConfigPath(skillmuxHome),
-    config
-  };
-  return {
-    ...resultWithoutOutput,
-    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput4(resultWithoutOutput)
-  };
-}
-
-// src/commands/doctor.ts
-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 fs6 from "fs/promises";
-
-// src/discovery/infer-skill-entry.ts
-import * as fs5 from "fs/promises";
-import { basename, resolve as resolve4 } from "path";
-
-// src/fs/path-utils.ts
-import * as fs4 from "fs/promises";
-import { dirname, parse, relative, resolve as resolve3, sep } from "path";
-function normalizeAbsolutePath(path) {
-  const normalized = resolve3(path);
-  return process.platform === "win32" ? normalized.replaceAll("/", "\\").toLowerCase() : normalized;
-}
-function pathsAreEqual(left, right) {
-  return normalizeAbsolutePath(left) === normalizeAbsolutePath(right);
-}
-function isPathInside(parentPath, childPath) {
-  const parent = normalizeAbsolutePath(parentPath);
-  const child = normalizeAbsolutePath(childPath);
-  if (parse(parent).root !== parse(child).root) {
-    return false;
-  }
-  const relativePath = relative(parent, child);
-  if (relativePath === "") {
-    return true;
-  }
-  if (relativePath === "..") {
-    return false;
-  }
-  if (relativePath.startsWith(`..${sep}`)) {
-    return false;
-  }
-  return true;
-}
-async function assertNoSymlinkAncestors(path, options) {
-  let current = options?.includeLeaf === true ? resolve3(path) : dirname(resolve3(path));
-  while (true) {
-    try {
-      const entry = await fs4.lstat(current);
-      if (entry.isSymbolicLink()) {
-        throw new Error(`Refusing to use path with symlink ancestor at ${current}`);
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return;
-    }
-    current = parent;
-  }
-}
-
-// src/discovery/infer-skill-entry.ts
-function buildIssue(code, severity, message, path) {
-  return { code, severity, message, path };
-}
-async function inferSkillEntry(options) {
-  const absolutePath = resolve4(options.path);
-  const skillName = basename(absolutePath);
-  const stats = await fs5.lstat(absolutePath);
-  if (stats.isSymbolicLink()) {
-    try {
-      const targetPath = await fs5.realpath(absolutePath);
-      if (isPathInside(options.skillmuxHome, targetPath)) {
-        return {
-          entry: {
-            agentId: options.agentId,
-            agentName: options.agentName,
-            skillName,
-            kind: "managed-link",
-            path: absolutePath,
-            targetPath
-          }
-        };
+async function inferSkillEntry(options) {
+  const absolutePath = resolve4(options.path);
+  const skillName = basename(absolutePath);
+  const stats = await fs4.lstat(absolutePath);
+  if (stats.isSymbolicLink()) {
+    try {
+      const targetPath = await fs4.realpath(absolutePath);
+      if (isPathInside(options.skillmuxHome, targetPath)) {
+        return {
+          entry: {
+            agentId: options.agentId,
+            agentName: options.agentName,
+            skillName,
+            kind: "managed-link",
+            path: absolutePath,
+            targetPath
+          }
+        };
       }
       return {
         entry: {
           agentId: options.agentId,
           agentName: options.agentName,
           skillName,
-          kind: "unknown",
+          kind: "unmanaged-link",
           path: absolutePath,
           targetPath
-        },
-        issue: buildIssue(
-          "unknown-entry",
-          "warning",
-          "Skill entry is a link that points outside the SkillMux managed store",
-          absolutePath
-        )
+        }
       };
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -723,7 +410,7 @@ async function scanAgentSkills(agent, skillmuxHome) {
       issues: []
     };
   }
-  const directoryEntries = await fs6.readdir(agent.absoluteSkillsDirectoryPath, {
+  const directoryEntries = await fs5.readdir(agent.absoluteSkillsDirectoryPath, {
     withFileTypes: true
   });
   const sortedDirectoryEntries = [...directoryEntries].sort(
@@ -735,7 +422,7 @@ async function scanAgentSkills(agent, skillmuxHome) {
     const result = await inferSkillEntry({
       agentId: agent.id,
       agentName: agent.stableName,
-      path: `${agent.absoluteSkillsDirectoryPath}/${directoryEntry.name}`,
+      path: join3(agent.absoluteSkillsDirectoryPath, directoryEntry.name),
       skillmuxHome
     });
     entries.push(result.entry);
@@ -749,9 +436,201 @@ async function scanAgentSkills(agent, skillmuxHome) {
   };
 }
 
-// src/manifest/read-manifest.ts
-import * as fs8 from "fs/promises";
-import { join as join4, resolve as resolve5 } from "path";
+// src/fs/safe-copy.ts
+import * as fs6 from "fs/promises";
+import { dirname as dirname2, join as join4, resolve as resolve5 } from "path";
+async function assertDirectory(path) {
+  const entry = await fs6.lstat(path);
+  if (!entry.isDirectory()) {
+    throw new Error(`Expected a directory at ${path}`);
+  }
+}
+async function assertRegularFile(path, label) {
+  const entry = await fs6.lstat(path);
+  if (!entry.isFile()) {
+    throw new Error(`Expected ${label} to be a regular file at ${path}`);
+  }
+}
+async function assertTargetDoesNotExist(path) {
+  try {
+    await fs6.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 fs6.mkdir(targetPath, { recursive: true });
+  const entries = await fs6.readdir(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntryPath = join4(sourcePath, entry.name);
+    const targetEntryPath = join4(targetPath, entry.name);
+    const entryStats = await fs6.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 fs6.mkdir(dirname2(targetEntryPath), { recursive: true });
+      await fs6.copyFile(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+    throw new Error(`Unsupported filesystem entry at ${sourceEntryPath}`);
+  }
+}
+async function assertSkillSourceLayout(sourcePath) {
+  const resolvedSourcePath = resolve5(sourcePath);
+  const skillFilePath = join4(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 hasRootSkillFile(sourcePath) {
+  const resolvedSourcePath = resolve5(sourcePath);
+  const skillFilePath = join4(resolvedSourcePath, "SKILL.md");
+  try {
+    await assertDirectory(resolvedSourcePath);
+    await assertRegularFile(skillFilePath, "SKILL.md");
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function copySkillContentsToManagedStore(sourcePath, targetPath) {
+  const resolvedSourcePath = resolve5(sourcePath);
+  const resolvedTargetPath = resolve5(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/core/batch-operation-error.ts
+function getCauseMessage(cause) {
+  if (cause instanceof Error) {
+    return cause.message;
+  }
+  return String(cause);
+}
+function buildBatchOperationMessage(options) {
+  const completedSuffix = options.completedItems.length > 0 ? ` after ${options.completedAction}: ${options.completedItems.join(", ")}` : "";
+  return `Failed to ${options.failedAction}${completedSuffix}: ${getCauseMessage(options.cause)}`;
+}
+var BatchOperationError = class extends Error {
+  operation;
+  failedItem;
+  completedItems;
+  cause;
+  constructor(options) {
+    super(buildBatchOperationMessage(options), { cause: options.cause });
+    this.name = "BatchOperationError";
+    this.operation = options.operation;
+    this.failedItem = options.failedItem;
+    this.completedItems = [...options.completedItems];
+    this.cause = options.cause;
+  }
+};
+
+// src/fs/link-ops.ts
+import * as fs7 from "fs/promises";
+import { dirname as dirname3, resolve as resolve6 } from "path";
+var directoryLinkType = process.platform === "win32" ? "junction" : "dir";
+async function createManagedLink(linkPath, targetPath) {
+  const resolvedLinkPath = resolve6(linkPath);
+  const resolvedTargetPath = resolve6(targetPath);
+  await assertNoSymlinkAncestors(resolvedLinkPath);
+  await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
+  await fs7.mkdir(dirname3(resolvedLinkPath), { recursive: true });
+  try {
+    const existingEntry = await fs7.lstat(resolvedLinkPath);
+    if (!existingEntry.isSymbolicLink()) {
+      throw new Error(`Refusing to replace non-link entry at ${resolvedLinkPath}`);
+    }
+    const currentTargetPath = await fs7.realpath(resolvedLinkPath);
+    if (pathsAreEqual(currentTargetPath, resolvedTargetPath)) {
+      return;
+    }
+    throw new Error(`Refusing to replace link at ${resolvedLinkPath}`);
+  } catch (error) {
+    if (error.code === "ENOENT" && await fs7.lstat(resolvedLinkPath).then((entry) => entry.isSymbolicLink()).catch(() => false)) {
+      await fs7.rm(resolvedLinkPath, { recursive: true, force: false });
+    } else if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await fs7.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+}
+async function replaceEntryWithManagedLink(linkPath, targetPath, expectedCurrentPath) {
+  const resolvedLinkPath = resolve6(linkPath);
+  const resolvedTargetPath = resolve6(targetPath);
+  const resolvedExpectedCurrentPath = resolve6(expectedCurrentPath);
+  await assertNoSymlinkAncestors(resolvedLinkPath);
+  await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
+  await fs7.mkdir(dirname3(resolvedLinkPath), { recursive: true });
+  const existingEntry = await fs7.lstat(resolvedLinkPath);
+  if (existingEntry.isSymbolicLink()) {
+    const currentTargetPath = await fs7.realpath(resolvedLinkPath);
+    if (pathsAreEqual(currentTargetPath, resolvedTargetPath)) {
+      return false;
+    }
+    if (!pathsAreEqual(currentTargetPath, resolvedExpectedCurrentPath)) {
+      throw new Error(`Refusing to replace unexpected link at ${resolvedLinkPath}`);
+    }
+    await fs7.rm(resolvedLinkPath, { recursive: true, force: false });
+    await fs7.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+    return true;
+  }
+  if (!existingEntry.isDirectory()) {
+    throw new Error(`Refusing to replace non-directory entry at ${resolvedLinkPath}`);
+  }
+  const currentPath = await fs7.realpath(resolvedLinkPath);
+  if (!pathsAreEqual(currentPath, resolvedExpectedCurrentPath)) {
+    throw new Error(`Refusing to replace unexpected directory at ${resolvedLinkPath}`);
+  }
+  await fs7.rm(resolvedLinkPath, { recursive: true, force: false });
+  await fs7.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+  return true;
+}
+async function isLinkPointingToTarget(linkPath, targetPath) {
+  try {
+    const entry = await fs7.lstat(linkPath);
+    if (!entry.isSymbolicLink()) {
+      return false;
+    }
+    const resolvedTargetPath = await fs7.realpath(linkPath);
+    return pathsAreEqual(resolvedTargetPath, targetPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// src/manifest/read-manifest.ts
+import * as fs9 from "fs/promises";
+import { join as join6, resolve as resolve7 } from "path";
 
 // src/manifest/build-empty-manifest.ts
 function buildEmptyManifest(skillmuxHome) {
@@ -876,35 +755,35 @@ var manifestSchema = z2.object({
 
 // src/manifest/write-manifest.ts
 import { randomUUID } from "crypto";
-import * as fs7 from "fs/promises";
-import { join as join3 } from "path";
+import * as fs8 from "fs/promises";
+import { join as join5 } from "path";
 function getManifestPath(home) {
-  return join3(home, "manifest.json");
+  return join5(home, "manifest.json");
 }
 function createManifestTempPath(manifestPath) {
   return `${manifestPath}.${process.pid}.${randomUUID()}.tmp`;
 }
 async function writeManifest(home, manifest) {
-  await fs7.mkdir(home, { recursive: true });
+  await fs8.mkdir(home, { recursive: true });
   const manifestPath = getManifestPath(home);
   const tempPath = createManifestTempPath(manifestPath);
   const contents = `${JSON.stringify(manifest, null, 2)}
 `;
-  await fs7.writeFile(tempPath, contents, "utf8");
+  await fs8.writeFile(tempPath, contents, "utf8");
   try {
-    await fs7.rename(tempPath, manifestPath);
+    await fs8.rename(tempPath, manifestPath);
   } catch (error) {
-    await fs7.unlink(tempPath).catch(() => void 0);
+    await fs8.unlink(tempPath).catch(() => void 0);
     throw error;
   }
 }
 
 // src/manifest/read-manifest.ts
 function getManifestPath2(home) {
-  return join4(home, "manifest.json");
+  return join6(home, "manifest.json");
 }
 function normalizeHomePath(home) {
-  const resolvedHome = resolve5(home);
+  const resolvedHome = resolve7(home);
   return process.platform === "win32" ? resolvedHome.toLowerCase() : resolvedHome;
 }
 function formatValidationIssues2(error) {
@@ -916,7 +795,7 @@ function formatValidationIssues2(error) {
 async function readManifest(home) {
   const manifestPath = getManifestPath2(home);
   try {
-    const contents = await fs8.readFile(manifestPath, "utf8");
+    const contents = await fs9.readFile(manifestPath, "utf8");
     const parsedJson = JSON.parse(contents);
     const parsedManifest = manifestSchema.safeParse(parsedJson);
     if (!parsedManifest.success) {
@@ -945,13 +824,689 @@ async function readManifest(home) {
   }
 }
 
+// src/output/print-json.ts
+function printJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+
+// src/commands/adopt.ts
+function buildManagedSkillPath(skillmuxHome, skillId) {
+  return resolve8(skillmuxHome, "skills", skillId);
+}
+function buildAgentRecord(agent, timestamp) {
+  return {
+    id: agent.id,
+    name: agent.stableName,
+    path: agent.absoluteSkillsDirectoryPath,
+    discovery: agent.discovery,
+    available: agent.exists && agent.supportedOnPlatform,
+    lastSeenAt: agent.exists ? timestamp : null
+  };
+}
+function buildActivationRecord(skillId, agentId, linkPath, timestamp) {
+  return {
+    skillId,
+    agentId,
+    linkPath,
+    state: "enabled",
+    updatedAt: timestamp
+  };
+}
+function upsertActivation(manifest, activation) {
+  const index = manifest.activations.findIndex(
+    (entry) => entry.skillId === activation.skillId && entry.agentId === activation.agentId
+  );
+  if (index === -1) {
+    manifest.activations.push(activation);
+    return;
+  }
+  manifest.activations[index] = activation;
+}
+async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
+  const agentId = normalizeId(agentName);
+  const agents = await discoverAgents({ homeDir, skillmuxHome });
+  const agent = agents.find((entry) => entry.id === agentId);
+  if (agent === void 0) {
+    throw new AdoptionError(`Unknown agent: ${agentName}`);
+  }
+  if (!agent.supportedOnPlatform) {
+    throw new AdoptionError(
+      `Agent ${agent.id} is not supported on ${process.platform}`
+    );
+  }
+  return agent;
+}
+function filterEntries(scannedAgent, skillFilter) {
+  if (skillFilter === void 0) {
+    return scannedAgent.entries;
+  }
+  const skillId = normalizeId(skillFilter);
+  return scannedAgent.entries.filter(
+    (entry) => normalizeId(entry.skillName) === skillId
+  );
+}
+async function resolveAdoptionSource(entry) {
+  if (entry.kind === "unmanaged-link") {
+    return entry.targetPath;
+  }
+  if (entry.kind === "unmanaged-directory") {
+    return entry.path;
+  }
+  return void 0;
+}
+function buildManagedSkill(skillId, skillName, managedPath, sourcePath, timestamp) {
+  return {
+    id: skillId,
+    name: skillName,
+    path: managedPath,
+    source: {
+      kind: "imported",
+      path: sourcePath
+    },
+    importedAt: timestamp
+  };
+}
+async function reconcileManagedLink(manifest, skillId, entry, agentId, timestamp) {
+  if (entry.targetPath === void 0) {
+    throw new AdoptionError(`Managed link target is missing for ${entry.path}`);
+  }
+  await assertSkillSourceLayout(entry.targetPath);
+  const skill = manifest.skills[skillId];
+  if (skill === void 0 || !pathsAreEqual(skill.path, entry.targetPath)) {
+    throw new AdoptionError(
+      `Managed link for ${agentId}/${skillId} has no matching manifest skill record`
+    );
+  }
+  upsertActivation(
+    manifest,
+    buildActivationRecord(skillId, agentId, entry.path, timestamp)
+  );
+}
+function buildOutput(result, json) {
+  if (json) {
+    return printJson({
+      agent: result.agent,
+      adopted: result.adopted,
+      skipped: result.skipped
+    });
+  }
+  if (result.adopted.length === 0) {
+    return `No skills adopted for ${result.agent.id}.
+`;
+  }
+  const adoptedSkills = result.adopted.map((entry) => entry.skillId).sort((left, right) => left.localeCompare(right)).join(", ");
+  return `Adopted ${adoptedSkills} for ${result.agent.id}
+`;
+}
+async function runAdoptSingle(options) {
+  const homeDir = options.homeDir ?? homedir();
+  const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
+  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const manifest = await readManifest(skillmuxHome);
+  const agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
+  const agentRecord = buildAgentRecord(agent, timestamp);
+  const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
+  const entries = filterEntries(scannedAgent, options.skill);
+  const adopted = [];
+  const skipped = [];
+  manifest.agents[agent.id] = agentRecord;
+  for (const entry of entries) {
+    const skillId = normalizeId(entry.skillName);
+    if (entry.kind === "managed-link") {
+      await reconcileManagedLink(
+        manifest,
+        skillId,
+        entry,
+        agent.id,
+        timestamp
+      );
+      skipped.push({
+        skillId,
+        agentId: agent.id,
+        path: entry.path,
+        reason: "already-managed"
+      });
+      await writeManifest(skillmuxHome, manifest);
+      continue;
+    }
+    const sourcePath = await resolveAdoptionSource(entry);
+    if (sourcePath === void 0) {
+      skipped.push({
+        skillId,
+        agentId: agent.id,
+        path: entry.path,
+        reason: "not-adoptable"
+      });
+      continue;
+    }
+    if (!await hasRootSkillFile(sourcePath)) {
+      skipped.push({
+        skillId,
+        agentId: agent.id,
+        path: entry.path,
+        reason: "missing-skill-file"
+      });
+      continue;
+    }
+    const managedPath = buildManagedSkillPath(skillmuxHome, skillId);
+    if (manifest.skills[skillId] === void 0) {
+      await copySkillContentsToManagedStore(sourcePath, managedPath);
+      manifest.skills[skillId] = buildManagedSkill(
+        skillId,
+        entry.skillName,
+        managedPath,
+        sourcePath,
+        timestamp
+      );
+    } else if (await isLinkPointingToTarget(entry.path, manifest.skills[skillId].path)) {
+      skipped.push({
+        skillId,
+        agentId: agent.id,
+        path: entry.path,
+        reason: "already-managed"
+      });
+      continue;
+    } else {
+      await assertSkillSourceLayout(manifest.skills[skillId].path);
+    }
+    await replaceEntryWithManagedLink(
+      entry.path,
+      manifest.skills[skillId].path,
+      sourcePath
+    );
+    const activation = buildActivationRecord(
+      skillId,
+      agent.id,
+      join7(agent.absoluteSkillsDirectoryPath, entry.skillName),
+      timestamp
+    );
+    upsertActivation(manifest, activation);
+    adopted.push({
+      skillId,
+      agentId: agent.id,
+      sourcePath,
+      managedPath: manifest.skills[skillId].path,
+      linkPath: activation.linkPath
+    });
+    await writeManifest(skillmuxHome, manifest);
+  }
+  await writeManifest(skillmuxHome, manifest);
+  const resultWithoutOutput = {
+    agent: agentRecord,
+    adopted,
+    skipped,
+    manifest
+  };
+  return {
+    ...resultWithoutOutput,
+    output: buildOutput(resultWithoutOutput, options.json === true)
+  };
+}
+async function runAdopt(options) {
+  if (options.skills !== void 0) {
+    const results = [];
+    const completedSkills = [];
+    for (const skill of options.skills) {
+      try {
+        results.push(await runAdoptSingle({ ...options, skill, skills: void 0 }));
+        completedSkills.push(skill);
+      } catch (error) {
+        throw new BatchOperationError({
+          operation: "adopt",
+          failedItem: skill,
+          failedAction: `adopt ${skill} for ${options.agent}`,
+          completedAction: "adopting",
+          completedItems: completedSkills,
+          cause: error
+        });
+      }
+    }
+    if (results.length === 0) {
+      throw new AdoptionError("Adopt requires at least one target skill");
+    }
+    const lastResult = results[results.length - 1];
+    const resultWithoutOutput = {
+      agent: lastResult.agent,
+      adopted: results.flatMap((result) => result.adopted),
+      skipped: results.flatMap((result) => result.skipped),
+      manifest: lastResult.manifest,
+      results
+    };
+    return {
+      ...resultWithoutOutput,
+      output: options.json === true ? printJson({
+        agent: resultWithoutOutput.agent,
+        adopted: resultWithoutOutput.adopted,
+        skipped: resultWithoutOutput.skipped,
+        results: resultWithoutOutput.results
+      }) : results.map((result) => result.output).join("")
+    };
+  }
+  return runAdoptSingle(options);
+}
+
+// src/commands/agents.ts
+import { homedir as homedir2 } from "os";
+
+// src/output/print-table.ts
+function printTable(rows, columns) {
+  const renderedRows = rows.map(
+    (row) => columns.map((column) => String(row[column.key] ?? ""))
+  );
+  const widths = columns.map(
+    (column, index) => Math.max(
+      column.label.length,
+      ...renderedRows.map((row) => row[index]?.length ?? 0)
+    )
+  );
+  const header = columns.map((column, index) => column.label.padEnd(widths[index])).join("  ");
+  const separator = widths.map((width) => "-".repeat(width)).join("  ");
+  const body = renderedRows.map(
+    (row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ")
+  );
+  return `${[header, separator, ...body].join("\n")}
+`;
+}
+
+// src/commands/agents.ts
+function buildTableOutput(agents) {
+  return printTable(
+    agents.map((agent) => ({
+      id: agent.id,
+      name: agent.stableName,
+      path: agent.absoluteSkillsDirectoryPath,
+      exists: String(agent.exists),
+      supported: String(agent.supportedOnPlatform),
+      discovery: agent.discovery
+    })),
+    [
+      { key: "id", label: "Agent" },
+      { key: "name", label: "Name" },
+      { key: "path", label: "Path" },
+      { key: "exists", label: "Exists" },
+      { key: "supported", label: "Supported" },
+      { key: "discovery", label: "Discovery" }
+    ]
+  );
+}
+async function runAgents(options = {}) {
+  const homeDir = options.homeDir ?? homedir2();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const agents = await discoverAgents({
+    homeDir,
+    skillmuxHome,
+    platform: options.platform
+  });
+  return {
+    agents,
+    output: options.json === true ? printJson(agents) : buildTableOutput(agents)
+  };
+}
+
+// src/commands/config-add-agent.ts
+import { homedir as homedir3 } from "os";
+
+// src/config/agent-override-validation.ts
+import { isAbsolute } from "path";
+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;
+}
+
+// src/config/write-user-config.ts
+import * as fs10 from "fs/promises";
+async function writeUserConfig(skillmuxHome, config) {
+  const configPath = buildConfigPath(skillmuxHome);
+  await fs10.mkdir(skillmuxHome, { recursive: true });
+  await fs10.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return {
+    skillmuxHome,
+    configPath
+  };
+}
+
+// src/commands/config-add-agent.ts
+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 ?? homedir3();
+  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 homedir4 } 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 ?? homedir4();
+  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-update-agent.ts
+import { homedir as homedir5 } from "os";
+function buildAgentPatch(options) {
+  const patch = {};
+  if (options.root !== void 0) {
+    patch.homeRelativeRootPath = normalizeRelativePath(options.root, "root");
+  }
+  if (options.skills !== void 0) {
+    patch.skillsDirectoryPath = normalizeRelativePath(options.skills, "skills");
+  }
+  if (options.name !== void 0 && options.name.trim().length > 0) {
+    patch.stableName = options.name.trim();
+  }
+  if (options.platforms !== void 0) {
+    patch.supportedPlatforms = normalizePlatforms(options.platforms);
+  }
+  if (options.enabledByDefault !== void 0 && options.disabledByDefault === true) {
+    throw new UserConfigValidationError(
+      "enabled-by-default and disabled-by-default cannot both be set"
+    );
+  }
+  if (options.enabledByDefault !== void 0) {
+    patch.enabledByDefault = options.enabledByDefault;
+  }
+  if (options.disabledByDefault === true) {
+    patch.enabledByDefault = false;
+  }
+  return patch;
+}
+function buildTableOutput4(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 runConfigUpdateAgent(options) {
+  const homeDir = options.homeDir ?? homedir5();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const agentId = normalizeAgentId(options.id);
+  const previous = config.agents[agentId];
+  if (previous === void 0) {
+    throw new UserConfigValidationError(`Agent override does not exist: ${agentId}`);
+  }
+  const agent = {
+    ...previous,
+    ...buildAgentPatch(options)
+  };
+  const changed = JSON.stringify(previous) !== JSON.stringify(agent);
+  const nextConfig = {
+    ...config,
+    agents: {
+      ...config.agents,
+      [agentId]: agent
+    }
+  };
+  if (changed) {
+    await writeUserConfig(skillmuxHome, nextConfig);
+  }
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed,
+    agent,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput4(resultWithoutOutput)
+  };
+}
+
+// src/commands/config.ts
+import { homedir as homedir6 } from "os";
+function buildTableOutput5(result) {
+  const summary = printTable(
+    [
+      {
+        skillmuxHome: result.skillmuxHome,
+        configPath: result.configPath,
+        overrides: String(Object.keys(result.config.agents).length)
+      }
+    ],
+    [
+      { key: "skillmuxHome", label: "SkillMux Home" },
+      { key: "configPath", label: "Config Path" },
+      { key: "overrides", label: "Overrides" }
+    ]
+  );
+  const agentRows = Object.entries(result.config.agents).sort(([left], [right]) => left.localeCompare(right)).map(([agentId, agent]) => ({
+    agentId,
+    stableName: agent.stableName ?? "",
+    root: agent.homeRelativeRootPath ?? "",
+    skills: agent.skillsDirectoryPath ?? ""
+  }));
+  if (agentRows.length === 0) {
+    return `${summary}
+No user overrides configured.
+`;
+  }
+  return `${summary}
+${printTable(agentRows, [
+    { key: "agentId", label: "Agent" },
+    { key: "stableName", label: "Name" },
+    { key: "root", label: "Root" },
+    { key: "skills", label: "Skills Dir" }
+  ])}`;
+}
+async function runConfig(options = {}) {
+  const homeDir = options.homeDir ?? homedir6();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const config = await loadUserConfig(skillmuxHome);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath: buildConfigPath(skillmuxHome),
+    config
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput5(resultWithoutOutput)
+  };
+}
+
 // src/commands/doctor.ts
+import * as fs11 from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
 function buildIssue2(code, severity, message, path) {
   return path === void 0 ? { code, severity, message } : { code, severity, message, path };
 }
 async function pathExists2(path) {
   try {
-    await fs9.access(path);
+    await fs11.access(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -965,7 +1520,7 @@ async function addUnmanagedDirectoryIssues(entries, issues) {
     if (entry.kind !== "unmanaged-directory") {
       continue;
     }
-    if (await pathExists2(join5(entry.path, "SKILL.md"))) {
+    if (await pathExists2(join8(entry.path, "SKILL.md"))) {
       issues.push(
         buildIssue2(
           "unmanaged-skill-directory",
@@ -1015,7 +1570,7 @@ function addConflictingAgentPathIssues(agents, issues) {
     );
   }
 }
-function buildTableOutput5(issues) {
+function buildTableOutput6(issues) {
   if (issues.length === 0) {
     return "No doctor issues found.\n";
   }
@@ -1047,7 +1602,7 @@ function buildJsonOutput(result) {
   });
 }
 async function runDoctor(options = {}) {
-  const homeDir = options.homeDir ?? homedir5();
+  const homeDir = options.homeDir ?? homedir7();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const [manifest, config, agents] = await Promise.all([
@@ -1084,135 +1639,14 @@ async function runDoctor(options = {}) {
   };
   return {
     ...resultWithoutOutput,
-    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput5(dedupedIssues)
+    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput6(dedupedIssues)
   };
 }
 
 // src/commands/disable.ts
 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 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 = resolve7(linkPath);
-  const resolvedTargetPath = resolve7(targetPath);
-  await assertNoSymlinkAncestors(resolvedLinkPath);
-  await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
-  await fs11.mkdir(dirname3(resolvedLinkPath), { recursive: true });
-  try {
-    const existingEntry = await fs11.lstat(resolvedLinkPath);
-    if (!existingEntry.isSymbolicLink()) {
-      throw new Error(`Refusing to replace non-link entry at ${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 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 fs11.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
-}
-async function isLinkPointingToTarget(linkPath, targetPath) {
-  try {
-    const entry = await fs11.lstat(linkPath);
-    if (!entry.isSymbolicLink()) {
-      return false;
-    }
-    const resolvedTargetPath = await fs11.realpath(linkPath);
-    return pathsAreEqual(resolvedTargetPath, targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
+import { homedir as homedir8 } from "os";
+import { join as join9, resolve as resolve9 } from "path";
 
 // src/fs/safe-remove-link.ts
 import * as fs12 from "fs/promises";
@@ -1233,7 +1667,7 @@ async function safeRemoveLink(path) {
 }
 
 // src/commands/disable.ts
-function buildAgentRecord(agent, timestamp) {
+function buildAgentRecord2(agent, timestamp) {
   return {
     id: agent.id,
     name: agent.stableName,
@@ -1243,7 +1677,7 @@ function buildAgentRecord(agent, timestamp) {
     lastSeenAt: agent.exists ? timestamp : null
   };
 }
-function buildActivationRecord(skillId, agentId, linkPath, timestamp) {
+function buildActivationRecord2(skillId, agentId, linkPath, timestamp) {
   return {
     skillId,
     agentId,
@@ -1252,7 +1686,7 @@ function buildActivationRecord(skillId, agentId, linkPath, timestamp) {
     updatedAt: timestamp
   };
 }
-function upsertActivation(manifest, activation) {
+function upsertActivation2(manifest, activation) {
   const index = manifest.activations.findIndex(
     (entry) => entry.skillId === activation.skillId && entry.agentId === activation.agentId
   );
@@ -1262,8 +1696,8 @@ function upsertActivation(manifest, activation) {
   }
   manifest.activations[index] = activation;
 }
-function buildManagedSkillPath(skillmuxHome, skillId) {
-  return resolve8(skillmuxHome, "skills", skillId);
+function buildManagedSkillPath2(skillmuxHome, skillId) {
+  return resolve9(skillmuxHome, "skills", skillId);
 }
 async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName, linkPath, timestamp) {
   try {
@@ -1279,7 +1713,7 @@ async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName,
   }
   const sourcePath = await fs13.realpath(linkPath);
   await assertSkillSourceLayout(sourcePath);
-  const managedSkillPath = buildManagedSkillPath(skillmuxHome, skillId);
+  const managedSkillPath = buildManagedSkillPath2(skillmuxHome, skillId);
   await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
   const skill = {
     id: skillId,
@@ -1294,7 +1728,7 @@ async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName,
   manifest.skills[skillId] = skill;
   return { skill, sourcePath };
 }
-async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
+async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
   const agentId = normalizeId(agentName);
   const agents = await discoverAgents({ homeDir, skillmuxHome });
   const agent = agents.find((entry) => entry.id === agentId);
@@ -1317,15 +1751,18 @@ async function pathExists3(path) {
     throw error;
   }
 }
-async function runDisable(options) {
-  const homeDir = options.homeDir ?? homedir6();
+async function runDisableSingle(options) {
+  if (options.agent === void 0) {
+    throw new Error("Disable requires one target agent");
+  }
+  const homeDir = options.homeDir ?? homedir8();
   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 agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
-  const linkPath = join7(agent.absoluteSkillsDirectoryPath, skillId);
+  const agent = await resolveTargetAgent2(homeDir, skillmuxHome, options.agent);
+  const linkPath = join9(agent.absoluteSkillsDirectoryPath, skillId);
   const adoption = manifest.skills[skillId] ? void 0 : await tryAdoptManagedSkill(
     manifest,
     skillmuxHome,
@@ -1342,7 +1779,7 @@ async function runDisable(options) {
     (entry) => entry.skillId === skill.id && entry.agentId === agent.id
   );
   const activationLinkPath = currentActivation?.linkPath ?? linkPath;
-  const agentRecord = buildAgentRecord(agent, timestamp);
+  const agentRecord = buildAgentRecord2(agent, timestamp);
   manifest.agents[agent.id] = agentRecord;
   const adoptedLinkRemoved = adoption !== void 0 ? await safeRemoveLink(linkPath) : false;
   const linkMatchesSkill = adoption === void 0 ? await isLinkPointingToTarget(activationLinkPath, skill.path) : false;
@@ -1361,8 +1798,8 @@ async function runDisable(options) {
 `
     };
   }
-  const activation = buildActivationRecord(skill.id, agent.id, linkPath, timestamp);
-  upsertActivation(manifest, activation);
+  const activation = buildActivationRecord2(skill.id, agent.id, linkPath, timestamp);
+  upsertActivation2(manifest, activation);
   await writeManifest(skillmuxHome, manifest);
   return {
     changed: true,
@@ -1374,12 +1811,44 @@ async function runDisable(options) {
 `
   };
 }
+async function runDisable(options) {
+  if (options.agents !== void 0) {
+    const results = [];
+    for (const agent of options.agents) {
+      try {
+        results.push(await runDisableSingle({ ...options, agent, agents: void 0 }));
+      } catch (error) {
+        throw new BatchOperationError({
+          operation: "disable",
+          failedItem: agent,
+          failedAction: `disable ${options.skill} for ${agent}`,
+          completedAction: "disabling",
+          completedItems: results.map((result) => result.agent.id),
+          cause: error
+        });
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("Disable requires at least one target agent");
+    }
+    const lastResult = results[results.length - 1];
+    return {
+      changed: results.some((result) => result.changed),
+      skill: lastResult.skill,
+      results,
+      changedAgents: results.filter((result) => result.changed).map((result) => result.agent.id),
+      manifest: lastResult.manifest,
+      output: results.map((result) => result.output).join("")
+    };
+  }
+  return runDisableSingle(options);
+}
 
 // src/commands/enable.ts
 import * as fs14 from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
-function buildAgentRecord2(agent, timestamp) {
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
+function buildAgentRecord3(agent, timestamp) {
   return {
     id: agent.id,
     name: agent.stableName,
@@ -1389,7 +1858,7 @@ function buildAgentRecord2(agent, timestamp) {
     lastSeenAt: timestamp
   };
 }
-function buildActivationRecord2(skillId, agentId, linkPath, timestamp, state) {
+function buildActivationRecord3(skillId, agentId, linkPath, timestamp, state) {
   return {
     skillId,
     agentId,
@@ -1398,7 +1867,7 @@ function buildActivationRecord2(skillId, agentId, linkPath, timestamp, state) {
     updatedAt: timestamp
   };
 }
-function upsertActivation2(manifest, activation) {
+function upsertActivation3(manifest, activation) {
   const index = manifest.activations.findIndex(
     (entry) => entry.skillId === activation.skillId && entry.agentId === activation.agentId
   );
@@ -1408,7 +1877,7 @@ function upsertActivation2(manifest, activation) {
   }
   manifest.activations[index] = activation;
 }
-async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
+async function resolveTargetAgent3(homeDir, skillmuxHome, agentName) {
   const agentId = normalizeId(agentName);
   const agents = await discoverAgents({ homeDir, skillmuxHome });
   const agent = agents.find((entry) => entry.id === agentId);
@@ -1420,8 +1889,11 @@ async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
   }
   return agent;
 }
-async function runEnable(options) {
-  const homeDir = options.homeDir ?? homedir7();
+async function runEnableSingle(options) {
+  if (options.agent === void 0) {
+    throw new Error("Enable requires one target agent");
+  }
+  const homeDir = options.homeDir ?? homedir9();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -1431,12 +1903,12 @@ async function runEnable(options) {
   if (skill === void 0) {
     throw new Error(`Managed skill not found: ${skillId}`);
   }
-  const agent = await resolveTargetAgent2(homeDir, skillmuxHome, options.agent);
-  const linkPath = join8(agent.absoluteSkillsDirectoryPath, skill.id);
+  const agent = await resolveTargetAgent3(homeDir, skillmuxHome, options.agent);
+  const linkPath = join10(agent.absoluteSkillsDirectoryPath, skill.id);
   const currentActivation = manifest.activations.find(
     (entry) => entry.skillId === skill.id && entry.agentId === agent.id
   );
-  const agentRecord = buildAgentRecord2(agent, timestamp);
+  const agentRecord = buildAgentRecord3(agent, timestamp);
   manifest.agents[agent.id] = agentRecord;
   await fs14.mkdir(agent.absoluteSkillsDirectoryPath, { recursive: true });
   const linkAlreadyEnabled = await isLinkPointingToTarget(linkPath, skill.path);
@@ -1453,14 +1925,14 @@ async function runEnable(options) {
     };
   }
   await createManagedLink(linkPath, skill.path);
-  const activation = buildActivationRecord2(
+  const activation = buildActivationRecord3(
     skill.id,
     agent.id,
     linkPath,
     timestamp,
     "enabled"
   );
-  upsertActivation2(manifest, activation);
+  upsertActivation3(manifest, activation);
   await writeManifest(skillmuxHome, manifest);
   return {
     changed: true,
@@ -1472,22 +1944,54 @@ async function runEnable(options) {
 `
   };
 }
+async function runEnable(options) {
+  if (options.agents !== void 0) {
+    const results = [];
+    for (const agent of options.agents) {
+      try {
+        results.push(await runEnableSingle({ ...options, agent, agents: void 0 }));
+      } catch (error) {
+        throw new BatchOperationError({
+          operation: "enable",
+          failedItem: agent,
+          failedAction: `enable ${options.skill} for ${agent}`,
+          completedAction: "enabling",
+          completedItems: results.map((result) => result.agent.id),
+          cause: error
+        });
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("Enable requires at least one target agent");
+    }
+    const lastResult = results[results.length - 1];
+    return {
+      changed: results.some((result) => result.changed),
+      skill: lastResult.skill,
+      results,
+      changedAgents: results.filter((result) => result.changed).map((result) => result.agent.id),
+      manifest: lastResult.manifest,
+      output: results.map((result) => result.output).join("")
+    };
+  }
+  return runEnableSingle(options);
+}
 
 // src/commands/import.ts
-import { resolve as resolve9 } from "path";
-import { homedir as homedir8 } from "os";
-function buildManagedSkillPath2(skillmuxHome, skillId) {
-  return resolve9(skillmuxHome, "skills", skillId);
+import { resolve as resolve10 } from "path";
+import { homedir as homedir10 } from "os";
+function buildManagedSkillPath3(skillmuxHome, skillId) {
+  return resolve10(skillmuxHome, "skills", skillId);
 }
 async function runImport(options) {
-  const homeDir = options.homeDir ?? homedir8();
+  const homeDir = options.homeDir ?? homedir10();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const sourcePath = resolve9(options.sourcePath);
+  const sourcePath = resolve10(options.sourcePath);
   const skillId = normalizeId(options.skillName);
   const importedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
   const manifest = await readManifest(skillmuxHome);
-  const managedSkillPath = buildManagedSkillPath2(skillmuxHome, skillId);
+  const managedSkillPath = buildManagedSkillPath3(skillmuxHome, skillId);
   await assertSkillSourceLayout(sourcePath);
   if (manifest.skills[skillId] !== void 0) {
     throw new Error(`Managed skill already exists for ${skillId}`);
@@ -1514,7 +2018,7 @@ async function runImport(options) {
 }
 
 // src/commands/scan.ts
-import { homedir as homedir9 } from "os";
+import { homedir as homedir11 } from "os";
 
 // src/output/format-issue.ts
 function formatIssue(issue) {
@@ -1525,7 +2029,7 @@ function formatIssue(issue) {
 }
 
 // src/commands/scan.ts
-function buildAgentRecord3(agent, timestamp, previousRecord) {
+function buildAgentRecord4(agent, timestamp, previousRecord) {
   const lastSeenAt = agent.exists ? timestamp : previousRecord?.lastSeenAt ?? null;
   return {
     id: agent.id,
@@ -1575,7 +2079,7 @@ ${result.issues.map(formatIssue).join("\n")}
 `;
 }
 async function runScan(options = {}) {
-  const homeDir = options.homeDir ?? homedir9();
+  const homeDir = options.homeDir ?? homedir11();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const manifest = await readManifest(skillmuxHome);
@@ -1591,7 +2095,7 @@ async function runScan(options = {}) {
     const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
     entries.push(...scannedAgent.entries);
     issues.push(...scannedAgent.issues);
-    manifest.agents[agent.id] = buildAgentRecord3(
+    manifest.agents[agent.id] = buildAgentRecord4(
       agent,
       timestamp,
       manifest.agents[agent.id]
@@ -1681,7 +2185,7 @@ function buildListData(scanResult, view) {
   }
   return buildRecordsView(scanResult);
 }
-function buildTableOutput6(data, view) {
+function buildTableOutput7(data, view) {
   if (view === "agents") {
     const agentRows = data.agents;
     return printTable(
@@ -1731,14 +2235,204 @@ async function runList(options = {}) {
   const data = buildListData(scanResult, view);
   return {
     data,
-    output: format === "json" ? printJson(data) : buildTableOutput6(data, view)
+    output: format === "json" ? printJson(data) : buildTableOutput7(data, view)
+  };
+}
+
+// src/commands/remove.ts
+import * as fs15 from "fs/promises";
+import { homedir as homedir12 } from "os";
+import { resolve as resolve11 } from "path";
+function buildManagedSkillPath4(skillmuxHome, skillId) {
+  return resolve11(skillmuxHome, "skills", skillId);
+}
+function buildManifestPath(skillmuxHome) {
+  return resolve11(skillmuxHome, "manifest.json");
+}
+function buildConfigPath2(skillmuxHome) {
+  return resolve11(skillmuxHome, "config.json");
+}
+function resolveManagedSkill(manifest, skillNameOrId) {
+  const skillId = normalizeId(skillNameOrId);
+  const directMatch = manifest.skills[skillId];
+  if (directMatch !== void 0) {
+    return directMatch;
+  }
+  const nameMatches = Object.values(manifest.skills).filter(
+    (skill) => normalizeId(skill.name) === skillId
+  );
+  if (nameMatches.length === 1) {
+    return nameMatches[0];
+  }
+  if (nameMatches.length > 1) {
+    const candidateIds = nameMatches.map((skill) => skill.id).sort((left, right) => left.localeCompare(right));
+    throw new Error(
+      `Ambiguous managed skill name ${skillNameOrId}: ${candidateIds.join(", ")}`
+    );
+  }
+  throw new Error(`Managed skill not found: ${skillId}`);
+}
+function buildHumanOutput(skill, managedSkillPath) {
+  return `Removed ${skill.id} from ${managedSkillPath}
+`;
+}
+function buildJsonOutput2(result) {
+  return printJson({
+    changed: result.changed,
+    removedSkillId: result.removedSkillId,
+    skill: result.skill,
+    location: result.location,
+    manifest: result.manifest
+  });
+}
+async function pathExists4(path) {
+  try {
+    await fs15.lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function assertManagedSkillRemovalSafety(skillmuxHome, skillPath, skillId) {
+  const expectedSkillPath = buildManagedSkillPath4(skillmuxHome, skillId);
+  if (!pathsAreEqual(skillPath, expectedSkillPath)) {
+    throw new Error(`Refusing to remove unmanaged skill path at ${skillPath}`);
+  }
+  await assertNoSymlinkAncestors(skillPath, { includeLeaf: true });
+  if (!await pathExists4(skillPath)) {
+    return;
+  }
+  const entry = await fs15.lstat(skillPath);
+  if (entry.isSymbolicLink()) {
+    throw new Error(`Refusing to remove symlinked managed skill path at ${skillPath}`);
+  }
+  if (!entry.isDirectory()) {
+    throw new Error(`Refusing to remove non-directory managed skill path at ${skillPath}`);
+  }
+}
+async function runRemoveSingle(options) {
+  if (options.skill === void 0) {
+    throw new Error("Remove requires one target skill");
+  }
+  const homeDir = options.homeDir ?? homedir12();
+  const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
+  const manifestPath = buildManifestPath(skillmuxHome);
+  const configPath = buildConfigPath2(skillmuxHome);
+  const manifest = await readManifest(skillmuxHome);
+  const skill = resolveManagedSkill(manifest, options.skill);
+  const managedSkillsDirectory = resolve11(skillmuxHome, "skills");
+  const managedSkillPath = skill.path;
+  const enabledActivations = manifest.activations.filter(
+    (activation) => activation.skillId === skill.id && activation.state === "enabled"
+  );
+  if (enabledActivations.length > 0) {
+    const enabledAgents = [...new Set(enabledActivations.map((activation) => activation.agentId))].sort(
+      (left, right) => left.localeCompare(right)
+    );
+    throw new Error(
+      `Cannot remove ${skill.id}; it is still enabled for: ${enabledAgents.join(", ")}`
+    );
+  }
+  await assertManagedSkillRemovalSafety(skillmuxHome, managedSkillPath, skill.id);
+  if (await pathExists4(managedSkillPath)) {
+    await fs15.rm(managedSkillPath, { recursive: true, force: false });
+  }
+  delete manifest.skills[skill.id];
+  manifest.activations = manifest.activations.filter(
+    (activation) => activation.skillId !== skill.id
+  );
+  await writeManifest(skillmuxHome, manifest);
+  const resultWithoutOutput = {
+    changed: true,
+    removedSkillId: skill.id,
+    skill,
+    location: {
+      skillmuxHome,
+      configPath,
+      manifestPath,
+      managedSkillsDirectory,
+      managedSkillPath
+    },
+    manifest
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? buildJsonOutput2(resultWithoutOutput) : buildHumanOutput(skill, managedSkillPath)
   };
 }
+async function runRemove(options) {
+  if (options.skills !== void 0) {
+    const results = [];
+    for (const skill of options.skills) {
+      try {
+        results.push(await runRemoveSingle({ ...options, skill, skills: void 0 }));
+      } catch (error) {
+        throw new BatchOperationError({
+          operation: "remove",
+          failedItem: skill,
+          failedAction: `remove ${skill}`,
+          completedAction: "removing",
+          completedItems: results.map((result) => result.removedSkillId),
+          cause: error
+        });
+      }
+    }
+    if (results.length === 0) {
+      throw new Error("Remove requires at least one target skill");
+    }
+    const lastResult = results[results.length - 1];
+    const resultWithoutOutput = {
+      changed: results.some((result) => result.changed),
+      removedSkillIds: results.map((result) => result.removedSkillId),
+      results,
+      manifest: lastResult.manifest
+    };
+    return {
+      ...resultWithoutOutput,
+      output: options.json === true ? printJson(resultWithoutOutput) : results.map((result) => result.output).join("")
+    };
+  }
+  return runRemoveSingle(options);
+}
 
 // src/index.ts
+function collectValues(value, previous = []) {
+  return [...previous, value];
+}
+function requireSingleValue(values, label) {
+  if (values.length !== 1) {
+    throw new Error(`Expected exactly one ${label}`);
+  }
+  return values[0];
+}
+function requireAtLeastOneValue(values, label) {
+  if (values.length === 0) {
+    throw new Error(`Expected at least one ${label}`);
+  }
+  return values;
+}
 function buildCli() {
   const program = new Command();
   program.name("skillmux");
+  program.command("adopt").requiredOption("--agent <agent>", "Source agent id").option("--skill <skill>", "Repeatable installed skill to adopt", collectValues, []).option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = options.skill.length === 0 ? await runAdopt({
+      agent: options.agent,
+      json: options.json === true
+    }) : options.skill.length === 1 ? await runAdopt({
+      agent: options.agent,
+      skill: options.skill[0],
+      json: options.json === true
+    }) : await runAdopt({
+      agent: options.agent,
+      skills: options.skill,
+      json: options.json === true
+    });
+    process.stdout.write(result.output);
+  });
   program.command("scan").option("--json", "Emit structured JSON output").action(async (options) => {
     const result = await runScan({ json: options.json === true });
     process.stdout.write(result.output);
@@ -1796,17 +2490,48 @@ function buildCli() {
     });
     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) => {
+  configCommand.command("update-agent").requiredOption("--id <id>", "Agent id").option("--root <path>", "Home-relative root path").option("--skills <path>", "Skills directory path relative to the agent root").option("--name <name>", "Stable display name").option(
+    "--platform <platform>",
+    `Supported platform (${supportedPlatforms.join(", ")})`,
+    (value, previous = []) => [...previous, value],
+    []
+  ).option("--enabled-by-default", "Mark this custom agent as enabled by default").option("--disabled-by-default", "Mark this custom agent as disabled by default").option("--json", "Emit structured JSON output").action(
+    async (options) => {
+      const result = await runConfigUpdateAgent({
+        id: options.id,
+        root: options.root,
+        skills: options.skills,
+        name: options.name,
+        platforms: options.platform !== void 0 && options.platform.length > 0 ? options.platform : void 0,
+        enabledByDefault: options.enabledByDefault === true ? true : void 0,
+        disabledByDefault: options.disabledByDefault === true,
+        json: options.json === true
+      });
+      process.stdout.write(result.output);
+    }
+  );
+  program.command("enable").requiredOption("--skill <skill>", "Managed skill name or id", collectValues, []).requiredOption("--agent <agent>", "Repeatable target agent", collectValues, []).action(async (options) => {
     const result = await runEnable({
-      skill: options.skill,
-      agent: options.agent
+      skill: requireSingleValue(options.skill, "skill"),
+      agents: requireAtLeastOneValue(options.agent, "agent")
     });
     process.stdout.write(result.output);
   });
-  program.command("disable").requiredOption("--skill <skill>", "Managed skill name or id").requiredOption("--agent <agent>", "Target agent id").action(async (options) => {
+  program.command("disable").requiredOption("--skill <skill>", "Managed skill name or id", collectValues, []).requiredOption("--agent <agent>", "Repeatable target agent", collectValues, []).action(async (options) => {
     const result = await runDisable({
-      skill: options.skill,
-      agent: options.agent
+      skill: requireSingleValue(options.skill, "skill"),
+      agents: requireAtLeastOneValue(options.agent, "agent")
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("remove").requiredOption("--skill <skill>", "Repeatable managed skill name or id", collectValues, []).option("--json", "Emit structured JSON output").action(async (options) => {
+    const skills = requireAtLeastOneValue(options.skill, "skill");
+    const result = skills.length === 1 ? await runRemove({
+      skill: skills[0],
+      json: options.json === true
+    }) : await runRemove({
+      skills,
+      json: options.json === true
     });
     process.stdout.write(result.output);
   });