skillmux 0.1.4 → 0.1.5

package/dist/{chunk-EEIOA7GC.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);
@@ -1085,7 +1198,7 @@ async function runAdopt(options) {
 }
 
 // src/commands/config-add-agent.ts
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // src/config/agent-override-validation.ts
 import { isAbsolute } from "path";
@@ -1126,19 +1239,6 @@ function normalizePlatforms(value) {
   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/output/print-table.ts
 function printTable(rows, columns) {
   const renderedRows = rows.map(
@@ -1211,7 +1311,7 @@ function buildTableOutput(result) {
   return `${summary}${detail}`;
 }
 async function runConfigAddAgent(options) {
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir3();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const configPath = buildConfigPath(skillmuxHome);
@@ -1242,7 +1342,7 @@ async function runConfigAddAgent(options) {
 }
 
 // src/commands/config-remove-agent.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 function normalizeAgentId2(value) {
   const trimmed = value.trim();
   if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
@@ -1269,18 +1369,22 @@ function buildTableOutput2(result) {
   );
 }
 async function runConfigRemoveAgent(options) {
-  const homeDir = options.homeDir ?? homedir3();
+  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);
@@ -1300,7 +1404,7 @@ async function runConfigRemoveAgent(options) {
 }
 
 // src/commands/config-update-agent.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 function buildAgentPatch(options) {
   const patch = {};
   if (options.root !== void 0) {
@@ -1364,7 +1468,7 @@ function buildTableOutput3(result) {
   return `${summary}${detail}`;
 }
 async function runConfigUpdateAgent(options) {
-  const homeDir = options.homeDir ?? homedir4();
+  const homeDir = options.homeDir ?? homedir5();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const configPath = buildConfigPath(skillmuxHome);
@@ -1378,6 +1482,9 @@ async function runConfigUpdateAgent(options) {
     ...previous,
     ...buildAgentPatch(options)
   };
+  if (previous.autoDiscovered === true) {
+    delete agent.autoDiscovered;
+  }
   const changed = JSON.stringify(previous) !== JSON.stringify(agent);
   const nextConfig = {
     ...config,
@@ -1404,11 +1511,11 @@ async function runConfigUpdateAgent(options) {
 }
 
 // src/commands/doctor.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 
 // src/diagnostics/collect-doctor-issues.ts
 import * as fs11 from "fs/promises";
-import { join as join8 } 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 };
 }
@@ -1428,7 +1535,7 @@ async function addUnmanagedDirectoryIssues(entries, issues) {
     if (entry.kind !== "unmanaged-directory") {
       continue;
     }
-    if (await pathExists2(join8(entry.path, "SKILL.md"))) {
+    if (await pathExists2(join9(entry.path, "SKILL.md"))) {
       issues.push(
         buildIssue2(
           "unmanaged-skill-directory",
@@ -1534,7 +1641,7 @@ function buildJsonOutput(result) {
   });
 }
 async function runDoctor(options = {}) {
-  const homeDir = options.homeDir ?? homedir5();
+  const homeDir = options.homeDir ?? homedir6();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const [manifest, config, agents] = await Promise.all([
@@ -1575,8 +1682,8 @@ async function runDoctor(options = {}) {
 
 // src/commands/disable.ts
 import * as fs13 from "fs/promises";
-import { homedir as homedir6 } from "os";
-import { join as join9, resolve as resolve9 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join10, resolve as resolve9 } from "path";
 
 // src/fs/safe-remove-link.ts
 import * as fs12 from "fs/promises";
@@ -1685,14 +1792,14 @@ async function runDisableSingle(options) {
   if (options.agent === void 0) {
     throw new Error("Disable requires one target agent");
   }
-  const homeDir = options.homeDir ?? homedir6();
+  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 = join9(agent.absoluteSkillsDirectoryPath, skillId);
+  const linkPath = join10(agent.absoluteSkillsDirectoryPath, skillId);
   const adoption = manifest.skills[skillId] ? void 0 : await tryAdoptManagedSkill(
     manifest,
     skillmuxHome,
@@ -1776,8 +1883,8 @@ async function runDisable(options) {
 
 // src/commands/enable.ts
 import * as fs14 from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join11 } from "path";
 function buildAgentRecord3(agent, timestamp) {
   return {
     id: agent.id,
@@ -1823,7 +1930,7 @@ async function runEnableSingle(options) {
   if (options.agent === void 0) {
     throw new Error("Enable requires one target agent");
   }
-  const homeDir = options.homeDir ?? homedir7();
+  const homeDir = options.homeDir ?? homedir8();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -1834,7 +1941,7 @@ async function runEnableSingle(options) {
     throw new Error(`Managed skill not found: ${skillId}`);
   }
   const agent = await resolveTargetAgent3(homeDir, skillmuxHome, options.agent);
-  const linkPath = join10(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
   );
@@ -1909,12 +2016,12 @@ async function runEnable(options) {
 
 // src/commands/import.ts
 import { resolve as resolve10 } from "path";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 function buildManagedSkillPath3(skillmuxHome, skillId) {
   return resolve10(skillmuxHome, "skills", skillId);
 }
 async function runImport(options) {
-  const homeDir = options.homeDir ?? homedir8();
+  const homeDir = options.homeDir ?? homedir9();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const sourcePath = resolve10(options.sourcePath);
@@ -1948,7 +2055,7 @@ async function runImport(options) {
 }
 
 // src/commands/scan.ts
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 
 // src/output/format-issue.ts
 function formatIssue(issue) {
@@ -2009,7 +2116,7 @@ ${result.issues.map(formatIssue).join("\n")}
 `;
 }
 async function runScan(options = {}) {
-  const homeDir = options.homeDir ?? homedir9();
+  const homeDir = options.homeDir ?? homedir10();
   const resolvedPaths = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
   const manifest = await readManifest(skillmuxHome);
@@ -2050,7 +2157,7 @@ async function runScan(options = {}) {
 
 // src/commands/remove.ts
 import * as fs15 from "fs/promises";
-import { homedir as homedir10 } from "os";
+import { homedir as homedir11 } from "os";
 import { resolve as resolve11 } from "path";
 function buildManagedSkillPath4(skillmuxHome, skillId) {
   return resolve11(skillmuxHome, "skills", skillId);
@@ -2126,7 +2233,7 @@ async function runRemoveSingle(options) {
   if (options.skill === void 0) {
     throw new Error("Remove requires one target skill");
   }
-  const homeDir = options.homeDir ?? homedir10();
+  const homeDir = options.homeDir ?? homedir11();
   const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
   const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
   const manifestPath = buildManifestPath(skillmuxHome);
@@ -2236,4 +2343,4 @@ export {
   runScan,
   runRemove
 };
-//# sourceMappingURL=chunk-EEIOA7GC.js.map
+//# sourceMappingURL=chunk-OY3C7VIL.js.map