skillmux 0.1.3 → 0.1.5

package/dist/{chunk-DBEVDI27.js → chunk-OY3C7VIL.js}

@@ -59,8 +59,8 @@ var defaultAgentRuleMap = Object.fromEntries(
 );
 
 // src/commands/adopt.ts
-import { homedir } from "os";
-import { join as join7, resolve as resolve8 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join8, resolve as resolve8 } from "path";
 
 // src/core/errors.ts
 var SkillMuxError = class extends Error {
@@ -119,8 +119,13 @@ function resolveSkillmuxHome(homeDir) {
 }
 
 // src/discovery/discover-agents.ts
-import * as fs2 from "fs/promises";
-import { join as join2, resolve as resolve2 } from "path";
+import * as fs3 from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/config/auto-register-agents.ts
+import { readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
 
 // src/config/load-user-config.ts
 import * as fs from "fs/promises";
@@ -131,16 +136,27 @@ var agentOverrideSchema = z.object({
   supportedPlatforms: z.array(supportedPlatformSchema).min(1).optional(),
   homeRelativeRootPath: z.string().min(1).optional(),
   skillsDirectoryPath: z.string().min(1).optional(),
-  enabledByDefault: z.boolean().optional()
+  enabledByDefault: z.boolean().optional(),
+  autoDiscovered: z.literal(true).optional()
 }).strict();
 var userConfigSchema = z.object({
   version: z.literal(1),
-  agents: z.record(z.string().min(1), agentOverrideSchema)
+  agents: z.record(z.string().min(1), agentOverrideSchema),
+  autoDiscover: z.object({
+    lastRunAt: z.string().nullable(),
+    intervalMs: z.number().int().nonnegative()
+  }).optional(),
+  removedAutoAgentIds: z.array(z.string().min(1)).optional()
 }).strict();
 function createEmptyUserConfig() {
   return {
     version: 1,
-    agents: {}
+    agents: {},
+    autoDiscover: {
+      lastRunAt: null,
+      intervalMs: 36e5
+    },
+    removedAutoAgentIds: []
   };
 }
 function stripUtf8Bom(contents) {
@@ -177,6 +193,101 @@ async function loadUserConfig(skillmuxHome) {
   }
 }
 
+// src/config/write-user-config.ts
+import * as fs2 from "fs/promises";
+async function writeUserConfig(skillmuxHome, config) {
+  const configPath = buildConfigPath(skillmuxHome);
+  await fs2.mkdir(skillmuxHome, { recursive: true });
+  await fs2.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return {
+    skillmuxHome,
+    configPath
+  };
+}
+
+// src/config/auto-register-agents.ts
+function isDotDir(name) {
+  return name.startsWith(".");
+}
+function isValidAgentId(name) {
+  if (name.length < 2) return false;
+  const stem = name.slice(1);
+  return /^[a-z][a-z0-9-]*$/u.test(stem);
+}
+function dirExists(dirPath) {
+  try {
+    return statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isBuiltInAgentId(id) {
+  return builtInAgentIds.includes(id);
+}
+function makeAutoDiscoveredOverride(dirName) {
+  const stem = dirName.slice(1);
+  return {
+    stableName: stem.charAt(0).toUpperCase() + stem.slice(1),
+    supportedPlatforms: ["win32", "linux", "darwin"],
+    homeRelativeRootPath: dirName,
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    autoDiscovered: true
+  };
+}
+async function autoRegisterNewAgents(homeDir) {
+  const resolvedHomeDir = homeDir ?? homedir();
+  const { skillmuxHome } = resolveSkillmuxHome(resolvedHomeDir);
+  const config = await loadUserConfig(skillmuxHome);
+  const autoDiscover = config.autoDiscover ?? {
+    lastRunAt: null,
+    intervalMs: 36e5
+  };
+  if (autoDiscover.lastRunAt !== null && autoDiscover.intervalMs > 0) {
+    const elapsed = Date.now() - new Date(autoDiscover.lastRunAt).getTime();
+    if (elapsed < autoDiscover.intervalMs) {
+      return;
+    }
+  }
+  const wellKnownNonAgentDirs = /* @__PURE__ */ new Set([".skillmux"]);
+  const removedIds = new Set(config.removedAutoAgentIds ?? []);
+  let changed = false;
+  let entries;
+  try {
+    entries = readdirSync(resolvedHomeDir);
+  } catch {
+    return;
+  }
+  const nextAgents = { ...config.agents };
+  for (const name of entries) {
+    if (!isDotDir(name)) continue;
+    if (wellKnownNonAgentDirs.has(name)) continue;
+    if (!isValidAgentId(name)) continue;
+    const agentId = name.slice(1).toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    if (agentId in nextAgents) continue;
+    if (isBuiltInAgentId(agentId)) continue;
+    if (removedIds.has(agentId)) continue;
+    const skillsDir = join2(resolvedHomeDir, name, "skills");
+    if (!dirExists(skillsDir)) continue;
+    nextAgents[agentId] = makeAutoDiscoveredOverride(name);
+    changed = true;
+  }
+  if (!changed && autoDiscover.lastRunAt !== null) {
+    return;
+  }
+  const nextConfig = {
+    ...config,
+    agents: nextAgents,
+    autoDiscover: {
+      ...autoDiscover,
+      lastRunAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    removedAutoAgentIds: [...removedIds]
+  };
+  await writeUserConfig(skillmuxHome, nextConfig);
+}
+
 // src/discovery/discover-agents.ts
 function mergeRule(rule, override) {
   if (override === void 0) {
@@ -205,7 +316,7 @@ function buildCustomRule(id, override) {
 }
 async function pathExists(path) {
   try {
-    await fs2.access(path);
+    await fs3.access(path);
     return true;
   } catch {
     return false;
@@ -215,7 +326,7 @@ function resolveAgentRulePaths(homeDir, rule) {
   const absoluteRootPath = resolve2(homeDir, rule.homeRelativeRootPath);
   return {
     absoluteRootPath,
-    absoluteSkillsDirectoryPath: join2(
+    absoluteSkillsDirectoryPath: join3(
       absoluteRootPath,
       rule.skillsDirectoryPath
     )
@@ -225,6 +336,7 @@ async function discoverAgents(options) {
   const platform = options.platform ?? process.platform;
   const homeDir = resolve2(options.homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolveSkillmuxHome(homeDir).skillmuxHome;
+  await autoRegisterNewAgents(homeDir);
   const userConfig = await loadUserConfig(skillmuxHome);
   const discoveredAgents = [];
   for (const agentId of builtInAgentIds) {
@@ -254,22 +366,23 @@ async function discoverAgents(options) {
       exists: await pathExists(resolvedPaths.absoluteSkillsDirectoryPath),
       supportedOnPlatform: customRule.supportedPlatforms.some(
         (supportedPlatform) => supportedPlatform === platform
-      )
+      ),
+      autoDiscovered: override.autoDiscovered === true || void 0
     });
   }
   return discoveredAgents;
 }
 
 // src/discovery/scan-agent-skills.ts
-import * as fs5 from "fs/promises";
-import { join as join3 } from "path";
+import * as fs6 from "fs/promises";
+import { join as join4 } from "path";
 
 // 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);
@@ -300,7 +413,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}`);
       }
@@ -324,10 +437,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: {
@@ -407,7 +520,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(
@@ -419,7 +532,7 @@ async function scanAgentSkills(agent, skillmuxHome) {
     const result = await inferSkillEntry({
       agentId: agent.id,
       agentName: agent.stableName,
-      path: join3(agent.absoluteSkillsDirectoryPath, directoryEntry.name),
+      path: join4(agent.absoluteSkillsDirectoryPath, directoryEntry.name),
       skillmuxHome
     });
     entries.push(result.entry);
@@ -434,23 +547,23 @@ async function scanAgentSkills(agent, skillmuxHome) {
 }
 
 // src/fs/safe-copy.ts
-import * as fs6 from "fs/promises";
-import { dirname as dirname2, join as join4, resolve as resolve5 } from "path";
+import * as fs7 from "fs/promises";
+import { dirname as dirname2, join as join5, resolve as resolve5 } from "path";
 async function assertDirectory(path) {
-  const entry = await fs6.lstat(path);
+  const entry = await fs7.lstat(path);
   if (!entry.isDirectory()) {
     throw new Error(`Expected a directory at ${path}`);
   }
 }
 async function assertRegularFile(path, label) {
-  const entry = await fs6.lstat(path);
+  const entry = await fs7.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);
+    await fs7.lstat(path);
     throw new Error(`Refusing to overwrite existing path at ${path}`);
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -459,12 +572,12 @@ async function assertTargetDoesNotExist(path) {
   }
 }
 async function copyDirectoryContents(sourcePath, targetPath) {
-  await fs6.mkdir(targetPath, { recursive: true });
-  const entries = await fs6.readdir(sourcePath, { withFileTypes: true });
+  await fs7.mkdir(targetPath, { recursive: true });
+  const entries = await fs7.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);
+    const sourceEntryPath = join5(sourcePath, entry.name);
+    const targetEntryPath = join5(targetPath, entry.name);
+    const entryStats = await fs7.lstat(sourceEntryPath);
     if (entryStats.isSymbolicLink()) {
       throw new Error(`Refusing to copy source symlink at ${sourceEntryPath}`);
     }
@@ -473,8 +586,8 @@ async function copyDirectoryContents(sourcePath, targetPath) {
       continue;
     }
     if (entryStats.isFile()) {
-      await fs6.mkdir(dirname2(targetEntryPath), { recursive: true });
-      await fs6.copyFile(sourceEntryPath, targetEntryPath);
+      await fs7.mkdir(dirname2(targetEntryPath), { recursive: true });
+      await fs7.copyFile(sourceEntryPath, targetEntryPath);
       continue;
     }
     throw new Error(`Unsupported filesystem entry at ${sourceEntryPath}`);
@@ -482,7 +595,7 @@ async function copyDirectoryContents(sourcePath, targetPath) {
 }
 async function assertSkillSourceLayout(sourcePath) {
   const resolvedSourcePath = resolve5(sourcePath);
-  const skillFilePath = join4(resolvedSourcePath, "SKILL.md");
+  const skillFilePath = join5(resolvedSourcePath, "SKILL.md");
   await assertNoSymlinkAncestors(resolvedSourcePath, { includeLeaf: true });
   await assertDirectory(resolvedSourcePath);
   try {
@@ -496,7 +609,7 @@ async function assertSkillSourceLayout(sourcePath) {
 }
 async function hasRootSkillFile(sourcePath) {
   const resolvedSourcePath = resolve5(sourcePath);
-  const skillFilePath = join4(resolvedSourcePath, "SKILL.md");
+  const skillFilePath = join5(resolvedSourcePath, "SKILL.md");
   try {
     await assertDirectory(resolvedSourcePath);
     await assertRegularFile(skillFilePath, "SKILL.md");
@@ -550,7 +663,7 @@ var BatchOperationError = class extends Error {
 };
 
 // src/fs/link-ops.ts
-import * as fs7 from "fs/promises";
+import * as fs8 from "fs/promises";
 import { dirname as dirname3, resolve as resolve6 } from "path";
 var directoryLinkType = process.platform === "win32" ? "junction" : "dir";
 async function createManagedLink(linkPath, targetPath) {
@@ -558,25 +671,25 @@ async function createManagedLink(linkPath, targetPath) {
   const resolvedTargetPath = resolve6(targetPath);
   await assertNoSymlinkAncestors(resolvedLinkPath);
   await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
-  await fs7.mkdir(dirname3(resolvedLinkPath), { recursive: true });
+  await fs8.mkdir(dirname3(resolvedLinkPath), { recursive: true });
   try {
-    const existingEntry = await fs7.lstat(resolvedLinkPath);
+    const existingEntry = await fs8.lstat(resolvedLinkPath);
     if (!existingEntry.isSymbolicLink()) {
       throw new Error(`Refusing to replace non-link entry at ${resolvedLinkPath}`);
     }
-    const currentTargetPath = await fs7.realpath(resolvedLinkPath);
+    const currentTargetPath = await fs8.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 });
+    if (error.code === "ENOENT" && await fs8.lstat(resolvedLinkPath).then((entry) => entry.isSymbolicLink()).catch(() => false)) {
+      await fs8.rm(resolvedLinkPath, { recursive: true, force: false });
     } else if (error.code !== "ENOENT") {
       throw error;
     }
   }
-  await fs7.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+  await fs8.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
 }
 async function replaceEntryWithManagedLink(linkPath, targetPath, expectedCurrentPath) {
   const resolvedLinkPath = resolve6(linkPath);
@@ -584,38 +697,38 @@ async function replaceEntryWithManagedLink(linkPath, targetPath, expectedCurrent
   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);
+  await fs8.mkdir(dirname3(resolvedLinkPath), { recursive: true });
+  const existingEntry = await fs8.lstat(resolvedLinkPath);
   if (existingEntry.isSymbolicLink()) {
-    const currentTargetPath = await fs7.realpath(resolvedLinkPath);
+    const currentTargetPath = await fs8.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);
+    await fs8.rm(resolvedLinkPath, { recursive: true, force: false });
+    await fs8.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);
+  const currentPath = await fs8.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);
+  await fs8.rm(resolvedLinkPath, { recursive: true, force: false });
+  await fs8.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
   return true;
 }
 async function isLinkPointingToTarget(linkPath, targetPath) {
   try {
-    const entry = await fs7.lstat(linkPath);
+    const entry = await fs8.lstat(linkPath);
     if (!entry.isSymbolicLink()) {
       return false;
     }
-    const resolvedTargetPath = await fs7.realpath(linkPath);
+    const resolvedTargetPath = await fs8.realpath(linkPath);
     return pathsAreEqual(resolvedTargetPath, targetPath);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -626,8 +739,8 @@ async function isLinkPointingToTarget(linkPath, targetPath) {
 }
 
 // src/manifest/read-manifest.ts
-import * as fs9 from "fs/promises";
-import { join as join6, resolve as resolve7 } from "path";
+import * as fs10 from "fs/promises";
+import { join as join7, resolve as resolve7 } from "path";
 
 // src/manifest/build-empty-manifest.ts
 function buildEmptyManifest(skillmuxHome) {
@@ -752,32 +865,32 @@ var manifestSchema = z2.object({
 
 // src/manifest/write-manifest.ts
 import { randomUUID } from "crypto";
-import * as fs8 from "fs/promises";
-import { join as join5 } from "path";
+import * as fs9 from "fs/promises";
+import { join as join6 } from "path";
 function getManifestPath(home) {
-  return join5(home, "manifest.json");
+  return join6(home, "manifest.json");
 }
 function createManifestTempPath(manifestPath) {
   return `${manifestPath}.${process.pid}.${randomUUID()}.tmp`;
 }
 async function writeManifest(home, manifest) {
-  await fs8.mkdir(home, { recursive: true });
+  await fs9.mkdir(home, { recursive: true });
   const manifestPath = getManifestPath(home);
   const tempPath = createManifestTempPath(manifestPath);
   const contents = `${JSON.stringify(manifest, null, 2)}
 `;
-  await fs8.writeFile(tempPath, contents, "utf8");
+  await fs9.writeFile(tempPath, contents, "utf8");
   try {
-    await fs8.rename(tempPath, manifestPath);
+    await fs9.rename(tempPath, manifestPath);
   } catch (error) {
-    await fs8.unlink(tempPath).catch(() => void 0);
+    await fs9.unlink(tempPath).catch(() => void 0);
     throw error;
   }
 }
 
 // src/manifest/read-manifest.ts
 function getManifestPath2(home) {
-  return join6(home, "manifest.json");
+  return join7(home, "manifest.json");
 }
 function normalizeHomePath(home) {
   const resolvedHome = resolve7(home);
@@ -792,7 +905,7 @@ function formatValidationIssues2(error) {
 async function readManifest(home) {
   const manifestPath = getManifestPath2(home);
   try {
-    const contents = await fs9.readFile(manifestPath, "utf8");
+    const contents = await fs10.readFile(manifestPath, "utf8");
     const parsedJson = JSON.parse(contents);
     const parsedManifest = manifestSchema.safeParse(parsedJson);
     if (!parsedManifest.success) {
@@ -937,7 +1050,7 @@ function buildOutput(result, json) {
 `;
 }
 async function runAdoptSingle(options) {
-  const homeDir = options.homeDir ?? homedir();
+  const homeDir = options.homeDir ?? homedir2();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -1016,7 +1129,7 @@ async function runAdoptSingle(options) {
     const activation = buildActivationRecord(
       skillId,
       agent.id,
-      join7(agent.absoluteSkillsDirectoryPath, entry.skillName),
+      join8(agent.absoluteSkillsDirectoryPath, entry.skillName),
       timestamp
     );
     upsertActivation(manifest, activation);
@@ -1084,20 +1197,503 @@ async function runAdopt(options) {
   return runAdoptSingle(options);
 }
 
-// src/commands/disable.ts
+// 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/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/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 buildTableOutput(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) : buildTableOutput(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 buildTableOutput2(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 removedOverride = config.agents[agentId];
+  const wasAutoDiscovered = removedOverride?.autoDiscovered === true;
+  const removedAutoAgentIds = wasAutoDiscovered ? [...config.removedAutoAgentIds ?? [], agentId] : config.removedAutoAgentIds;
+  const nextConfig = {
+    ...config,
+    agents: Object.fromEntries(
+      Object.entries(config.agents).filter(([currentAgentId]) => currentAgentId !== agentId)
+    ),
+    ...wasAutoDiscovered ? { removedAutoAgentIds } : {}
+  };
+  if (removed) {
+    await writeUserConfig(skillmuxHome, nextConfig);
+  }
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed: removed,
+    removed,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(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 buildTableOutput3(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)
+  };
+  if (previous.autoDiscovered === true) {
+    delete agent.autoDiscovered;
+  }
+  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) : buildTableOutput3(resultWithoutOutput)
+  };
+}
+
+// src/commands/doctor.ts
+import { homedir as homedir6 } from "os";
+
+// src/diagnostics/collect-doctor-issues.ts
 import * as fs11 from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join8, resolve as resolve9 } from "path";
+import { join as join9 } 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 fs11.access(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function addUnmanagedDirectoryIssues(entries, issues) {
+  for (const entry of entries) {
+    if (entry.kind !== "unmanaged-directory") {
+      continue;
+    }
+    if (await pathExists2(join9(entry.path, "SKILL.md"))) {
+      issues.push(
+        buildIssue2(
+          "unmanaged-skill-directory",
+          "warning",
+          `Unmanaged skill directory is present for ${entry.agentId}/${entry.skillName}`,
+          entry.path
+        )
+      );
+    }
+  }
+}
+async function addMissingManagedSkillIssues(manifest, issues) {
+  for (const skill of Object.values(manifest.skills)) {
+    if (await pathExists2(skill.path)) {
+      continue;
+    }
+    issues.push(
+      buildIssue2(
+        "missing-managed-skill-path",
+        "error",
+        `Managed skill path is missing for ${skill.id}`,
+        skill.path
+      )
+    );
+  }
+}
+function addConflictingAgentPathIssues(agents, issues) {
+  const pathToAgents = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    const key = normalizeAbsolutePath(agent.absoluteSkillsDirectoryPath);
+    const current = pathToAgents.get(key) ?? [];
+    current.push(agent);
+    pathToAgents.set(key, current);
+  }
+  for (const conflictedAgents of pathToAgents.values()) {
+    if (conflictedAgents.length < 2) {
+      continue;
+    }
+    const agentIds = conflictedAgents.map((agent) => agent.id).sort((left, right) => left.localeCompare(right));
+    issues.push(
+      buildIssue2(
+        "conflicting-agent-path",
+        "warning",
+        `Multiple agents resolve to the same skills directory: ${agentIds.join(", ")}`,
+        conflictedAgents[0].absoluteSkillsDirectoryPath
+      )
+    );
+  }
+}
+function issueSortKey(issue) {
+  return `${issue.severity}:${issue.code}:${issue.path ?? ""}:${issue.message}`;
+}
+function sortIssues(issues) {
+  return [...issues].sort(
+    (left, right) => issueSortKey(left).localeCompare(issueSortKey(right))
+  );
+}
+function dedupeAndSortIssues(issues) {
+  const issueByKey = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    issueByKey.set(issueSortKey(issue), issue);
+  }
+  return sortIssues([...issueByKey.values()]);
+}
+async function collectDoctorIssues(input) {
+  const issues = [];
+  await addUnmanagedDirectoryIssues(input.entries, issues);
+  await addMissingManagedSkillIssues(input.manifest, issues);
+  addConflictingAgentPathIssues(input.agents, issues);
+  return dedupeAndSortIssues(issues);
+}
+
+// src/commands/doctor.ts
+function buildTableOutput4(issues) {
+  if (issues.length === 0) {
+    return "No doctor issues found.\n";
+  }
+  return printTable(
+    issues.map((issue) => ({
+      severity: issue.severity,
+      code: issue.code,
+      path: issue.path ?? "",
+      message: issue.message
+    })),
+    [
+      { key: "severity", label: "Severity" },
+      { key: "code", label: "Code" },
+      { key: "path", label: "Path" },
+      { key: "message", label: "Message" }
+    ]
+  );
+}
+function buildJsonOutput(result) {
+  return printJson({
+    skillmuxHome: result.skillmuxHome,
+    issues: result.issues,
+    agents: result.agents.map((agent) => ({
+      id: agent.id,
+      path: agent.absoluteSkillsDirectoryPath,
+      supportedOnPlatform: agent.supportedOnPlatform
+    })),
+    entries: result.entries
+  });
+}
+async function runDoctor(options = {}) {
+  const homeDir = options.homeDir ?? homedir6();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const [manifest, config, agents] = await Promise.all([
+    readManifest(skillmuxHome),
+    loadUserConfig(skillmuxHome),
+    discoverAgents({
+      homeDir,
+      skillmuxHome,
+      platform: options.platform
+    })
+  ]);
+  const entries = [];
+  const issues = [];
+  for (const agent of agents) {
+    const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
+    entries.push(...scannedAgent.entries);
+    issues.push(...scannedAgent.issues);
+  }
+  const doctorIssues = await collectDoctorIssues({
+    manifest,
+    agents,
+    entries
+  });
+  const dedupedIssues = dedupeAndSortIssues([...issues, ...doctorIssues]);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    manifest,
+    config,
+    agents,
+    entries,
+    issues: dedupedIssues
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput4(dedupedIssues)
+  };
+}
+
+// src/commands/disable.ts
+import * as fs13 from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join10, resolve as resolve9 } from "path";
 
 // 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") {
@@ -1142,7 +1738,7 @@ function buildManagedSkillPath2(skillmuxHome, skillId) {
 }
 async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName, linkPath, timestamp) {
   try {
-    const entry = await fs11.lstat(linkPath);
+    const entry = await fs13.lstat(linkPath);
     if (!entry.isSymbolicLink()) {
       return void 0;
     }
@@ -1152,7 +1748,7 @@ async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName,
     }
     throw error;
   }
-  const sourcePath = await fs11.realpath(linkPath);
+  const sourcePath = await fs13.realpath(linkPath);
   await assertSkillSourceLayout(sourcePath);
   const managedSkillPath = buildManagedSkillPath2(skillmuxHome, skillId);
   await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
@@ -1181,9 +1777,9 @@ async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
   }
   return agent;
 }
-async function pathExists2(path) {
+async function pathExists3(path) {
   try {
-    await fs11.lstat(path);
+    await fs13.lstat(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1196,14 +1792,14 @@ async function runDisableSingle(options) {
   if (options.agent === void 0) {
     throw new Error("Disable requires one target agent");
   }
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir7();
   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 resolveTargetAgent2(homeDir, skillmuxHome, options.agent);
-  const linkPath = join8(agent.absoluteSkillsDirectoryPath, skillId);
+  const linkPath = join10(agent.absoluteSkillsDirectoryPath, skillId);
   const adoption = manifest.skills[skillId] ? void 0 : await tryAdoptManagedSkill(
     manifest,
     skillmuxHome,
@@ -1224,7 +1820,7 @@ async function runDisableSingle(options) {
   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;
-  if (adoption === void 0 && !linkMatchesSkill && await pathExists2(activationLinkPath)) {
+  if (adoption === void 0 && !linkMatchesSkill && await pathExists3(activationLinkPath)) {
     throw new Error(`Refusing to disable non-managed entry at ${linkPath}`);
   }
   const removedLink = adoptedLinkRemoved ? true : linkMatchesSkill ? await safeRemoveLink(activationLinkPath) : false;
@@ -1286,9 +1882,9 @@ async function runDisable(options) {
 }
 
 // src/commands/enable.ts
-import * as fs12 from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import * as fs14 from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join11 } from "path";
 function buildAgentRecord3(agent, timestamp) {
   return {
     id: agent.id,
@@ -1334,7 +1930,7 @@ async function runEnableSingle(options) {
   if (options.agent === void 0) {
     throw new Error("Enable requires one target agent");
   }
-  const homeDir = options.homeDir ?? homedir3();
+  const homeDir = options.homeDir ?? homedir8();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -1345,13 +1941,13 @@ async function runEnableSingle(options) {
     throw new Error(`Managed skill not found: ${skillId}`);
   }
   const agent = await resolveTargetAgent3(homeDir, skillmuxHome, options.agent);
-  const linkPath = join9(agent.absoluteSkillsDirectoryPath, skill.id);
+  const linkPath = join11(agent.absoluteSkillsDirectoryPath, skill.id);
   const currentActivation = manifest.activations.find(
     (entry) => entry.skillId === skill.id && entry.agentId === agent.id
   );
   const agentRecord = buildAgentRecord3(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) {
@@ -1418,8 +2014,48 @@ async function runEnable(options) {
   return runEnableSingle(options);
 }
 
+// src/commands/import.ts
+import { resolve as resolve10 } from "path";
+import { homedir as homedir9 } from "os";
+function buildManagedSkillPath3(skillmuxHome, skillId) {
+  return resolve10(skillmuxHome, "skills", skillId);
+}
+async function runImport(options) {
+  const homeDir = options.homeDir ?? homedir9();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  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 = buildManagedSkillPath3(skillmuxHome, skillId);
+  await assertSkillSourceLayout(sourcePath);
+  if (manifest.skills[skillId] !== void 0) {
+    throw new Error(`Managed skill already exists for ${skillId}`);
+  }
+  await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
+  const skill = {
+    id: skillId,
+    name: options.skillName,
+    path: managedSkillPath,
+    source: {
+      kind: "local",
+      path: sourcePath
+    },
+    importedAt
+  };
+  manifest.skills[skillId] = skill;
+  await writeManifest(skillmuxHome, manifest);
+  return {
+    skill,
+    manifest,
+    output: `Imported ${skillId} to ${managedSkillPath}
+`
+  };
+}
+
 // src/commands/scan.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir10 } from "os";
 
 // src/output/format-issue.ts
 function formatIssue(issue) {
@@ -1429,26 +2065,6 @@ function formatIssue(issue) {
   return `[${issue.severity}] ${issue.code} @ ${issue.path}: ${issue.message}`;
 }
 
-// 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/scan.ts
 function buildAgentRecord4(agent, timestamp, previousRecord) {
   const lastSeenAt = agent.exists ? timestamp : previousRecord?.lastSeenAt ?? null;
@@ -1500,7 +2116,7 @@ ${result.issues.map(formatIssue).join("\n")}
 `;
 }
 async function runScan(options = {}) {
-  const homeDir = options.homeDir ?? homedir4();
+  const homeDir = options.homeDir ?? homedir10();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const manifest = await readManifest(skillmuxHome);
@@ -1540,17 +2156,17 @@ async function runScan(options = {}) {
 }
 
 // src/commands/remove.ts
-import * as fs13 from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { resolve as resolve10 } from "path";
-function buildManagedSkillPath3(skillmuxHome, skillId) {
-  return resolve10(skillmuxHome, "skills", skillId);
+import * as fs15 from "fs/promises";
+import { homedir as homedir11 } from "os";
+import { resolve as resolve11 } from "path";
+function buildManagedSkillPath4(skillmuxHome, skillId) {
+  return resolve11(skillmuxHome, "skills", skillId);
 }
 function buildManifestPath(skillmuxHome) {
-  return resolve10(skillmuxHome, "manifest.json");
+  return resolve11(skillmuxHome, "manifest.json");
 }
 function buildConfigPath2(skillmuxHome) {
-  return resolve10(skillmuxHome, "config.json");
+  return resolve11(skillmuxHome, "config.json");
 }
 function resolveManagedSkill(manifest, skillNameOrId) {
   const skillId = normalizeId(skillNameOrId);
@@ -1576,7 +2192,7 @@ function buildHumanOutput(skill, managedSkillPath) {
   return `Removed ${skill.id} from ${managedSkillPath}
 `;
 }
-function buildJsonOutput(result) {
+function buildJsonOutput2(result) {
   return printJson({
     changed: result.changed,
     removedSkillId: result.removedSkillId,
@@ -1585,9 +2201,9 @@ function buildJsonOutput(result) {
     manifest: result.manifest
   });
 }
-async function pathExists3(path) {
+async function pathExists4(path) {
   try {
-    await fs13.lstat(path);
+    await fs15.lstat(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1597,15 +2213,15 @@ async function pathExists3(path) {
   }
 }
 async function assertManagedSkillRemovalSafety(skillmuxHome, skillPath, skillId) {
-  const expectedSkillPath = buildManagedSkillPath3(skillmuxHome, 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 pathExists3(skillPath)) {
+  if (!await pathExists4(skillPath)) {
     return;
   }
-  const entry = await fs13.lstat(skillPath);
+  const entry = await fs15.lstat(skillPath);
   if (entry.isSymbolicLink()) {
     throw new Error(`Refusing to remove symlinked managed skill path at ${skillPath}`);
   }
@@ -1617,14 +2233,14 @@ async function runRemoveSingle(options) {
   if (options.skill === void 0) {
     throw new Error("Remove requires one target skill");
   }
-  const homeDir = options.homeDir ?? homedir5();
+  const homeDir = options.homeDir ?? homedir11();
   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 = resolve10(skillmuxHome, "skills");
+  const managedSkillsDirectory = resolve11(skillmuxHome, "skills");
   const managedSkillPath = skill.path;
   const enabledActivations = manifest.activations.filter(
     (activation) => activation.skillId === skill.id && activation.state === "enabled"
@@ -1638,8 +2254,8 @@ async function runRemoveSingle(options) {
     );
   }
   await assertManagedSkillRemovalSafety(skillmuxHome, managedSkillPath, skill.id);
-  if (await pathExists3(managedSkillPath)) {
-    await fs13.rm(managedSkillPath, { recursive: true, force: false });
+  if (await pathExists4(managedSkillPath)) {
+    await fs15.rm(managedSkillPath, { recursive: true, force: false });
   }
   delete manifest.skills[skill.id];
   manifest.activations = manifest.activations.filter(
@@ -1661,7 +2277,7 @@ async function runRemoveSingle(options) {
   };
   return {
     ...resultWithoutOutput,
-    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildHumanOutput(skill, managedSkillPath)
+    output: options.json === true ? buildJsonOutput2(resultWithoutOutput) : buildHumanOutput(skill, managedSkillPath)
   };
 }
 async function runRemove(options) {
@@ -1699,128 +2315,32 @@ async function runRemove(options) {
   return runRemoveSingle(options);
 }
 
-// src/diagnostics/collect-doctor-issues.ts
-import * as fs14 from "fs/promises";
-import { join as join10 } from "path";
-function buildIssue2(code, severity, message, path) {
-  return path === void 0 ? { code, severity, message } : { code, severity, message, path };
-}
-async function pathExists4(path) {
-  try {
-    await fs14.access(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-async function addUnmanagedDirectoryIssues(entries, issues) {
-  for (const entry of entries) {
-    if (entry.kind !== "unmanaged-directory") {
-      continue;
-    }
-    if (await pathExists4(join10(entry.path, "SKILL.md"))) {
-      issues.push(
-        buildIssue2(
-          "unmanaged-skill-directory",
-          "warning",
-          `Unmanaged skill directory is present for ${entry.agentId}/${entry.skillName}`,
-          entry.path
-        )
-      );
-    }
-  }
-}
-async function addMissingManagedSkillIssues(manifest, issues) {
-  for (const skill of Object.values(manifest.skills)) {
-    if (await pathExists4(skill.path)) {
-      continue;
-    }
-    issues.push(
-      buildIssue2(
-        "missing-managed-skill-path",
-        "error",
-        `Managed skill path is missing for ${skill.id}`,
-        skill.path
-      )
-    );
-  }
-}
-function addConflictingAgentPathIssues(agents, issues) {
-  const pathToAgents = /* @__PURE__ */ new Map();
-  for (const agent of agents) {
-    const key = normalizeAbsolutePath(agent.absoluteSkillsDirectoryPath);
-    const current = pathToAgents.get(key) ?? [];
-    current.push(agent);
-    pathToAgents.set(key, current);
-  }
-  for (const conflictedAgents of pathToAgents.values()) {
-    if (conflictedAgents.length < 2) {
-      continue;
-    }
-    const agentIds = conflictedAgents.map((agent) => agent.id).sort((left, right) => left.localeCompare(right));
-    issues.push(
-      buildIssue2(
-        "conflicting-agent-path",
-        "warning",
-        `Multiple agents resolve to the same skills directory: ${agentIds.join(", ")}`,
-        conflictedAgents[0].absoluteSkillsDirectoryPath
-      )
-    );
-  }
-}
-function issueSortKey(issue) {
-  return `${issue.severity}:${issue.code}:${issue.path ?? ""}:${issue.message}`;
-}
-function sortIssues(issues) {
-  return [...issues].sort(
-    (left, right) => issueSortKey(left).localeCompare(issueSortKey(right))
-  );
-}
-function dedupeAndSortIssues(issues) {
-  const issueByKey = /* @__PURE__ */ new Map();
-  for (const issue of issues) {
-    issueByKey.set(issueSortKey(issue), issue);
-  }
-  return sortIssues([...issueByKey.values()]);
-}
-async function collectDoctorIssues(input) {
-  const issues = [];
-  await addUnmanagedDirectoryIssues(input.entries, issues);
-  await addMissingManagedSkillIssues(input.manifest, issues);
-  addConflictingAgentPathIssues(input.agents, issues);
-  return dedupeAndSortIssues(issues);
-}
-
 export {
   supportedPlatforms,
-  InvalidIdentifierError,
   ManifestValidationError,
-  UserConfigValidationError,
-  normalizeId,
   buildConfigPath,
   resolveSkillmuxHome,
   loadUserConfig,
   discoverAgents,
   isPathInside,
   scanAgentSkills,
-  assertSkillSourceLayout,
-  copySkillContentsToManagedStore,
   buildEmptyManifest,
   manifestSchema,
-  writeManifest,
   formatValidationIssues2 as formatValidationIssues,
-  readManifest,
   printJson,
   runAdopt,
   printTable,
+  normalizeAgentId,
+  runConfigAddAgent,
+  runConfigRemoveAgent,
+  runConfigUpdateAgent,
   dedupeAndSortIssues,
   collectDoctorIssues,
+  runDoctor,
   runDisable,
   runEnable,
+  runImport,
   runScan,
   runRemove
 };
-//# sourceMappingURL=chunk-DBEVDI27.js.map
+//# sourceMappingURL=chunk-OY3C7VIL.js.map