skillmux 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,1819 +1,8 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
-
-// src/config/default-agent-rules.ts
-var supportedPlatforms = ["win32", "linux", "darwin"];
-var builtInAgentIds = [
-  "codex",
-  "claude",
-  "gemini",
-  "agents",
-  "openclaw"
-];
-var defaultAgentRules = [
-  {
-    id: "codex",
-    stableName: "OpenAI Codex",
-    supportedPlatforms: [...supportedPlatforms],
-    homeRelativeRootPath: ".codex",
-    skillsDirectoryPath: "skills",
-    enabledByDefault: true,
-    discovery: "builtin"
-  },
-  {
-    id: "claude",
-    stableName: "Claude Code",
-    supportedPlatforms: [...supportedPlatforms],
-    homeRelativeRootPath: ".claude",
-    skillsDirectoryPath: "skills",
-    enabledByDefault: true,
-    discovery: "builtin"
-  },
-  {
-    id: "gemini",
-    stableName: "Gemini CLI",
-    supportedPlatforms: [...supportedPlatforms],
-    homeRelativeRootPath: ".gemini",
-    skillsDirectoryPath: "skills",
-    enabledByDefault: true,
-    discovery: "builtin"
-  },
-  {
-    id: "agents",
-    stableName: "Agents",
-    supportedPlatforms: [...supportedPlatforms],
-    homeRelativeRootPath: ".agents",
-    skillsDirectoryPath: "skills",
-    enabledByDefault: true,
-    discovery: "builtin"
-  },
-  {
-    id: "openclaw",
-    stableName: "OpenClaw",
-    supportedPlatforms: [...supportedPlatforms],
-    homeRelativeRootPath: ".openclaw",
-    skillsDirectoryPath: "skills",
-    enabledByDefault: true,
-    discovery: "builtin"
-  }
-];
-var defaultAgentRuleMap = Object.fromEntries(
-  defaultAgentRules.map((rule) => [rule.id, rule])
-);
-
-// src/commands/agents.ts
-import { homedir } from "os";
-
-// src/config/resolve-skillmux-home.ts
-import { join, resolve } from "path";
-function buildConfigPath(skillmuxHome) {
-  return join(resolve(skillmuxHome), "config.json");
-}
-function resolveSkillmuxHome(homeDir) {
-  const resolvedHomeDir = resolve(homeDir);
-  const skillmuxHome = join(resolvedHomeDir, ".skillmux");
-  return {
-    skillmuxHome,
-    configPath: buildConfigPath(skillmuxHome)
-  };
-}
-
-// src/discovery/discover-agents.ts
-import * as fs2 from "fs/promises";
-import { join as join2, resolve as resolve2 } from "path";
-
-// src/config/load-user-config.ts
-import * as fs from "fs/promises";
-import { z } from "zod";
-
-// src/core/errors.ts
-var SkillMuxError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var InvalidIdentifierError = class extends SkillMuxError {
-  constructor(kind, value) {
-    super(`Invalid ${kind}: ${value}`);
-    this.kind = kind;
-    this.value = value;
-  }
-  kind;
-  value;
-};
-var ManifestValidationError = class extends SkillMuxError {
-  constructor(message) {
-    super(message);
-  }
-};
-var UserConfigValidationError = class extends SkillMuxError {
-  constructor(message) {
-    super(message);
-  }
-};
-
-// src/config/load-user-config.ts
-var supportedPlatformSchema = z.enum(supportedPlatforms);
-var agentOverrideSchema = z.object({
-  stableName: z.string().min(1).optional(),
-  supportedPlatforms: z.array(supportedPlatformSchema).min(1).optional(),
-  homeRelativeRootPath: z.string().min(1).optional(),
-  skillsDirectoryPath: z.string().min(1).optional(),
-  enabledByDefault: z.boolean().optional()
-}).strict();
-var userConfigSchema = z.object({
-  version: z.literal(1),
-  agents: z.record(z.string().min(1), agentOverrideSchema)
-}).strict();
-function createEmptyUserConfig() {
-  return {
-    version: 1,
-    agents: {}
-  };
-}
-function stripUtf8Bom(contents) {
-  return contents.charCodeAt(0) === 65279 ? contents.slice(1) : contents;
-}
-function formatValidationIssues(error) {
-  return error.issues.map((issue) => {
-    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-    return `${path}: ${issue.message}`;
-  }).join("; ");
-}
-async function loadUserConfig(skillmuxHome) {
-  const configPath = buildConfigPath(skillmuxHome);
-  try {
-    const contents = await fs.readFile(configPath, "utf8");
-    const parsed = JSON.parse(stripUtf8Bom(contents));
-    const validated = userConfigSchema.safeParse(parsed);
-    if (!validated.success) {
-      throw new UserConfigValidationError(
-        `Invalid config at ${configPath}: ${formatValidationIssues(validated.error)}`
-      );
-    }
-    return validated.data;
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-      return createEmptyUserConfig();
-    }
-    if (error instanceof SyntaxError) {
-      throw new UserConfigValidationError(
-        `Invalid config at ${configPath}: malformed JSON`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/discovery/discover-agents.ts
-function mergeRule(rule, override) {
-  if (override === void 0) {
-    return rule;
-  }
-  return {
-    ...rule,
-    ...override
-  };
-}
-function buildCustomRule(id, override) {
-  if (override.homeRelativeRootPath === void 0 || override.skillsDirectoryPath === void 0) {
-    throw new Error(
-      `Custom agent override "${id}" must define homeRelativeRootPath and skillsDirectoryPath`
-    );
-  }
-  return {
-    id,
-    stableName: override.stableName ?? id,
-    supportedPlatforms: override.supportedPlatforms ?? [...supportedPlatforms],
-    homeRelativeRootPath: override.homeRelativeRootPath,
-    skillsDirectoryPath: override.skillsDirectoryPath,
-    enabledByDefault: override.enabledByDefault ?? true,
-    discovery: "custom"
-  };
-}
-async function pathExists(path) {
-  try {
-    await fs2.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveAgentRulePaths(homeDir, rule) {
-  const absoluteRootPath = resolve2(homeDir, rule.homeRelativeRootPath);
-  return {
-    absoluteRootPath,
-    absoluteSkillsDirectoryPath: join2(
-      absoluteRootPath,
-      rule.skillsDirectoryPath
-    )
-  };
-}
-async function discoverAgents(options) {
-  const platform = options.platform ?? process.platform;
-  const homeDir = resolve2(options.homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolveSkillmuxHome(homeDir).skillmuxHome;
-  const userConfig = await loadUserConfig(skillmuxHome);
-  const discoveredAgents = [];
-  for (const agentId of builtInAgentIds) {
-    const mergedRule = mergeRule(
-      defaultAgentRuleMap[agentId],
-      userConfig.agents[agentId]
-    );
-    const resolvedPaths = resolveAgentRulePaths(homeDir, mergedRule);
-    discoveredAgents.push({
-      ...mergedRule,
-      ...resolvedPaths,
-      exists: await pathExists(resolvedPaths.absoluteSkillsDirectoryPath),
-      supportedOnPlatform: mergedRule.supportedPlatforms.some(
-        (supportedPlatform) => supportedPlatform === platform
-      )
-    });
-  }
-  for (const [agentId, override] of Object.entries(userConfig.agents)) {
-    if (Object.hasOwn(defaultAgentRuleMap, agentId)) {
-      continue;
-    }
-    const customRule = buildCustomRule(agentId, override);
-    const resolvedPaths = resolveAgentRulePaths(homeDir, customRule);
-    discoveredAgents.push({
-      ...customRule,
-      ...resolvedPaths,
-      exists: await pathExists(resolvedPaths.absoluteSkillsDirectoryPath),
-      supportedOnPlatform: customRule.supportedPlatforms.some(
-        (supportedPlatform) => supportedPlatform === platform
-      )
-    });
-  }
-  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/core/ids.ts
-var ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function normalizeId(value) {
-  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized.length > 0 ? normalized : "skill";
-}
-function isValidId(value) {
-  return ID_PATTERN.test(value);
-}
-
-// src/config/write-user-config.ts
-import * as fs3 from "fs/promises";
-async function writeUserConfig(skillmuxHome, config) {
-  const configPath = buildConfigPath(skillmuxHome);
-  await fs3.mkdir(skillmuxHome, { recursive: true });
-  await fs3.writeFile(configPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-  return {
-    skillmuxHome,
-    configPath
-  };
-}
-
-// src/commands/config-add-agent.ts
-function normalizeRelativePath(value, field) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    throw new UserConfigValidationError(`${field} must not be empty`);
-  }
-  if (isAbsolute(trimmed)) {
-    throw new UserConfigValidationError(`${field} must be a relative path`);
-  }
-  const normalized = trimmed.replaceAll("\\", "/");
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
-    throw new UserConfigValidationError(`${field} must stay within the configured home-relative tree`);
-  }
-  return normalized.replace(/^\.\/+/, "");
-}
-function normalizeAgentId(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
-    throw new InvalidIdentifierError("agent id", value);
-  }
-  return normalizeId(trimmed);
-}
-function normalizePlatforms(value) {
-  if (value === void 0 || value.length === 0) {
-    return [process.platform];
-  }
-  const normalized = [...new Set(value.map((entry) => entry.trim().toLowerCase()))];
-  const invalid = normalized.filter(
-    (entry) => supportedPlatforms.includes(entry) === false
-  );
-  if (invalid.length > 0) {
-    throw new UserConfigValidationError(
-      `platform must be one of: ${supportedPlatforms.join(", ")}`
-    );
-  }
-  return normalized;
-}
-function buildAgentOverride(options) {
-  const agentId = normalizeAgentId(options.id);
-  const agent = {
-    supportedPlatforms: normalizePlatforms(options.platforms),
-    homeRelativeRootPath: normalizeRelativePath(options.root, "root"),
-    skillsDirectoryPath: normalizeRelativePath(options.skills ?? "skills", "skills")
-  };
-  if (options.name !== void 0 && options.name.trim().length > 0) {
-    agent.stableName = options.name.trim();
-  }
-  if (options.disabledByDefault === true) {
-    agent.enabledByDefault = false;
-  }
-  return { agentId, agent };
-}
-function buildTableOutput2(result) {
-  const summary = printTable(
-    [
-      {
-        agentId: result.agentId,
-        configPath: result.configPath,
-        changed: String(result.changed)
-      }
-    ],
-    [
-      { key: "agentId", label: "Agent" },
-      { key: "configPath", label: "Config Path" },
-      { key: "changed", label: "Changed" }
-    ]
-  );
-  const detail = printTable(
-    [
-      {
-        stableName: result.agent.stableName ?? "",
-        platforms: (result.agent.supportedPlatforms ?? []).join(","),
-        root: result.agent.homeRelativeRootPath ?? "",
-        skills: result.agent.skillsDirectoryPath ?? "",
-        enabledByDefault: result.agent.enabledByDefault === void 0 ? "" : String(result.agent.enabledByDefault)
-      }
-    ],
-    [
-      { key: "stableName", label: "Name" },
-      { key: "platforms", label: "Platforms" },
-      { key: "root", label: "Root" },
-      { key: "skills", label: "Skills Dir" },
-      { key: "enabledByDefault", label: "Enabled By Default" }
-    ]
-  );
-  return `${summary}${detail}`;
-}
-async function runConfigAddAgent(options) {
-  const homeDir = options.homeDir ?? homedir2();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const configPath = buildConfigPath(skillmuxHome);
-  const config = await loadUserConfig(skillmuxHome);
-  const { agentId, agent } = buildAgentOverride(options);
-  const previous = config.agents[agentId];
-  const changed = JSON.stringify(previous ?? null) !== JSON.stringify(agent);
-  const nextConfig = {
-    ...config,
-    agents: {
-      ...config.agents,
-      [agentId]: agent
-    }
-  };
-  await writeUserConfig(skillmuxHome, nextConfig);
-  const resultWithoutOutput = {
-    skillmuxHome,
-    configPath,
-    agentId,
-    changed,
-    agent,
-    config: nextConfig
-  };
-  return {
-    ...resultWithoutOutput,
-    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(resultWithoutOutput)
-  };
-}
-
-// src/commands/config-remove-agent.ts
-import { homedir as homedir3 } from "os";
-function normalizeAgentId2(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
-    throw new InvalidIdentifierError("agent id", value);
-  }
-  return normalizeId(trimmed);
-}
-function buildTableOutput3(result) {
-  return printTable(
-    [
-      {
-        agentId: result.agentId,
-        configPath: result.configPath,
-        changed: String(result.changed),
-        removed: String(result.removed)
-      }
-    ],
-    [
-      { key: "agentId", label: "Agent" },
-      { key: "configPath", label: "Config Path" },
-      { key: "changed", label: "Changed" },
-      { key: "removed", label: "Removed" }
-    ]
-  );
-}
-async function runConfigRemoveAgent(options) {
-  const homeDir = options.homeDir ?? homedir3();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const configPath = buildConfigPath(skillmuxHome);
-  const config = await loadUserConfig(skillmuxHome);
-  const agentId = normalizeAgentId2(options.id);
-  const removed = agentId in config.agents;
-  const nextConfig = {
-    ...config,
-    agents: Object.fromEntries(
-      Object.entries(config.agents).filter(([currentAgentId]) => currentAgentId !== agentId)
-    )
-  };
-  if (removed) {
-    await writeUserConfig(skillmuxHome, nextConfig);
-  }
-  const resultWithoutOutput = {
-    skillmuxHome,
-    configPath,
-    agentId,
-    changed: removed,
-    removed,
-    config: nextConfig
-  };
-  return {
-    ...resultWithoutOutput,
-    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput3(resultWithoutOutput)
-  };
-}
-
-// src/commands/config.ts
-import { homedir as homedir4 } from "os";
-function buildTableOutput4(result) {
-  const summary = printTable(
-    [
-      {
-        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
-          }
-        };
-      }
-      return {
-        entry: {
-          agentId: options.agentId,
-          agentName: options.agentName,
-          skillName,
-          kind: "unknown",
-          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") {
-        throw error;
-      }
-      return {
-        entry: {
-          agentId: options.agentId,
-          agentName: options.agentName,
-          skillName,
-          kind: "broken-link",
-          path: absolutePath
-        },
-        issue: buildIssue(
-          "broken-link",
-          "error",
-          "Skill entry points to a missing target",
-          absolutePath
-        )
-      };
-    }
-  }
-  if (stats.isDirectory()) {
-    return {
-      entry: {
-        agentId: options.agentId,
-        agentName: options.agentName,
-        skillName,
-        kind: "unmanaged-directory",
-        path: absolutePath
-      }
-    };
-  }
-  return {
-    entry: {
-      agentId: options.agentId,
-      agentName: options.agentName,
-      skillName,
-      kind: "unknown",
-      path: absolutePath
-    },
-    issue: buildIssue(
-      "unknown-entry",
-      "warning",
-      "Skill entry is neither a managed link nor a directory",
-      absolutePath
-    )
-  };
-}
-
-// src/discovery/scan-agent-skills.ts
-async function scanAgentSkills(agent, skillmuxHome) {
-  if (!agent.exists || !agent.supportedOnPlatform) {
-    return {
-      entries: [],
-      issues: []
-    };
-  }
-  const directoryEntries = await fs6.readdir(agent.absoluteSkillsDirectoryPath, {
-    withFileTypes: true
-  });
-  const sortedDirectoryEntries = [...directoryEntries].sort(
-    (left, right) => left.name.localeCompare(right.name)
-  );
-  const entries = [];
-  const issues = [];
-  for (const directoryEntry of sortedDirectoryEntries) {
-    const result = await inferSkillEntry({
-      agentId: agent.id,
-      agentName: agent.stableName,
-      path: `${agent.absoluteSkillsDirectoryPath}/${directoryEntry.name}`,
-      skillmuxHome
-    });
-    entries.push(result.entry);
-    if (result.issue !== void 0) {
-      issues.push(result.issue);
-    }
-  }
-  return {
-    entries,
-    issues
-  };
-}
-
-// src/manifest/read-manifest.ts
-import * as fs8 from "fs/promises";
-import { join as join4, resolve as resolve5 } from "path";
-
-// src/manifest/build-empty-manifest.ts
-function buildEmptyManifest(skillmuxHome) {
-  return {
-    version: 1,
-    skillmuxHome,
-    skills: {},
-    agents: {},
-    activations: [],
-    lastScan: {
-      at: null,
-      issues: []
-    }
-  };
-}
-
-// src/manifest/manifest-schema.ts
-import { z as z2 } from "zod";
-var idSchema = z2.string().min(1).refine(isValidId, "Expected a canonical lowercase slug identifier");
-var scanIssueSchema = z2.object({
-  code: z2.string().min(1),
-  severity: z2.enum(["info", "warning", "error"]),
-  message: z2.string().min(1),
-  path: z2.string().min(1).optional()
-}).strict();
-var managedSkillSchema = z2.object({
-  id: idSchema,
-  name: z2.string().min(1),
-  path: z2.string().min(1),
-  source: z2.object({
-    kind: z2.enum(["local", "imported"]),
-    path: z2.string().min(1)
-  }).strict(),
-  importedAt: z2.string().min(1)
-}).strict();
-var agentRecordSchema = z2.object({
-  id: idSchema,
-  name: z2.string().min(1),
-  path: z2.string().min(1),
-  discovery: z2.enum(["builtin", "custom"]),
-  available: z2.boolean(),
-  lastSeenAt: z2.string().min(1).nullable()
-}).strict();
-var activationRecordSchema = z2.object({
-  skillId: idSchema,
-  agentId: idSchema,
-  linkPath: z2.string().min(1),
-  state: z2.enum(["enabled", "disabled"]),
-  updatedAt: z2.string().min(1)
-}).strict();
-var manifestSchema = z2.object({
-  version: z2.literal(1),
-  skillmuxHome: z2.string().min(1),
-  skills: z2.record(z2.string(), managedSkillSchema),
-  agents: z2.record(z2.string(), agentRecordSchema),
-  activations: z2.array(activationRecordSchema),
-  lastScan: z2.object({
-    at: z2.string().min(1).nullable(),
-    issues: z2.array(scanIssueSchema)
-  }).strict()
-}).strict().superRefine((manifest, ctx) => {
-  for (const [skillId, skill] of Object.entries(manifest.skills)) {
-    if (!isValidId(skillId)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["skills", skillId],
-        message: `Invalid skill id key: ${skillId}`
-      });
-    }
-    if (skill.id !== skillId) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["skills", skillId, "id"],
-        message: `Skill id must match its record key: ${skillId}`
-      });
-    }
-  }
-  for (const [agentId, agent] of Object.entries(manifest.agents)) {
-    if (!isValidId(agentId)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["agents", agentId],
-        message: `Invalid agent id key: ${agentId}`
-      });
-    }
-    if (agent.id !== agentId) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["agents", agentId, "id"],
-        message: `Agent id must match its record key: ${agentId}`
-      });
-    }
-  }
-  const activationPairs = /* @__PURE__ */ new Set();
-  manifest.activations.forEach((activation, index) => {
-    if (!(activation.skillId in manifest.skills)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["activations", index, "skillId"],
-        message: `Unknown skill reference: ${activation.skillId}`
-      });
-    }
-    if (!(activation.agentId in manifest.agents)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["activations", index, "agentId"],
-        message: `Unknown agent reference: ${activation.agentId}`
-      });
-    }
-    const pairKey = `${activation.skillId}:${activation.agentId}`;
-    if (activationPairs.has(pairKey)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: ["activations", index],
-        message: `Duplicate activation for ${pairKey}`
-      });
-      return;
-    }
-    activationPairs.add(pairKey);
-  });
-});
-
-// src/manifest/write-manifest.ts
-import { randomUUID } from "crypto";
-import * as fs7 from "fs/promises";
-import { join as join3 } from "path";
-function getManifestPath(home) {
-  return join3(home, "manifest.json");
-}
-function createManifestTempPath(manifestPath) {
-  return `${manifestPath}.${process.pid}.${randomUUID()}.tmp`;
-}
-async function writeManifest(home, manifest) {
-  await fs7.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");
-  try {
-    await fs7.rename(tempPath, manifestPath);
-  } catch (error) {
-    await fs7.unlink(tempPath).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/manifest/read-manifest.ts
-function getManifestPath2(home) {
-  return join4(home, "manifest.json");
-}
-function normalizeHomePath(home) {
-  const resolvedHome = resolve5(home);
-  return process.platform === "win32" ? resolvedHome.toLowerCase() : resolvedHome;
-}
-function formatValidationIssues2(error) {
-  return error.issues.map((issue) => {
-    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-    return `${path}: ${issue.message}`;
-  }).join("; ");
-}
-async function readManifest(home) {
-  const manifestPath = getManifestPath2(home);
-  try {
-    const contents = await fs8.readFile(manifestPath, "utf8");
-    const parsedJson = JSON.parse(contents);
-    const parsedManifest = manifestSchema.safeParse(parsedJson);
-    if (!parsedManifest.success) {
-      throw new ManifestValidationError(
-        `Invalid manifest at ${manifestPath}: ${formatValidationIssues2(parsedManifest.error)}`
-      );
-    }
-    if (normalizeHomePath(parsedManifest.data.skillmuxHome) !== normalizeHomePath(home)) {
-      throw new ManifestValidationError(
-        `Invalid manifest at ${manifestPath}: skillmuxHome must match ${home}`
-      );
-    }
-    return parsedManifest.data;
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-      const emptyManifest = buildEmptyManifest(home);
-      await writeManifest(home, emptyManifest);
-      return emptyManifest;
-    }
-    if (error instanceof SyntaxError) {
-      throw new ManifestValidationError(
-        `Invalid manifest at ${manifestPath}: malformed JSON`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/commands/doctor.ts
-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);
-    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(join5(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 buildTableOutput5(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 ?? homedir5();
-  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);
-  }
-  await addUnmanagedDirectoryIssues(entries, issues);
-  await addMissingManagedSkillIssues(manifest, issues);
-  addConflictingAgentPathIssues(agents, issues);
-  const dedupedIssues = [...issues].sort((left, right) => {
-    const leftKey = `${left.severity}:${left.code}:${left.path ?? ""}:${left.message}`;
-    const rightKey = `${right.severity}:${right.code}:${right.path ?? ""}:${right.message}`;
-    return leftKey.localeCompare(rightKey);
-  });
-  const resultWithoutOutput = {
-    skillmuxHome,
-    manifest,
-    config,
-    agents,
-    entries,
-    issues: dedupedIssues
-  };
-  return {
-    ...resultWithoutOutput,
-    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput5(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;
-  }
-}
-
-// src/fs/safe-remove-link.ts
-import * as fs12 from "fs/promises";
-async function safeRemoveLink(path) {
-  try {
-    const entry = await fs12.lstat(path);
-    if (!entry.isSymbolicLink()) {
-      return false;
-    }
-    await fs12.rm(path, { recursive: true, force: false });
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-
-// src/commands/disable.ts
-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: "disabled",
-    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;
-}
-function buildManagedSkillPath(skillmuxHome, skillId) {
-  return resolve8(skillmuxHome, "skills", skillId);
-}
-async function tryAdoptManagedSkill(manifest, skillmuxHome, skillId, skillName, linkPath, timestamp) {
-  try {
-    const entry = await fs13.lstat(linkPath);
-    if (!entry.isSymbolicLink()) {
-      return void 0;
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-  const sourcePath = await fs13.realpath(linkPath);
-  await assertSkillSourceLayout(sourcePath);
-  const managedSkillPath = buildManagedSkillPath(skillmuxHome, skillId);
-  await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
-  const skill = {
-    id: skillId,
-    name: skillName,
-    path: managedSkillPath,
-    source: {
-      kind: "imported",
-      path: sourcePath
-    },
-    importedAt: timestamp
-  };
-  manifest.skills[skillId] = skill;
-  return { skill, sourcePath };
-}
-async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
-  const agentId = normalizeId(agentName);
-  const agents = await discoverAgents({ homeDir, skillmuxHome });
-  const agent = agents.find((entry) => entry.id === agentId);
-  if (agent === void 0) {
-    throw new Error(`Unknown agent: ${agentName}`);
-  }
-  if (!agent.supportedOnPlatform) {
-    throw new Error(`Agent ${agent.id} is not supported on ${process.platform}`);
-  }
-  return agent;
-}
-async function pathExists3(path) {
-  try {
-    await fs13.lstat(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-async function runDisable(options) {
-  const homeDir = options.homeDir ?? homedir6();
-  const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
-  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const manifest = await readManifest(skillmuxHome);
-  const skillId = normalizeId(options.skill);
-  const agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
-  const linkPath = join7(agent.absoluteSkillsDirectoryPath, skillId);
-  const adoption = manifest.skills[skillId] ? void 0 : await tryAdoptManagedSkill(
-    manifest,
-    skillmuxHome,
-    skillId,
-    options.skill,
-    linkPath,
-    timestamp
-  );
-  const skill = manifest.skills[skillId] ?? adoption?.skill;
-  if (skill === void 0) {
-    throw new Error(`Managed skill not found: ${skillId}`);
-  }
-  const currentActivation = manifest.activations.find(
-    (entry) => entry.skillId === skill.id && entry.agentId === agent.id
-  );
-  const activationLinkPath = currentActivation?.linkPath ?? linkPath;
-  const agentRecord = buildAgentRecord(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;
-  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;
-  if (removedLink === false && currentActivation?.state !== "enabled") {
-    return {
-      changed: false,
-      skill,
-      agent: agentRecord,
-      activation: currentActivation ?? null,
-      manifest,
-      output: `${skill.id} is already disabled for ${agent.id}
-`
-    };
-  }
-  const activation = buildActivationRecord(skill.id, agent.id, linkPath, timestamp);
-  upsertActivation(manifest, activation);
-  await writeManifest(skillmuxHome, manifest);
-  return {
-    changed: true,
-    skill,
-    agent: agentRecord,
-    activation,
-    manifest,
-    output: `Disabled ${skill.id} for ${agent.id}
-`
-  };
-}
-
-// 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) {
-  return {
-    id: agent.id,
-    name: agent.stableName,
-    path: agent.absoluteSkillsDirectoryPath,
-    discovery: agent.discovery,
-    available: agent.supportedOnPlatform,
-    lastSeenAt: timestamp
-  };
-}
-function buildActivationRecord2(skillId, agentId, linkPath, timestamp, state) {
-  return {
-    skillId,
-    agentId,
-    linkPath,
-    state,
-    updatedAt: timestamp
-  };
-}
-function upsertActivation2(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 resolveTargetAgent2(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 Error(`Unknown agent: ${agentName}`);
-  }
-  if (!agent.supportedOnPlatform) {
-    throw new Error(`Agent ${agent.id} is not supported on ${process.platform}`);
-  }
-  return agent;
-}
-async function runEnable(options) {
-  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 skill = manifest.skills[skillId];
-  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 currentActivation = manifest.activations.find(
-    (entry) => entry.skillId === skill.id && entry.agentId === agent.id
-  );
-  const agentRecord = buildAgentRecord2(agent, timestamp);
-  manifest.agents[agent.id] = agentRecord;
-  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) {
-    return {
-      changed: false,
-      skill,
-      agent: agentRecord,
-      activation: currentActivation,
-      manifest,
-      output: `${skill.id} is already enabled for ${agent.id}
-`
-    };
-  }
-  await createManagedLink(linkPath, skill.path);
-  const activation = buildActivationRecord2(
-    skill.id,
-    agent.id,
-    linkPath,
-    timestamp,
-    "enabled"
-  );
-  upsertActivation2(manifest, activation);
-  await writeManifest(skillmuxHome, manifest);
-  return {
-    changed: true,
-    skill,
-    agent: agentRecord,
-    activation,
-    manifest,
-    output: `Enabled ${skill.id} for ${agent.id}
-`
-  };
-}
-
-// 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);
-}
-async function runImport(options) {
-  const homeDir = options.homeDir ?? homedir8();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const sourcePath = resolve9(options.sourcePath);
-  const skillId = normalizeId(options.skillName);
-  const importedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const manifest = await readManifest(skillmuxHome);
-  const managedSkillPath = buildManagedSkillPath2(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 homedir9 } from "os";
-
-// src/output/format-issue.ts
-function formatIssue(issue) {
-  if (issue.path === void 0) {
-    return `[${issue.severity}] ${issue.code}: ${issue.message}`;
-  }
-  return `[${issue.severity}] ${issue.code} @ ${issue.path}: ${issue.message}`;
-}
-
-// src/commands/scan.ts
-function buildAgentRecord3(agent, timestamp, previousRecord) {
-  const lastSeenAt = agent.exists ? timestamp : previousRecord?.lastSeenAt ?? null;
-  return {
-    id: agent.id,
-    name: agent.stableName,
-    path: agent.absoluteSkillsDirectoryPath,
-    discovery: agent.discovery,
-    available: agent.exists && agent.supportedOnPlatform,
-    lastSeenAt
-  };
-}
-function buildScanOutput(result, json) {
-  if (json) {
-    return printJson({
-      lastScan: result.manifest.lastScan,
-      agents: result.agents.map((agent) => ({
-        id: agent.id,
-        name: agent.stableName,
-        path: agent.absoluteSkillsDirectoryPath,
-        exists: agent.exists,
-        supportedOnPlatform: agent.supportedOnPlatform
-      })),
-      entries: result.entries
-    });
-  }
-  if (result.entries.length === 0) {
-    return "No skill entries found.\n";
-  }
-  const table = printTable(
-    result.entries.map((entry) => ({
-      agent: entry.agentId,
-      skill: entry.skillName,
-      kind: entry.kind,
-      path: entry.path
-    })),
-    [
-      { key: "agent", label: "Agent" },
-      { key: "skill", label: "Skill" },
-      { key: "kind", label: "Kind" },
-      { key: "path", label: "Path" }
-    ]
-  );
-  if (result.issues.length === 0) {
-    return table;
-  }
-  return `${table}
-${result.issues.map(formatIssue).join("\n")}
-`;
-}
-async function runScan(options = {}) {
-  const homeDir = options.homeDir ?? homedir9();
-  const resolvedPaths = resolveSkillmuxHome(homeDir);
-  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
-  const manifest = await readManifest(skillmuxHome);
-  const agents = await discoverAgents({
-    homeDir,
-    platform: options.platform,
-    skillmuxHome
-  });
-  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  const entries = [];
-  const issues = [];
-  for (const agent of agents) {
-    const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
-    entries.push(...scannedAgent.entries);
-    issues.push(...scannedAgent.issues);
-    manifest.agents[agent.id] = buildAgentRecord3(
-      agent,
-      timestamp,
-      manifest.agents[agent.id]
-    );
-  }
-  manifest.lastScan = {
-    at: timestamp,
-    issues
-  };
-  await writeManifest(skillmuxHome, manifest);
-  const resultWithoutOutput = {
-    manifest,
-    agents,
-    entries,
-    issues
-  };
-  return {
-    ...resultWithoutOutput,
-    output: buildScanOutput(resultWithoutOutput, options.json === true)
-  };
-}
-
-// src/commands/list.ts
-function buildRecordsView(scanResult) {
-  return {
-    view: "records",
-    records: scanResult.entries,
-    issues: scanResult.issues
-  };
-}
-function buildAgentsView(scanResult) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const agent of scanResult.agents) {
-    groups.set(agent.id, {
-      agentId: agent.id,
-      agentName: agent.stableName,
-      entries: []
-    });
-  }
-  for (const entry of scanResult.entries) {
-    const current = groups.get(entry.agentId) ?? {
-      agentId: entry.agentId,
-      agentName: entry.agentName,
-      entries: []
-    };
-    current.entries.push(entry);
-    groups.set(entry.agentId, current);
-  }
-  return {
-    view: "agents",
-    agents: [...groups.values()].sort(
-      (left, right) => left.agentId.localeCompare(right.agentId)
-    ),
-    issues: scanResult.issues
-  };
-}
-function buildSkillsView(scanResult) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const skill of Object.values(scanResult.manifest.skills)) {
-    groups.set(skill.id, {
-      skillName: skill.id,
-      entries: []
-    });
-  }
-  for (const entry of scanResult.entries) {
-    const current = groups.get(entry.skillName) ?? {
-      skillName: entry.skillName,
-      entries: []
-    };
-    current.entries.push(entry);
-    groups.set(entry.skillName, current);
-  }
-  return {
-    view: "skills",
-    skills: [...groups.values()].sort(
-      (left, right) => left.skillName.localeCompare(right.skillName)
-    ),
-    issues: scanResult.issues
-  };
-}
-function buildListData(scanResult, view) {
-  if (view === "agents") {
-    return buildAgentsView(scanResult);
-  }
-  if (view === "skills") {
-    return buildSkillsView(scanResult);
-  }
-  return buildRecordsView(scanResult);
-}
-function buildTableOutput6(data, view) {
-  if (view === "agents") {
-    const agentRows = data.agents;
-    return printTable(
-      agentRows.map((agent) => ({
-        agent: agent.agentId,
-        name: agent.agentName,
-        entries: String(agent.entries.length)
-      })),
-      [
-        { key: "agent", label: "Agent" },
-        { key: "name", label: "Name" },
-        { key: "entries", label: "Entries" }
-      ]
-    );
-  }
-  if (view === "skills") {
-    const skillRows = data.skills;
-    return printTable(
-      skillRows.map((skill) => ({
-        skill: skill.skillName,
-        entries: String(skill.entries.length)
-      })),
-      [
-        { key: "skill", label: "Skill" },
-        { key: "entries", label: "Entries" }
-      ]
-    );
-  }
-  const records = data.records;
-  return printTable(
-    records.map((record) => ({
-      agent: record.agentId,
-      skill: record.skillName,
-      kind: record.kind
-    })),
-    [
-      { key: "agent", label: "Agent" },
-      { key: "skill", label: "Skill" },
-      { key: "kind", label: "Kind" }
-    ]
-  );
-}
-async function runList(options = {}) {
-  const view = options.view ?? "records";
-  const format = options.format ?? "table";
-  const scanResult = await runScan(options);
-  const data = buildListData(scanResult, view);
-  return {
-    data,
-    output: format === "json" ? printJson(data) : buildTableOutput6(data, view)
-  };
-}
-
-// src/index.ts
-function buildCli() {
-  const program = new Command();
-  program.name("skillmux");
-  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);
-  });
-  program.command("agents").option("--json", "Emit structured JSON output").action(async (options) => {
-    const result = await runAgents({ json: options.json === true });
-    process.stdout.write(result.output);
-  });
-  program.command("list").option("--view <view>", "Select records, agents, or skills view", "records").option("--format <format>", "Select table or json output", "table").action(async (options) => {
-    const result = await runList({
-      view: options.view,
-      format: options.format
-    });
-    process.stdout.write(result.output);
-  });
-  program.command("import").requiredOption("--source <path>", "Local skill source directory").requiredOption("--name <name>", "Managed skill name").action(async (options) => {
-    const result = await runImport({
-      sourcePath: options.source,
-      skillName: options.name
-    });
-    process.stdout.write(result.output);
-  });
-  program.command("doctor").option("--json", "Emit structured JSON output").action(async (options) => {
-    const result = await runDoctor({ json: options.json === true });
-    process.stdout.write(result.output);
-  });
-  const configCommand = program.command("config");
-  configCommand.option("--json", "Emit structured JSON output").action(async (options) => {
-    const result = await runConfig({ json: options.json === true });
-    process.stdout.write(result.output);
-  });
-  configCommand.command("add-agent").requiredOption("--id <id>", "Agent id").requiredOption("--root <path>", "Home-relative root path").option("--skills <path>", "Skills directory path relative to the agent root", "skills").option("--name <name>", "Stable display name").option(
-    "--platform <platform>",
-    `Supported platform (${supportedPlatforms.join(", ")})`,
-    (value, previous = []) => [...previous, value],
-    []
-  ).option("--disabled-by-default", "Mark this custom agent as disabled by default").option("--json", "Emit structured JSON output").action(
-    async (options) => {
-      const result = await runConfigAddAgent({
-        id: options.id,
-        root: options.root,
-        skills: options.skills,
-        name: options.name,
-        platforms: options.platform,
-        disabledByDefault: options.disabledByDefault === true,
-        json: options.json === true
-      });
-      process.stdout.write(result.output);
-    }
-  );
-  configCommand.command("remove-agent").requiredOption("--id <id>", "Agent id").option("--json", "Emit structured JSON output").action(async (options) => {
-    const result = await runConfigRemoveAgent({
-      id: options.id,
-      json: options.json === true
-    });
-    process.stdout.write(result.output);
-  });
-  program.command("enable").requiredOption("--skill <skill>", "Managed skill name or id").requiredOption("--agent <agent>", "Target agent id").action(async (options) => {
-    const result = await runEnable({
-      skill: options.skill,
-      agent: options.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) => {
-    const result = await runDisable({
-      skill: options.skill,
-      agent: options.agent
-    });
-    process.stdout.write(result.output);
-  });
-  return program;
-}
+import {
+  buildCli
+} from "./chunk-UMN3UJFN.js";
+import "./chunk-DBEVDI27.js";
 
 // src/cli.ts
 await buildCli().parseAsync(process.argv);