@agentver/cli 0.1.3 → 0.2.1

package/dist/agentver.js

@@ -2,10 +2,10 @@
 
 // bin/agentver.ts
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname6, join as join23 } from "path";
+import { dirname as dirname7, join as join26 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
-import chalk28 from "chalk";
+import chalk33 from "chalk";
 import updateNotifier from "update-notifier";
 
 // src/commands/adopt.ts
@@ -960,7 +960,8 @@ var manifestV2PackageSchema = z.object({
   source: packageSourceSchema,
   agents: z.array(z.string()).default([]),
   installedAt: z.string().datetime(),
-  modified: z.boolean().default(false)
+  modified: z.boolean().default(false),
+  pinned: z.boolean().optional()
 });
 var manifestV2Schema = z.object({
   version: z.literal(2),
@@ -1147,7 +1148,8 @@ var statusResultSchema = z2.object({
     name: z2.string(),
     status: z2.string(),
     modified: z2.boolean(),
-    upstream: z2.boolean()
+    upstream: z2.boolean(),
+    pinned: z2.boolean().optional()
   })),
   summary: z2.object({
     total: z2.number(),
@@ -1205,6 +1207,39 @@ var adoptResultSchema = z2.object({
     reason: z2.string()
   }))
 });
+var infoResultSchema = z2.object({
+  name: z2.string(),
+  source: z2.object({
+    type: z2.string(),
+    uri: z2.string().optional(),
+    ref: z2.string().optional(),
+    commit: z2.string().optional(),
+    hostname: z2.string().optional()
+  }),
+  agents: z2.array(z2.string()),
+  installedAt: z2.string(),
+  modified: z2.boolean(),
+  integrity: z2.string().optional(),
+  files: z2.object({
+    count: z2.number(),
+    totalSize: z2.number()
+  }),
+  skill: z2.object({
+    title: z2.string(),
+    description: z2.string()
+  }).optional()
+});
+var doctorCheckSchema = z2.object({
+  name: z2.string(),
+  status: z2.enum(["pass", "fail", "warn"]),
+  message: z2.string()
+});
+var doctorResultSchema = z2.object({
+  checks: z2.array(doctorCheckSchema),
+  passed: z2.number(),
+  failed: z2.number(),
+  warnings: z2.number()
+});
 
 // ../shared/dist/errors.js
 var AgentverError = class extends Error {
@@ -1774,7 +1809,7 @@ function formatWithOptions(inspectOptions, ...args) {
   const first = args[0];
   let a = 0;
   let str = "";
-  let join24 = "";
+  let join27 = "";
   if (typeof first === "string") {
     if (args.length === 1) {
       return first;
@@ -1873,7 +1908,7 @@ function formatWithOptions(inspectOptions, ...args) {
     }
     if (lastPos !== 0) {
       a++;
-      join24 = " ";
+      join27 = " ";
       if (lastPos < first.length) {
         str += first.slice(lastPos);
       }
@@ -1881,9 +1916,9 @@ function formatWithOptions(inspectOptions, ...args) {
   }
   while (a < args.length) {
     const value = args[a];
-    str += join24;
+    str += join27;
     str += typeof value !== "string" ? inspect(value, inspectOptions) : value;
-    join24 = " ";
+    join27 = " ";
     a++;
   }
   return str;
@@ -2957,6 +2992,22 @@ var AGENTVER_EXTENSION_FIELDS = [
   "dependsOn",
   "conflictsWith"
 ];
+function parseSkillFrontmatter(content) {
+  const { rawData, body, hasFrontmatter } = parseFrontmatter(content);
+  if (!hasFrontmatter) {
+    throw new Error("No YAML frontmatter found. Expected content delimited by --- markers.");
+  }
+  const parsed = agentverSkillSchema.safeParse(rawData);
+  if (!parsed.success) {
+    const messages = parsed.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    throw new Error(`Invalid SKILL.md frontmatter:
+${messages.join("\n")}`);
+  }
+  return { frontmatter: parsed.data, body };
+}
 function validateSkillMd(content) {
   const errors = [];
   const warnings = [];
@@ -4526,6 +4577,9 @@ async function isAuthenticated() {
 // src/registry/config.ts
 var CONFIG_DIR = join7(homedir4(), ".agentver");
 var CONFIG_PATH = join7(CONFIG_DIR, "config.json");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
 function readConfig() {
   if (!existsSync6(CONFIG_PATH)) {
     return {};
@@ -4928,8 +4982,325 @@ Auditing ${packageNames.length} package${packageNames.length === 1 ? "" : "s"}..
   });
 }
 
-// src/commands/diff.ts
+// src/commands/completion.ts
+import { appendFileSync, existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join10 } from "path";
 import chalk5 from "chalk";
+var TOP_LEVEL_COMMANDS = [
+  "adopt",
+  "audit",
+  "completion",
+  "config",
+  "diff",
+  "doctor",
+  "draft",
+  "info",
+  "init",
+  "install",
+  "list",
+  "log",
+  "login",
+  "logout",
+  "publish",
+  "remove",
+  "save",
+  "scan",
+  "search",
+  "status",
+  "suggest",
+  "suggestions",
+  "sync",
+  "update",
+  "upgrade",
+  "verify",
+  "version",
+  "whoami"
+];
+var SUBCOMMANDS = {
+  draft: ["create", "list", "switch", "publish", "discard"],
+  version: ["create", "list"],
+  config: ["list", "get", "set", "unset", "path"],
+  completion: ["bash", "zsh", "fish"]
+};
+var COMMON_FLAGS = ["--json", "--global", "--dry-run", "--help"];
+function generateBashScript() {
+  const subcmdCases = Object.entries(SUBCOMMANDS).map(
+    ([cmd, subs]) => `      ${cmd})
+        COMPREPLY=( $(compgen -W "${subs.join(" ")}" -- "$cur") )
+        return 0
+        ;;`
+  ).join("\n");
+  return `# agentver bash completion
+_agentver() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${TOP_LEVEL_COMMANDS.join(" ")}"
+
+  if [[ "$COMP_CWORD" -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+    return 0
+  fi
+
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=( $(compgen -W "${COMMON_FLAGS.join(" ")}" -- "$cur") )
+    return 0
+  fi
+
+  case "$prev" in
+${subcmdCases}
+  esac
+
+  return 0
+}
+
+complete -F _agentver agentver
+`;
+}
+function generateZshScript() {
+  const subcmdCases = Object.entries(SUBCOMMANDS).map(
+    ([cmd, subs]) => `    ${cmd})
+      _values 'subcommand' ${subs.map((s) => `'${s}'`).join(" ")}
+      ;;`
+  ).join("\n");
+  return `# agentver zsh completion
+_agentver() {
+  local -a commands
+  commands=(
+${TOP_LEVEL_COMMANDS.map((c) => `    '${c}'`).join("\n")}
+  )
+
+  _arguments -C     '--json[Output results as structured JSON]'     '--global[Apply globally]'     '--dry-run[Preview changes without applying]'     '--help[Show help]'     '1:command:->cmd'     '*::arg:->args'
+
+  case "$state" in
+    cmd)
+      _describe 'command' commands
+      ;;
+    args)
+      case "\${words[1]}" in
+${subcmdCases}
+      esac
+      ;;
+  esac
+}
+
+compdef _agentver agentver
+`;
+}
+function generateFishScript() {
+  const topLevelCompletions = TOP_LEVEL_COMMANDS.map(
+    (cmd) => `complete -c agentver -n '__fish_use_subcommand' -a '${cmd}'`
+  ).join("\n");
+  const subcmdCompletions = Object.entries(SUBCOMMANDS).flatMap(
+    ([cmd, subs]) => subs.map((sub) => `complete -c agentver -n '__fish_seen_subcommand_from ${cmd}' -a '${sub}'`)
+  ).join("\n");
+  const flagCompletions = [
+    "complete -c agentver -l json -d 'Output results as structured JSON'",
+    "complete -c agentver -l global -d 'Apply globally'",
+    "complete -c agentver -l dry-run -d 'Preview changes without applying'",
+    "complete -c agentver -l help -d 'Show help'"
+  ].join("\n");
+  return `# agentver fish completion
+${topLevelCompletions}
+${subcmdCompletions}
+${flagCompletions}
+`;
+}
+var SHELL_GENERATORS = {
+  bash: generateBashScript,
+  zsh: generateZshScript,
+  fish: generateFishScript
+};
+var RC_PATHS = {
+  bash: join10(homedir6(), ".bashrc"),
+  zsh: join10(homedir6(), ".zshrc"),
+  fish: join10(homedir6(), ".config", "fish", "config.fish")
+};
+var EVAL_LINES = {
+  bash: 'eval "$(agentver completion bash)"',
+  zsh: 'eval "$(agentver completion zsh)"',
+  fish: "agentver completion fish | source"
+};
+function installCompletion(shell) {
+  const rcPath = RC_PATHS[shell];
+  const evalLine = EVAL_LINES[shell];
+  if (existsSync8(rcPath)) {
+    const content = readFileSync7(rcPath, "utf-8");
+    if (content.includes(evalLine)) {
+      process.stdout.write(chalk5.dim(`Completion already installed in ${rcPath}
+`));
+      return;
+    }
+  }
+  appendFileSync(rcPath, `
+# agentver shell completion
+${evalLine}
+`);
+  process.stdout.write(
+    chalk5.green(`Completion installed in ${rcPath}
+`) + chalk5.dim("Restart your shell or run: ") + chalk5.cyan(`source ${rcPath}`) + "\n"
+  );
+}
+function registerCompletionCommand(program2) {
+  program2.command("completion <shell>").description("Generate shell completion scripts (bash, zsh, fish)").option("--install", "Install the completion script to your shell RC file").action((shell, options) => {
+    const jsonMode = isJSONMode();
+    if (!["bash", "zsh", "fish"].includes(shell)) {
+      if (jsonMode) {
+        outputError("INVALID_SHELL", `Unsupported shell "${shell}". Supported: bash, zsh, fish`);
+        process.exit(1);
+      }
+      process.stderr.write(
+        chalk5.red(`Unsupported shell "${shell}". Supported: bash, zsh, fish
+`)
+      );
+      process.exit(1);
+    }
+    const validShell = shell;
+    const script = SHELL_GENERATORS[validShell]();
+    if (options.install) {
+      if (jsonMode) {
+        installCompletion(validShell);
+        outputSuccess({ shell: validShell, installed: true, rcPath: RC_PATHS[validShell] });
+        return;
+      }
+      installCompletion(validShell);
+      return;
+    }
+    if (jsonMode) {
+      outputSuccess({ shell: validShell, script });
+      return;
+    }
+    process.stdout.write(script);
+  });
+}
+
+// src/commands/config.ts
+import chalk6 from "chalk";
+var KNOWN_KEYS = ["platformUrl", "defaultOrg", "telemetry"];
+function isKnownKey(key) {
+  return KNOWN_KEYS.includes(key);
+}
+function formatValue2(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function validateKey(key) {
+  if (!isKnownKey(key)) {
+    if (isJSONMode()) {
+      outputError("INVALID_KEY", `Unknown config key: ${key}. Valid keys: ${KNOWN_KEYS.join(", ")}`);
+    } else {
+      console.error(chalk6.red(`Unknown config key: ${key}. Valid keys: ${KNOWN_KEYS.join(", ")}`));
+    }
+    return false;
+  }
+  return true;
+}
+function validateValue(key, value) {
+  switch (key) {
+    case "telemetry": {
+      if (value !== "true" && value !== "false") {
+        if (isJSONMode()) {
+          outputError("INVALID_VALUE", "telemetry must be true or false");
+        } else {
+          console.error(chalk6.red("telemetry must be true or false"));
+        }
+        return { valid: false };
+      }
+      return { valid: true, parsed: value === "true" };
+    }
+    case "platformUrl": {
+      if (!value.startsWith("https://")) {
+        if (isJSONMode()) {
+          outputError("INVALID_VALUE", "platformUrl must start with https://");
+        } else {
+          console.error(chalk6.red("platformUrl must start with https://"));
+        }
+        return { valid: false };
+      }
+      return { valid: true, parsed: value };
+    }
+    default:
+      return { valid: true, parsed: value };
+  }
+}
+function registerConfigCommand(program2) {
+  const configCmd = program2.command("config").description("Manage CLI configuration");
+  configCmd.command("list").description("Show all config values").option("--json", "Output as JSON").action(() => {
+    const config = readConfig();
+    const jsonMode = isJSONMode();
+    if (jsonMode) {
+      outputSuccess(config);
+      return;
+    }
+    const entries = Object.entries(config);
+    if (entries.length === 0) {
+      console.log(chalk6.dim("No configuration set."));
+      return;
+    }
+    console.log(chalk6.bold("\nConfiguration:\n"));
+    for (const [key, value] of entries) {
+      console.log(`  ${chalk6.green(key)} = ${chalk6.cyan(formatValue2(value))}`);
+    }
+    console.log();
+  });
+  configCmd.command("get").description("Get a config value").argument("<key>", "Config key to read").option("--json", "Output as JSON").action((key) => {
+    const jsonMode = isJSONMode();
+    if (!validateKey(key)) {
+      process.exit(1);
+    }
+    const config = readConfig();
+    const value = config[key];
+    if (jsonMode) {
+      outputSuccess({ key, value: value ?? null });
+      return;
+    }
+    if (value === void 0) {
+      process.exit(0);
+    }
+    console.log(formatValue2(value));
+  });
+  configCmd.command("set").description("Set a config value").argument("<key>", "Config key to set").argument("<value>", "Value to set").option("--json", "Output as JSON").action((key, value) => {
+    const jsonMode = isJSONMode();
+    if (!validateKey(key)) {
+      process.exit(1);
+    }
+    const validation = validateValue(key, value);
+    if (!validation.valid) {
+      process.exit(1);
+    }
+    const config = readConfig();
+    const updated = { ...config, [key]: validation.parsed };
+    writeConfig(updated);
+    if (jsonMode) {
+      outputSuccess({ key, value: validation.parsed });
+      return;
+    }
+    console.log(chalk6.green(`Set ${key} = ${formatValue2(validation.parsed)}`));
+  });
+  configCmd.command("unset").description("Remove a config key").argument("<key>", "Config key to remove").option("--json", "Output as JSON").action((key) => {
+    const jsonMode = isJSONMode();
+    if (!validateKey(key)) {
+      process.exit(1);
+    }
+    const config = readConfig();
+    delete config[key];
+    writeConfig(config);
+    if (jsonMode) {
+      outputSuccess({ key, removed: true });
+      return;
+    }
+    console.log(chalk6.green(`Removed ${key}`));
+  });
+  configCmd.command("path").description("Print the config file path").action(() => {
+    console.log(getConfigPath());
+  });
+}
+
+// src/commands/diff.ts
+import chalk7 from "chalk";
 
 // src/git/resolver.ts
 var logger4 = createLogger("git:resolver");
@@ -5314,17 +5685,17 @@ function diffFiles(upstreamFiles, localFiles) {
 function formatDiff(diffs) {
   const output = [];
   for (const diff of diffs) {
-    output.push(chalk5.bold(`--- a/${diff.path}`));
-    output.push(chalk5.bold(`+++ b/${diff.path}`));
+    output.push(chalk7.bold(`--- a/${diff.path}`));
+    output.push(chalk7.bold(`+++ b/${diff.path}`));
     for (const hunk of diff.hunks) {
       output.push(
-        chalk5.cyan(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`)
+        chalk7.cyan(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`)
       );
       for (const line of hunk.lines) {
         if (line.startsWith("+")) {
-          output.push(chalk5.green(line));
+          output.push(chalk7.green(line));
         } else if (line.startsWith("-")) {
-          output.push(chalk5.red(line));
+          output.push(chalk7.red(line));
         } else {
           output.push(line);
         }
@@ -5346,7 +5717,7 @@ function registerDiffCommand(program2) {
         outputError("NOT_INSTALLED", `Package "${name}" is not installed.`);
         process.exit(1);
       }
-      console.error(chalk5.red(`Package "${name}" is not installed.`));
+      console.error(chalk7.red(`Package "${name}" is not installed.`));
       process.exit(1);
     }
     const { source, agents } = manifestEntry;
@@ -5356,11 +5727,11 @@ function registerDiffCommand(program2) {
         process.exit(1);
       }
       console.error(
-        chalk5.red(
+        chalk7.red(
           `Package "${name}" was installed from a well-known source (${source.hostname}).`
         )
       );
-      console.error(chalk5.dim("Diff is not yet supported for well-known sources."));
+      console.error(chalk7.dim("Diff is not yet supported for well-known sources."));
       process.exit(1);
     }
     if (source.uri === "unknown") {
@@ -5372,11 +5743,11 @@ function registerDiffCommand(program2) {
         process.exit(1);
       }
       console.error(
-        chalk5.red(`Package "${name}" was migrated from v1 and has no known Git source.`)
+        chalk7.red(`Package "${name}" was migrated from v1 and has no known Git source.`)
       );
       console.error(
-        chalk5.dim("Reinstall it using a Git source URL to enable diff:\n") + chalk5.dim(`  agentver remove ${name}
-`) + chalk5.dim(`  agentver install <git-source>`)
+        chalk7.dim("Reinstall it using a Git source URL to enable diff:\n") + chalk7.dim(`  agentver remove ${name}
+`) + chalk7.dim(`  agentver install <git-source>`)
       );
       process.exit(1);
     }
@@ -5430,7 +5801,7 @@ function registerDiffCommand(program2) {
         return;
       }
       if (diffs.length === 0) {
-        console.log(chalk5.green("No differences found."));
+        console.log(chalk7.green("No differences found."));
         return;
       }
       console.log(formatDiff(diffs));
@@ -5446,132 +5817,449 @@ function registerDiffCommand(program2) {
   });
 }
 
-// src/commands/draft.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { basename as basename2, join as join10 } from "path";
-import chalk6 from "chalk";
-import ora2 from "ora";
-
-// src/registry/platform.ts
-var DEFAULT_TIMEOUT_MS = 1e4;
-async function platformFetch(path, options = {}) {
-  const platformUrl = getPlatformUrl();
-  if (!platformUrl) {
-    throw new AgentverError(
-      "UNAUTHORISED",
-      "No platform URL configured. Run `agentver login <url>` to connect."
-    );
+// src/commands/doctor.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync9, lstatSync as lstatSync2, readFileSync as readFileSync8, readlinkSync as readlinkSync2 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+import chalk8 from "chalk";
+var MANIFEST_DIR2 = ".agentver";
+var MANIFEST_FILE2 = "manifest.json";
+var LOCKFILE_FILE2 = "lockfile.json";
+var NETWORK_TIMEOUT_MS = 3e3;
+var MIN_NODE_VERSION = 20;
+function check(name, status, message) {
+  return { name, status, message };
+}
+function checkManifestIntegrity(projectRoot) {
+  const manifestPath = join11(projectRoot, MANIFEST_DIR2, MANIFEST_FILE2);
+  if (!existsSync9(manifestPath)) {
+    return check("manifest-integrity", "warn", "Manifest file not found (no skills installed yet)");
+  }
+  let raw;
+  try {
+    raw = readFileSync8(manifestPath, "utf-8");
+  } catch {
+    return check("manifest-integrity", "fail", "Cannot read manifest file");
   }
-  const credentials = await getCredentials();
-  if (!credentials?.token && !credentials?.apiKey) {
-    throw new AgentverError("UNAUTHORISED", "Not authenticated. Run `agentver login` to sign in.");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return check("manifest-integrity", "fail", "Manifest contains invalid JSON");
   }
-  const url = `${platformUrl}/api/v1${path}`;
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (credentials.token) {
-    headers.Authorization = `Bearer ${credentials.token}`;
-  } else if (credentials.apiKey) {
-    headers["X-API-Key"] = credentials.apiKey;
+  const result = manifestAnySchema.safeParse(parsed);
+  if (!result.success) {
+    return check("manifest-integrity", "fail", "Manifest does not match expected schema");
   }
-  const controller = new AbortController();
-  const timeoutMs = options.timeout ?? DEFAULT_TIMEOUT_MS;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  return check("manifest-integrity", "pass", "Manifest is valid");
+}
+function checkLockfileIntegrity(projectRoot) {
+  const lockfilePath = join11(projectRoot, MANIFEST_DIR2, LOCKFILE_FILE2);
+  if (!existsSync9(lockfilePath)) {
+    return check("lockfile-integrity", "warn", "Lockfile not found (no skills installed yet)");
+  }
+  let raw;
   try {
-    const response = await fetch(url, {
-      method: options.method ?? "GET",
-      headers,
-      body: options.body ? JSON.stringify(options.body) : void 0,
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      const errorBody = await response.text().catch(() => "Unknown error");
-      throw new AgentverError("INTERNAL_ERROR", `Platform error (${response.status}): ${errorBody}`);
-    }
-    return response.json();
-  } finally {
-    clearTimeout(timeoutId);
+    raw = readFileSync8(lockfilePath, "utf-8");
+  } catch {
+    return check("lockfile-integrity", "fail", "Cannot read lockfile");
   }
-}
-async function platformFetchSilent(path, options = {}) {
+  let parsed;
   try {
-    return await platformFetch(path, options);
+    parsed = JSON.parse(raw);
   } catch {
-    return null;
+    return check("lockfile-integrity", "fail", "Lockfile contains invalid JSON");
   }
+  const result = lockfileAnySchema.safeParse(parsed);
+  if (!result.success) {
+    return check("lockfile-integrity", "fail", "Lockfile does not match expected schema");
+  }
+  return check("lockfile-integrity", "pass", "Lockfile is valid");
 }
-
-// src/commands/draft.ts
-function resolveSkillIdentity() {
-  const cwd = process.cwd();
-  const skillMdPath = join10(cwd, "SKILL.md");
-  let skillName = null;
-  if (existsSync8(skillMdPath)) {
-    const content = readFileSync7(skillMdPath, "utf-8");
-    const nameMatch = content.match(/^name:\s*(.+)$/m);
-    skillName = nameMatch?.[1]?.trim() ?? basename2(cwd);
+function checkManifestLockfileSync(projectRoot) {
+  const manifest = readManifest(projectRoot);
+  const lockfile = readLockfile(projectRoot);
+  const manifestNames = new Set(Object.keys(manifest.packages));
+  const lockfileNames = new Set(Object.keys(lockfile.packages));
+  if (manifestNames.size === 0 && lockfileNames.size === 0) {
+    return check("manifest-lockfile-sync", "pass", "Manifest and lockfile are in sync (both empty)");
   }
-  if (!skillName) {
-    skillName = basename2(cwd);
+  const inManifestOnly = [];
+  const inLockfileOnly = [];
+  for (const name of manifestNames) {
+    if (!lockfileNames.has(name)) {
+      inManifestOnly.push(name);
+    }
   }
-  const manifest = readManifest(cwd);
-  const entry = manifest.packages[skillName];
-  if (entry?.source.type === "git") {
-    const parts = entry.source.uri.split("/");
-    const org = parts.length >= 2 ? parts[parts.length - 2] : parts[0];
-    if (org) {
-      return { org, name: skillName };
+  for (const name of lockfileNames) {
+    if (!manifestNames.has(name)) {
+      inLockfileOnly.push(name);
     }
   }
-  const pathParts = cwd.split("/");
-  const skillsIdx = pathParts.lastIndexOf("skills");
-  if (skillsIdx >= 0 && pathParts.length > skillsIdx + 2) {
-    return { org: pathParts[skillsIdx + 1], name: skillName };
+  if (inManifestOnly.length > 0 || inLockfileOnly.length > 0) {
+    const parts = [];
+    if (inManifestOnly.length > 0) {
+      parts.push(`in manifest but not lockfile: ${inManifestOnly.join(", ")}`);
+    }
+    if (inLockfileOnly.length > 0) {
+      parts.push(`in lockfile but not manifest: ${inLockfileOnly.join(", ")}`);
+    }
+    return check("manifest-lockfile-sync", "fail", `Out of sync \u2014 ${parts.join("; ")}`);
   }
-  return null;
+  return check("manifest-lockfile-sync", "pass", "Manifest and lockfile are in sync");
 }
-function registerDraftCommand(program2) {
-  const draft = program2.command("draft").description("Manage skill drafts (branches)");
-  draft.command("create <name>").description("Create a draft branch for the current skill").option("--json", "Output as JSON").action(async (name, options) => {
-    const identity = resolveSkillIdentity();
-    if (!identity) {
-      process.stderr.write(
-        chalk6.red("Could not determine skill identity. Run this from a skill directory.\n")
-      );
-      process.exit(1);
+function checkSkillFilesExist(projectRoot) {
+  const manifest = readManifest(projectRoot);
+  const entries = Object.keys(manifest.packages);
+  if (entries.length === 0) {
+    return check("skill-files-exist", "pass", "No packages installed");
+  }
+  const missing = [];
+  for (const name of entries) {
+    const canonicalPath = getCanonicalSkillPath(projectRoot, name, "project");
+    if (!existsSync9(canonicalPath) || !lstatSync2(canonicalPath).isDirectory()) {
+      missing.push(name);
     }
-    const spinner = ora2(`Creating draft "${name}"...`).start();
-    try {
-      const result = await platformFetch(
-        `/skills/@${identity.org}/${identity.name}/drafts`,
-        {
-          method: "POST",
-          body: { name }
+  }
+  if (missing.length > 0) {
+    return check("skill-files-exist", "fail", `Missing skill directories: ${missing.join(", ")}`);
+  }
+  return check("skill-files-exist", "pass", `All ${entries.length} skill directories present`);
+}
+function checkSymlinksValid(projectRoot) {
+  const manifest = readManifest(projectRoot);
+  const entries = Object.entries(manifest.packages);
+  if (entries.length === 0) {
+    return check("symlinks-valid", "pass", "No packages installed");
+  }
+  const broken = [];
+  for (const [name, pkg2] of entries) {
+    for (const agentId of pkg2.agents) {
+      const placementPath = getSkillPlacementPath(agentId, name, "project");
+      if (!placementPath) continue;
+      const agentSkillPath = join11(projectRoot, placementPath);
+      if (!existsSync9(agentSkillPath)) {
+        broken.push(`${name}/${agentId}`);
+        continue;
+      }
+      try {
+        const stats = lstatSync2(agentSkillPath);
+        if (stats.isSymbolicLink()) {
+          const target = readlinkSync2(agentSkillPath);
+          const resolvedTarget = join11(dirname4(agentSkillPath), target);
+          if (!existsSync9(resolvedTarget)) {
+            broken.push(`${name}/${agentId} (broken symlink)`);
+          }
         }
-      );
-      if (options.json) {
-        spinner.stop();
-        console.log(JSON.stringify(result, null, 2));
-      } else {
-        spinner.succeed(
-          `Draft ${chalk6.green(result.name)} created on branch ${chalk6.cyan(result.branchName)}`
-        );
+      } catch {
+        broken.push(`${name}/${agentId} (unreadable)`);
       }
-    } catch (error) {
-      spinner.fail(
-        `Failed to create draft: ${error instanceof Error ? error.message : String(error)}`
-      );
-      process.exit(1);
-    }
-  });
-  draft.command("list").description("List open drafts for the current skill").option("--json", "Output as JSON").action(async (options) => {
-    const identity = resolveSkillIdentity();
-    if (!identity) {
-      process.stderr.write(
-        chalk6.red("Could not determine skill identity. Run this from a skill directory.\n")
-      );
-      process.exit(1);
+    }
+  }
+  if (broken.length > 0) {
+    return check("symlinks-valid", "fail", `Invalid symlinks: ${broken.join(", ")}`);
+  }
+  const totalLinks = entries.reduce((sum, [, pkg2]) => sum + pkg2.agents.length, 0);
+  return check("symlinks-valid", "pass", `All ${totalLinks} symlinks valid`);
+}
+async function checkAuthentication() {
+  const creds = await getCredentials();
+  const hasCredentials = !!(creds?.token ?? creds?.apiKey);
+  if (!hasCredentials) {
+    return check("authentication", "warn", "No credentials configured (run agentver login)");
+  }
+  const platformUrl = getPlatformUrl();
+  if (!platformUrl) {
+    return check("authentication", "warn", "Credentials present but no platform URL configured");
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), NETWORK_TIMEOUT_MS);
+    const response = await fetch(`${platformUrl}/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (response.ok) {
+      return check("authentication", "pass", "Authenticated and platform reachable");
+    }
+    return check(
+      "authentication",
+      "warn",
+      `Platform returned status ${String(response.status)} (offline mode available)`
+    );
+  } catch {
+    return check("authentication", "warn", "Platform unreachable (offline mode available)");
+  }
+}
+function checkGitAvailable() {
+  try {
+    execSync("git --version", { stdio: "pipe" });
+    return check("git-available", "pass", "Git is available");
+  } catch {
+    return check("git-available", "fail", "Git is not installed or not on PATH");
+  }
+}
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  if (major >= MIN_NODE_VERSION) {
+    return check(
+      "node-version",
+      "pass",
+      `Node ${process.versions.node} (>= ${String(MIN_NODE_VERSION)})`
+    );
+  }
+  return check(
+    "node-version",
+    "fail",
+    `Node ${process.versions.node} is below minimum ${String(MIN_NODE_VERSION)}`
+  );
+}
+function formatCheck(result) {
+  switch (result.status) {
+    case "pass":
+      return `  ${chalk8.green("\u2713")} ${result.message}`;
+    case "fail":
+      return `  ${chalk8.red("\u2717")} ${result.message}`;
+    case "warn":
+      return `  ${chalk8.yellow("\u26A0")} ${result.message}`;
+  }
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Run health checks to diagnose common issues").option("--json", "Output as JSON").action(async (options) => {
+    const jsonMode = isJSONMode() || options.json === true;
+    const projectRoot = process.cwd();
+    const checks = [];
+    checks.push(checkManifestIntegrity(projectRoot));
+    checks.push(checkLockfileIntegrity(projectRoot));
+    checks.push(checkManifestLockfileSync(projectRoot));
+    checks.push(checkSkillFilesExist(projectRoot));
+    checks.push(checkSymlinksValid(projectRoot));
+    checks.push(await checkAuthentication());
+    checks.push(checkGitAvailable());
+    checks.push(checkNodeVersion());
+    const passed = checks.filter((c) => c.status === "pass").length;
+    const failed = checks.filter((c) => c.status === "fail").length;
+    const warnings = checks.filter((c) => c.status === "warn").length;
+    if (jsonMode) {
+      const result = { checks, passed, failed, warnings };
+      outputSuccess(result);
+      process.exit(failed > 0 ? 1 : 0);
+      return;
+    }
+    console.log(chalk8.bold("\nHealth checks:\n"));
+    for (const result of checks) {
+      console.log(formatCheck(result));
+    }
+    console.log();
+    console.log(
+      chalk8.dim(
+        `${chalk8.green(String(passed))} passed, ${chalk8.red(String(failed))} failed, ${chalk8.yellow(String(warnings))} warnings`
+      )
+    );
+    console.log();
+    process.exit(failed > 0 ? 1 : 0);
+  });
+}
+
+// src/commands/draft.ts
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { basename as basename2, join as join12 } from "path";
+import chalk9 from "chalk";
+import ora2 from "ora";
+
+// src/utils/retry.ts
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_BASE_DELAY_MS = 1e3;
+var RequestTimeoutError = class extends Error {
+  constructor(label) {
+    super(`${label} request timed out. The service may be experiencing issues.`);
+    this.name = "RequestTimeoutError";
+  }
+};
+function isRetryable(error, response) {
+  if (error instanceof RequestTimeoutError) return false;
+  if (error instanceof DOMException && error.name === "AbortError") return false;
+  if (!response) return true;
+  return response.status >= 500;
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function isAuthExpired(status) {
+  return status === 401;
+}
+async function fetchWithRetry(options) {
+  let lastError;
+  let lastResponse;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+      const config = options.buildRequest();
+      const response = await fetch(config.url, {
+        method: config.method ?? "GET",
+        headers: config.headers,
+        body: config.body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return response.json();
+      }
+      if (isAuthExpired(response.status)) {
+        options.onAuthExpired();
+      }
+      lastResponse = response;
+      lastError = new Error(
+        `${options.label} error (${response.status}): ${await response.text().catch(() => "Unknown error")}`
+      );
+      if (!isRetryable(void 0, response)) {
+        throw lastError;
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new RequestTimeoutError(options.label);
+      }
+      lastError = error;
+      lastResponse = void 0;
+      if (!isRetryable(error)) {
+        throw error;
+      }
+    }
+    if (attempt < MAX_RETRY_ATTEMPTS) {
+      const retryDelay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      process.stderr.write(
+        `${options.label} request failed (attempt ${attempt}/${MAX_RETRY_ATTEMPTS}), retrying in ${retryDelay / 1e3}s...
+`
+      );
+      await delay(retryDelay);
+    }
+  }
+  if (lastResponse && !lastResponse.ok) {
+    throw lastError;
+  }
+  throw lastError;
+}
+
+// src/registry/platform.ts
+var REQUEST_TIMEOUT_MS = 3e4;
+async function platformFetch(path, options = {}) {
+  const platformUrl = getPlatformUrl();
+  if (!platformUrl) {
+    throw new AgentverError(
+      "UNAUTHORISED",
+      "No platform URL configured. Run `agentver login <url>` to connect."
+    );
+  }
+  const credentials = await getCredentials();
+  if (!credentials?.token && !credentials?.apiKey) {
+    throw new AgentverError("UNAUTHORISED", "Not authenticated. Run `agentver login` to sign in.");
+  }
+  const url = `${platformUrl}/api/v1${path}`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (credentials.token) {
+    headers.Authorization = `Bearer ${credentials.token}`;
+  } else if (credentials.apiKey) {
+    headers["X-API-Key"] = credentials.apiKey;
+  }
+  return fetchWithRetry({
+    label: "Platform",
+    timeoutMs: options.timeout ?? REQUEST_TIMEOUT_MS,
+    buildRequest: () => ({
+      url,
+      method: options.method ?? "GET",
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    }),
+    onAuthExpired: () => {
+      throw new AgentverError(
+        "UNAUTHORISED",
+        "Authentication expired. Run `agentver login` to re-authenticate."
+      );
+    }
+  });
+}
+async function platformFetchSilent(path, options = {}) {
+  try {
+    return await platformFetch(path, options);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/draft.ts
+function resolveSkillIdentity() {
+  const cwd = process.cwd();
+  const skillMdPath = join12(cwd, "SKILL.md");
+  let skillName = null;
+  if (existsSync10(skillMdPath)) {
+    const content = readFileSync9(skillMdPath, "utf-8");
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    skillName = nameMatch?.[1]?.trim() ?? basename2(cwd);
+  }
+  if (!skillName) {
+    skillName = basename2(cwd);
+  }
+  const manifest = readManifest(cwd);
+  const entry = manifest.packages[skillName];
+  if (entry?.source.type === "git") {
+    const parts = entry.source.uri.split("/");
+    const org = parts.length >= 2 ? parts[parts.length - 2] : parts[0];
+    if (org) {
+      return { org, name: skillName };
+    }
+  }
+  const pathParts = cwd.split("/");
+  const skillsIdx = pathParts.lastIndexOf("skills");
+  if (skillsIdx >= 0 && pathParts.length > skillsIdx + 2) {
+    return { org: pathParts[skillsIdx + 1], name: skillName };
+  }
+  return null;
+}
+function registerDraftCommand(program2) {
+  const draft = program2.command("draft").description("Manage skill drafts (branches)");
+  draft.command("create <name>").description("Create a draft branch for the current skill").option("--json", "Output as JSON").action(async (name, options) => {
+    const identity = resolveSkillIdentity();
+    if (!identity) {
+      process.stderr.write(
+        chalk9.red("Could not determine skill identity. Run this from a skill directory.\n")
+      );
+      process.exit(1);
+    }
+    const spinner = ora2(`Creating draft "${name}"...`).start();
+    try {
+      const result = await platformFetch(
+        `/skills/@${identity.org}/${identity.name}/drafts`,
+        {
+          method: "POST",
+          body: { name }
+        }
+      );
+      if (options.json) {
+        spinner.stop();
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        spinner.succeed(
+          `Draft ${chalk9.green(result.name)} created on branch ${chalk9.cyan(result.branchName)}`
+        );
+      }
+    } catch (error) {
+      spinner.fail(
+        `Failed to create draft: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  });
+  draft.command("list").description("List open drafts for the current skill").option("--json", "Output as JSON").action(async (options) => {
+    const identity = resolveSkillIdentity();
+    if (!identity) {
+      process.stderr.write(
+        chalk9.red("Could not determine skill identity. Run this from a skill directory.\n")
+      );
+      process.exit(1);
     }
     const spinner = ora2("Fetching drafts...").start();
     try {
@@ -5584,16 +6272,16 @@ function registerDraftCommand(program2) {
         return;
       }
       if (drafts.length === 0) {
-        process.stdout.write(chalk6.dim("No open drafts.\n"));
+        process.stdout.write(chalk9.dim("No open drafts.\n"));
         return;
       }
-      process.stdout.write(chalk6.bold(`
+      process.stdout.write(chalk9.bold(`
 Drafts for @${identity.org}/${identity.name}:
 
 `));
       for (const d of drafts) {
         process.stdout.write(
-          `  ${chalk6.green(d.name)} ${chalk6.dim(`(${d.latestCommitId.slice(0, 7)})`)} ${chalk6.dim(d.latestMessage)}
+          `  ${chalk9.green(d.name)} ${chalk9.dim(`(${d.latestCommitId.slice(0, 7)})`)} ${chalk9.dim(d.latestMessage)}
 `
         );
       }
@@ -5609,7 +6297,7 @@ Drafts for @${identity.org}/${identity.name}:
     const identity = resolveSkillIdentity();
     if (!identity) {
       process.stderr.write(
-        chalk6.red("Could not determine skill identity. Run this from a skill directory.\n")
+        chalk9.red("Could not determine skill identity. Run this from a skill directory.\n")
       );
       process.exit(1);
     }
@@ -5617,7 +6305,7 @@ Drafts for @${identity.org}/${identity.name}:
     const lockfile = readLockfile(projectRoot);
     const lockEntry = lockfile.packages[identity.name];
     if (!lockEntry) {
-      process.stderr.write(chalk6.red(`Skill "${identity.name}" not found in lockfile.
+      process.stderr.write(chalk9.red(`Skill "${identity.name}" not found in lockfile.
 `));
       process.exit(1);
     }
@@ -5639,7 +6327,7 @@ Drafts for @${identity.org}/${identity.name}:
       );
     } else {
       process.stdout.write(
-        `Switched to draft ${chalk6.green(name)} ${chalk6.dim(`(ref: draft/${identity.name}/${name})`)}
+        `Switched to draft ${chalk9.green(name)} ${chalk9.dim(`(ref: draft/${identity.name}/${name})`)}
 `
       );
     }
@@ -5648,7 +6336,7 @@ Drafts for @${identity.org}/${identity.name}:
     const identity = resolveSkillIdentity();
     if (!identity) {
       process.stderr.write(
-        chalk6.red("Could not determine skill identity. Run this from a skill directory.\n")
+        chalk9.red("Could not determine skill identity. Run this from a skill directory.\n")
       );
       process.exit(1);
     }
@@ -5656,12 +6344,12 @@ Drafts for @${identity.org}/${identity.name}:
     const lockfile = readLockfile(projectRoot);
     const lockEntry = lockfile.packages[identity.name];
     if (!lockEntry || lockEntry.source.type !== "git") {
-      process.stderr.write(chalk6.red("Skill not found in lockfile.\n"));
+      process.stderr.write(chalk9.red("Skill not found in lockfile.\n"));
       process.exit(1);
     }
     const currentRef = lockEntry.source.ref;
     if (!currentRef.startsWith("draft/")) {
-      process.stderr.write(chalk6.red(`Not on a draft branch. Current ref: ${currentRef}
+      process.stderr.write(chalk9.red(`Not on a draft branch. Current ref: ${currentRef}
 `));
       process.exit(1);
     }
@@ -5694,7 +6382,7 @@ Drafts for @${identity.org}/${identity.name}:
         );
       } else {
         spinner.succeed(
-          `Draft merged to main ${result.commitSha ? chalk6.dim(`(${result.commitSha.slice(0, 7)})`) : ""}`
+          `Draft merged to main ${result.commitSha ? chalk9.dim(`(${result.commitSha.slice(0, 7)})`) : ""}`
         );
       }
     } catch (error) {
@@ -5708,7 +6396,7 @@ Drafts for @${identity.org}/${identity.name}:
     const identity = resolveSkillIdentity();
     if (!identity) {
       process.stderr.write(
-        chalk6.red("Could not determine skill identity. Run this from a skill directory.\n")
+        chalk9.red("Could not determine skill identity. Run this from a skill directory.\n")
       );
       process.exit(1);
     }
@@ -5716,12 +6404,12 @@ Drafts for @${identity.org}/${identity.name}:
     const lockfile = readLockfile(projectRoot);
     const lockEntry = lockfile.packages[identity.name];
     if (!lockEntry || lockEntry.source.type !== "git") {
-      process.stderr.write(chalk6.red("Skill not found in lockfile.\n"));
+      process.stderr.write(chalk9.red("Skill not found in lockfile.\n"));
       process.exit(1);
     }
     const currentRef = lockEntry.source.ref;
     if (!currentRef.startsWith("draft/")) {
-      process.stderr.write(chalk6.red(`Not on a draft branch. Current ref: ${currentRef}
+      process.stderr.write(chalk9.red(`Not on a draft branch. Current ref: ${currentRef}
 `));
       process.exit(1);
     }
@@ -5750,7 +6438,7 @@ Drafts for @${identity.org}/${identity.name}:
           )
         );
       } else {
-        spinner.succeed(`Draft discarded. Switched back to ${chalk6.cyan("main")}.`);
+        spinner.succeed(`Draft discarded. Switched back to ${chalk9.cyan("main")}.`);
       }
     } catch (error) {
       spinner.fail(
@@ -5761,10 +6449,124 @@ Drafts for @${identity.org}/${identity.name}:
   });
 }
 
+// src/commands/info.ts
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join13 } from "path";
+import chalk10 from "chalk";
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function registerInfoCommand(program2) {
+  program2.command("info <name>").description("Show detailed information about an installed package").option("--json", "Output as JSON").action(async (name, options) => {
+    const jsonMode = isJSONMode() || options.json === true;
+    const projectRoot = process.cwd();
+    const manifest = readManifest(projectRoot);
+    const pkg2 = manifest.packages[name];
+    if (!pkg2) {
+      if (jsonMode) {
+        outputError("NOT_FOUND", `Package "${name}" is not installed.`);
+        process.exit(1);
+      }
+      console.error(chalk10.red(`Package "${name}" is not installed.`));
+      process.exit(1);
+    }
+    const spinner = createSpinner("Reading package information...").start();
+    const lockfile = readLockfile(projectRoot);
+    const lockfileEntry = lockfile.packages[name];
+    const shortName = name.split("/").pop();
+    let fileCount = 0;
+    let totalSize = 0;
+    let locallyModified = false;
+    let skillTitle;
+    let skillDescription;
+    const readPath = resolveReadPath(projectRoot, shortName, pkg2.agents);
+    if (readPath) {
+      try {
+        const files = await readFilesFromDirectory(readPath);
+        fileCount = files.length;
+        totalSize = files.reduce((sum, f) => sum + f.size, 0);
+        if (lockfileEntry?.integrity && files.length > 0) {
+          const localIntegrity = computeSha256FromFiles(files);
+          locallyModified = localIntegrity !== lockfileEntry.integrity;
+        }
+        const skillMdPath = join13(readPath, "SKILL.md");
+        try {
+          const skillMdContent = readFileSync10(skillMdPath, "utf-8");
+          const { frontmatter } = parseSkillFrontmatter(skillMdContent);
+          skillTitle = frontmatter.name;
+          skillDescription = frontmatter.description;
+        } catch {
+        }
+      } catch {
+      }
+    }
+    const sourceInfo = pkg2.source.type === "git" ? {
+      type: "git",
+      uri: pkg2.source.uri,
+      ref: pkg2.source.ref,
+      commit: pkg2.source.commit
+    } : { type: "well-known", hostname: pkg2.source.hostname };
+    const result = {
+      name,
+      source: sourceInfo,
+      agents: pkg2.agents,
+      installedAt: pkg2.installedAt,
+      modified: locallyModified,
+      integrity: lockfileEntry?.integrity,
+      files: {
+        count: fileCount,
+        totalSize
+      },
+      skill: skillTitle && skillDescription ? { title: skillTitle, description: skillDescription } : void 0
+    };
+    if (jsonMode) {
+      spinner.stop();
+      outputSuccess(result);
+      return;
+    }
+    spinner.stop();
+    console.log();
+    console.log(chalk10.bold(name));
+    console.log();
+    if (pkg2.source.type === "git") {
+      console.log(`  ${chalk10.dim("Source:")}    ${pkg2.source.uri}`);
+      console.log(`  ${chalk10.dim("Ref:")}       ${chalk10.cyan(pkg2.source.ref)}`);
+      console.log(`  ${chalk10.dim("Commit:")}    ${chalk10.dim(pkg2.source.commit.slice(0, 7))}`);
+    } else {
+      console.log(
+        `  ${chalk10.dim("Source:")}    ${pkg2.source.hostname} ${chalk10.dim("[well-known]")}`
+      );
+    }
+    console.log(
+      `  ${chalk10.dim("Agents:")}    ${pkg2.agents.length > 0 ? pkg2.agents.join(", ") : chalk10.dim("none")}`
+    );
+    console.log(`  ${chalk10.dim("Installed:")} ${pkg2.installedAt}`);
+    console.log(
+      `  ${chalk10.dim("Modified:")}  ${locallyModified ? chalk10.yellow("yes") : chalk10.green("no")}`
+    );
+    if (lockfileEntry?.integrity) {
+      console.log(`  ${chalk10.dim("Integrity:")} ${lockfileEntry.integrity}`);
+    }
+    console.log(
+      `  ${chalk10.dim("Files:")}     ${fileCount} file${fileCount !== 1 ? "s" : ""} (${formatBytes2(totalSize)})`
+    );
+    if (skillTitle) {
+      console.log();
+      console.log(`  ${chalk10.dim("Skill:")}     ${skillTitle}`);
+      if (skillDescription) {
+        console.log(`  ${chalk10.dim("Description:")} ${skillDescription}`);
+      }
+    }
+    console.log();
+  });
+}
+
 // src/commands/init.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join11 } from "path";
-import chalk7 from "chalk";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
+import chalk11 from "chalk";
 import prompts from "prompts";
 var TOKEN_BUDGET = 5e3;
 function estimateTokens(content) {
@@ -5774,11 +6576,11 @@ function warnIfOverBudget(filePath, content) {
   const tokens = estimateTokens(content);
   if (tokens > TOKEN_BUDGET) {
     console.log(
-      chalk7.yellow(`
+      chalk11.yellow(`
   Warning: ${filePath} is ~${tokens} tokens (recommended < ${TOKEN_BUDGET}).`)
     );
     console.log(
-      chalk7.yellow("  Move detailed content to docs/ or examples/ for progressive disclosure.")
+      chalk11.yellow("  Move detailed content to docs/ or examples/ for progressive disclosure.")
     );
   }
 }
@@ -6007,7 +6809,7 @@ agentver install github.com/YOUR_ORG/YOUR_REPO@main
 }
 function createGitkeep(dirPath) {
   mkdirSync7(dirPath, { recursive: true });
-  writeFileSync6(join11(dirPath, ".gitkeep"), "", "utf-8");
+  writeFileSync6(join14(dirPath, ".gitkeep"), "", "utf-8");
 }
 function registerInitCommand(program2) {
   program2.command("init").description("Scaffold a new package").option("--type <type>", "Package type: skill, agent, plugin, script, prompt", "skill").option("--repo", "Scaffold in a Git-repo-friendly structure").option("--name <name>", "Package name (required in JSON mode)").option("--description <desc>", "Package description").action(
@@ -6060,13 +6862,13 @@ function registerInitCommand(program2) {
         description = response.description ?? "";
         author = response.author ?? "";
       }
-      const dir = join11(process.cwd(), packageName);
-      if (existsSync9(dir)) {
+      const dir = join14(process.cwd(), packageName);
+      if (existsSync11(dir)) {
         if (isJSONMode()) {
           outputError("ALREADY_EXISTS", `Directory "${packageName}" already exists.`);
           process.exit(1);
         }
-        console.error(chalk7.red(`Directory "${packageName}" already exists.`));
+        console.error(chalk11.red(`Directory "${packageName}" already exists.`));
         process.exit(1);
       }
       mkdirSync7(dir, { recursive: true });
@@ -6077,14 +6879,14 @@ function registerInitCommand(program2) {
         case "skill": {
           fileName = "SKILL.md";
           const content = applyReplacements(SKILL_TEMPLATE);
-          writeFileSync6(join11(dir, fileName), content, "utf-8");
+          writeFileSync6(join14(dir, fileName), content, "utf-8");
           createdFiles.push(fileName);
           if (!options.repo) {
-            mkdirSync7(join11(dir, "examples"), { recursive: true });
-            writeFileSync6(join11(dir, "examples", "README.md"), EXAMPLES_README, "utf-8");
+            mkdirSync7(join14(dir, "examples"), { recursive: true });
+            writeFileSync6(join14(dir, "examples", "README.md"), EXAMPLES_README, "utf-8");
             createdFiles.push("examples/README.md");
-            mkdirSync7(join11(dir, "docs"), { recursive: true });
-            writeFileSync6(join11(dir, "docs", "README.md"), DOCS_README, "utf-8");
+            mkdirSync7(join14(dir, "docs"), { recursive: true });
+            writeFileSync6(join14(dir, "docs", "README.md"), DOCS_README, "utf-8");
             createdFiles.push("docs/README.md");
           }
           if (!isJSONMode()) {
@@ -6095,29 +6897,29 @@ function registerInitCommand(program2) {
         case "agent": {
           fileName = "CLAUDE.md";
           const content = applyReplacements(AGENT_CONFIG_TEMPLATE);
-          writeFileSync6(join11(dir, fileName), content, "utf-8");
+          writeFileSync6(join14(dir, fileName), content, "utf-8");
           createdFiles.push(fileName);
           if (!options.repo) {
-            mkdirSync7(join11(dir, "rules"), { recursive: true });
+            mkdirSync7(join14(dir, "rules"), { recursive: true });
           }
           break;
         }
         case "plugin": {
           fileName = "plugin.json";
-          writeFileSync6(join11(dir, fileName), applyReplacements(PLUGIN_TEMPLATE), "utf-8");
+          writeFileSync6(join14(dir, fileName), applyReplacements(PLUGIN_TEMPLATE), "utf-8");
           createdFiles.push(fileName);
           if (!options.repo) {
-            mkdirSync7(join11(dir, "scripts"), { recursive: true });
+            mkdirSync7(join14(dir, "scripts"), { recursive: true });
           }
           break;
         }
         case "script": {
           fileName = "script.json";
-          writeFileSync6(join11(dir, fileName), applyReplacements(SCRIPT_TEMPLATE), "utf-8");
+          writeFileSync6(join14(dir, fileName), applyReplacements(SCRIPT_TEMPLATE), "utf-8");
           createdFiles.push(fileName);
-          mkdirSync7(join11(dir, "src"), { recursive: true });
+          mkdirSync7(join14(dir, "src"), { recursive: true });
           writeFileSync6(
-            join11(dir, "src", "index.ts"),
+            join14(dir, "src", "index.ts"),
             applyReplacements(SCRIPT_ENTRY_TEMPLATE),
             "utf-8"
           );
@@ -6127,10 +6929,10 @@ function registerInitCommand(program2) {
         case "prompt": {
           fileName = "PROMPT.md";
           const content = applyReplacements(PROMPT_TEMPLATE);
-          writeFileSync6(join11(dir, fileName), content, "utf-8");
+          writeFileSync6(join14(dir, fileName), content, "utf-8");
           createdFiles.push(fileName);
           if (!options.repo) {
-            mkdirSync7(join11(dir, "variants"), { recursive: true });
+            mkdirSync7(join14(dir, "variants"), { recursive: true });
           }
           if (!isJSONMode()) {
             warnIfOverBudget(fileName, content);
@@ -6142,28 +6944,28 @@ function registerInitCommand(program2) {
             outputError("VALIDATION_ERROR", `Unknown package type: "${options.type}"`);
             process.exit(1);
           }
-          console.error(chalk7.red(`Unknown package type: "${options.type}"`));
+          console.error(chalk11.red(`Unknown package type: "${options.type}"`));
           process.exit(1);
         }
       }
       if (options.repo) {
-        const skillsDir = join11(dir, "skills", "example-skill");
+        const skillsDir = join14(dir, "skills", "example-skill");
         mkdirSync7(skillsDir, { recursive: true });
-        writeFileSync6(join11(skillsDir, "SKILL.md"), EXAMPLE_SKILL_TEMPLATE, "utf-8");
+        writeFileSync6(join14(skillsDir, "SKILL.md"), EXAMPLE_SKILL_TEMPLATE, "utf-8");
         createdFiles.push("skills/example-skill/SKILL.md");
-        mkdirSync7(join11(skillsDir, "examples"), { recursive: true });
-        writeFileSync6(join11(skillsDir, "examples", "README.md"), EXAMPLES_README, "utf-8");
+        mkdirSync7(join14(skillsDir, "examples"), { recursive: true });
+        writeFileSync6(join14(skillsDir, "examples", "README.md"), EXAMPLES_README, "utf-8");
         createdFiles.push("skills/example-skill/examples/README.md");
-        mkdirSync7(join11(skillsDir, "docs"), { recursive: true });
-        writeFileSync6(join11(skillsDir, "docs", "README.md"), DOCS_README, "utf-8");
+        mkdirSync7(join14(skillsDir, "docs"), { recursive: true });
+        writeFileSync6(join14(skillsDir, "docs", "README.md"), DOCS_README, "utf-8");
         createdFiles.push("skills/example-skill/docs/README.md");
-        createGitkeep(join11(dir, "configs"));
+        createGitkeep(join14(dir, "configs"));
         createdFiles.push("configs/.gitkeep");
-        createGitkeep(join11(dir, "prompts"));
+        createGitkeep(join14(dir, "prompts"));
         createdFiles.push("prompts/.gitkeep");
-        writeFileSync6(join11(dir, "README.md"), buildReadme(packageName, description), "utf-8");
+        writeFileSync6(join14(dir, "README.md"), buildReadme(packageName, description), "utf-8");
         createdFiles.push("README.md");
-        writeFileSync6(join11(dir, ".agentverignore"), AGENTVERIGNORE_CONTENT, "utf-8");
+        writeFileSync6(join14(dir, ".agentverignore"), AGENTVERIGNORE_CONTENT, "utf-8");
         createdFiles.push(".agentverignore");
       }
       if (isJSONMode()) {
@@ -6175,25 +6977,25 @@ function registerInitCommand(program2) {
         });
         return;
       }
-      console.log(chalk7.green(`
+      console.log(chalk11.green(`
 Created ${fileName} in ./${packageName}/`));
       if (options.repo) {
-        console.log(chalk7.dim("Repo structure created with skills/, configs/, prompts/"));
+        console.log(chalk11.dim("Repo structure created with skills/, configs/, prompts/"));
         console.log(
-          chalk7.dim(`Install with: agentver install github.com/YOUR_ORG/YOUR_REPO@main`)
+          chalk11.dim(`Install with: agentver install github.com/YOUR_ORG/YOUR_REPO@main`)
         );
       } else {
-        console.log(chalk7.dim(`Edit the file, then run: agentver publish ./${packageName}`));
+        console.log(chalk11.dim(`Edit the file, then run: agentver publish ./${packageName}`));
       }
     }
   );
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname4, join as join12, relative as relative2, resolve } from "path";
-import chalk8 from "chalk";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname5, join as join15, relative as relative2, resolve } from "path";
+import chalk12 from "chalk";
 import prompts2 from "prompts";
 
 // src/registry/reporter.ts
@@ -6502,19 +7304,19 @@ async function installFromWellKnown(source, options) {
         process.exit(1);
       }
       spinner.stop();
-      process.stdout.write(chalk8.bold(`
+      process.stdout.write(chalk12.bold(`
 Multiple skills available at ${hostname3}:
 
 `));
       for (const skill of index.skills) {
         process.stdout.write(
-          `  ${chalk8.green(skill.name)} ${chalk8.dim(`\u2014 ${skill.description}`)}
+          `  ${chalk12.green(skill.name)} ${chalk12.dim(`\u2014 ${skill.description}`)}
 `
         );
       }
       process.stdout.write(
         `
-${chalk8.dim("Specify a skill:")} ${chalk8.white(`agentver install ${hostname3}/<skill-name>`)}
+${chalk12.dim("Specify a skill:")} ${chalk12.white(`agentver install ${hostname3}/<skill-name>`)}
 `
       );
       process.exit(1);
@@ -6631,7 +7433,7 @@ ${chalk8.dim("Specify a skill:")} ${chalk8.white(`agentver install ${hostname3}/
       });
     } else {
       spinner.succeed(
-        `Installed ${chalk8.green(selectedEntry.name)} from ${chalk8.dim(hostname3)} ${chalk8.dim("(well-known)")} to ${target}`
+        `Installed ${chalk12.green(selectedEntry.name)} from ${chalk12.dim(hostname3)} ${chalk12.dim("(well-known)")} to ${target}`
       );
     }
     return { name: selectedEntry.name, ref: "well-known", commitSha: "", agents };
@@ -6695,14 +7497,14 @@ async function installPackage(source, options) {
             initial: false
           });
           if (!proceed) {
-            console.log(chalk8.dim("Installation cancelled."));
+            console.log(chalk12.dim("Installation cancelled."));
             process.exit(0);
           }
           spinner.start("Continuing installation...");
         }
       } else {
         if (!jsonMode) {
-          spinner.succeed(chalk8.green("Security scan passed"));
+          spinner.succeed(chalk12.green("Security scan passed"));
           spinner.start("Installing...");
         }
       }
@@ -6810,7 +7612,7 @@ async function installPackage(source, options) {
       );
     } else {
       spinner.succeed(
-        `Installed ${chalk8.green(shortName)} from ${chalk8.dim(formatSource(gitSource))} ${chalk8.cyan(`@${gitSource.ref}`)} ${chalk8.dim(`(${resolved.commitSha.slice(0, 7)})`)} to ${target}`
+        `Installed ${chalk12.green(shortName)} from ${chalk12.dim(formatSource(gitSource))} ${chalk12.cyan(`@${gitSource.ref}`)} ${chalk12.dim(`(${resolved.commitSha.slice(0, 7)})`)} to ${target}`
       );
     }
     return { name: shortName, ref: gitSource.ref, commitSha: resolved.commitSha, agents };
@@ -6857,7 +7659,7 @@ async function installAgentConfig(name, files, agents, options, spinner) {
   const projectRoot = process.cwd();
   if (options.dryRun) {
     spinner.info(
-      `${chalk8.yellow("[dry-run]")} Would install agent config ${chalk8.green(name)} to ${agents.join(", ")}`
+      `${chalk12.yellow("[dry-run]")} Would install agent config ${chalk12.green(name)} to ${agents.join(", ")}`
     );
     return;
   }
@@ -6873,14 +7675,14 @@ async function installAgentConfig(name, files, agents, options, spinner) {
   for (const agentId of agents) {
     const configPath = getConfigFilePath(agentId, name);
     if (!configPath) continue;
-    const fullConfigPath = options.global ? configPath.replace("~", homedir6()) : join12(projectRoot, configPath);
-    const configDir = join12(fullConfigPath, "..");
-    if (!existsSync10(configDir)) {
+    const fullConfigPath = options.global ? configPath.replace("~", homedir7()) : join15(projectRoot, configPath);
+    const configDir = join15(fullConfigPath, "..");
+    if (!existsSync12(configDir)) {
       mkdirSync8(configDir, { recursive: true });
     }
     let finalContent = configContent;
-    if (existsSync10(fullConfigPath)) {
-      const existingContent = readFileSync8(fullConfigPath, "utf-8");
+    if (existsSync12(fullConfigPath)) {
+      const existingContent = readFileSync11(fullConfigPath, "utf-8");
       if (isComposedConfig(existingContent)) {
         const existingSections = parseComposedSections(existingContent);
         const alreadyPresent = existingSections.some((s) => s.packageName === name);
@@ -6909,13 +7711,13 @@ async function installToCustomPath(name, files, options, spinner) {
   const targetPath = resolve(process.cwd(), options.path);
   if (options.dryRun) {
     spinner.info(
-      `${chalk8.yellow("[dry-run]")} Would install ${chalk8.green(name)} to ${chalk8.dim(targetPath)}`
+      `${chalk12.yellow("[dry-run]")} Would install ${chalk12.green(name)} to ${chalk12.dim(targetPath)}`
     );
-    console.log(chalk8.dim(`  Files: ${files.map((f) => f.path).join(", ")}`));
+    console.log(chalk12.dim(`  Files: ${files.map((f) => f.path).join(", ")}`));
     return;
   }
   spinner.text = `Installing to ${targetPath}...`;
-  if (!existsSync10(targetPath)) {
+  if (!existsSync12(targetPath)) {
     mkdirSync8(targetPath, { recursive: true });
   }
   for (const file of files) {
@@ -6924,8 +7726,8 @@ async function installToCustomPath(name, files, options, spinner) {
     if (relativePath.startsWith("..") || resolve(resolvedFilePath) !== resolvedFilePath) {
       continue;
     }
-    const dir = join12(resolvedFilePath, "..");
-    if (!existsSync10(dir)) {
+    const dir = join15(resolvedFilePath, "..");
+    if (!existsSync12(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
     writeFileSync7(resolvedFilePath, file.content, "utf-8");
@@ -6937,15 +7739,15 @@ async function installStandardPackage(name, files, agents, options, spinner) {
   if (options.dryRun) {
     const canonicalPath2 = getCanonicalSkillPath(projectRoot, name, scope);
     spinner.info(
-      `${chalk8.yellow("[dry-run]")} Would install ${chalk8.green(name)} to ${chalk8.dim(canonicalPath2)}`
+      `${chalk12.yellow("[dry-run]")} Would install ${chalk12.green(name)} to ${chalk12.dim(canonicalPath2)}`
     );
-    console.log(chalk8.dim(`  Files: ${files.map((f) => f.path).join(", ")}`));
-    console.log(chalk8.dim(`  Symlinks: ${agents.join(", ")}`));
+    console.log(chalk12.dim(`  Files: ${files.map((f) => f.path).join(", ")}`));
+    console.log(chalk12.dim(`  Symlinks: ${agents.join(", ")}`));
     return;
   }
   spinner.text = `Installing to canonical path and symlinking to ${agents.length} agent(s)...`;
   const canonicalPath = getCanonicalSkillPath(projectRoot, name, scope);
-  if (!existsSync10(canonicalPath)) {
+  if (!existsSync12(canonicalPath)) {
     mkdirSync8(canonicalPath, { recursive: true });
   }
   for (const file of files) {
@@ -6954,8 +7756,8 @@ async function installStandardPackage(name, files, agents, options, spinner) {
     if (relativePath.startsWith("..") || resolve(resolvedFilePath) !== resolvedFilePath) {
       continue;
     }
-    const dir = dirname4(resolvedFilePath);
-    if (!existsSync10(dir)) {
+    const dir = dirname5(resolvedFilePath);
+    if (!existsSync12(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
     writeFileSync7(resolvedFilePath, file.content, "utf-8");
@@ -6969,7 +7771,7 @@ function registerInstallCommand(program2) {
 }
 
 // src/commands/list.ts
-import chalk9 from "chalk";
+import chalk13 from "chalk";
 function registerListCommand(program2) {
   program2.command("list").description("Show installed packages").option("--json", "Output as JSON").action(() => {
     const jsonMode = isJSONMode();
@@ -6980,24 +7782,25 @@ function registerListCommand(program2) {
       return;
     }
     if (entries.length === 0) {
-      console.log(chalk9.dim("No packages installed."));
+      console.log(chalk13.dim("No packages installed."));
       return;
     }
-    console.log(chalk9.bold(`
+    console.log(chalk13.bold(`
 Installed packages (${entries.length}):
 `));
     for (const [name, pkg2] of entries) {
-      const agents = pkg2.agents.length > 0 ? chalk9.dim(` [${pkg2.agents.join(", ")}]`) : "";
+      const agents = pkg2.agents.length > 0 ? chalk13.dim(` [${pkg2.agents.join(", ")}]`) : "";
+      const pinned = pkg2.pinned === true ? chalk13.yellow(" [pinned]") : "";
       if (pkg2.source.type === "git") {
         const ref = pkg2.source.ref;
         const commit = pkg2.source.commit.slice(0, 7);
         console.log(
-          `  ${chalk9.green(name)}@${chalk9.cyan(ref)} ${chalk9.dim(`(${commit})`)}${agents}`
+          `  ${chalk13.green(name)}@${chalk13.cyan(ref)} ${chalk13.dim(`(${commit})`)}${pinned}${agents}`
         );
       } else {
         const hostname3 = pkg2.source.hostname;
         console.log(
-          `  ${chalk9.green(name)} ${chalk9.dim(`(${hostname3})`)} ${chalk9.dim("[well-known]")}${agents}`
+          `  ${chalk13.green(name)} ${chalk13.dim(`(${hostname3})`)} ${chalk13.dim("[well-known]")}${pinned}${agents}`
         );
       }
     }
@@ -7006,9 +7809,9 @@ Installed packages (${entries.length}):
 }
 
 // src/commands/log.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { basename as basename3, join as join13 } from "path";
-import chalk10 from "chalk";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
+import { basename as basename3, join as join16 } from "path";
+import chalk14 from "chalk";
 import ora3 from "ora";
 function resolveSkillIdentity2(nameArg) {
   const cwd = process.cwd();
@@ -7024,10 +7827,10 @@ function resolveSkillIdentity2(nameArg) {
     }
     return null;
   }
-  const skillMdPath = join13(cwd, "SKILL.md");
+  const skillMdPath = join16(cwd, "SKILL.md");
   let skillName = null;
-  if (existsSync11(skillMdPath)) {
-    const content = readFileSync9(skillMdPath, "utf-8");
+  if (existsSync13(skillMdPath)) {
+    const content = readFileSync12(skillMdPath, "utf-8");
     const nameMatch = content.match(/^name:\s*(.+)$/m);
     skillName = nameMatch?.[1]?.trim() ?? basename3(cwd);
   }
@@ -7067,7 +7870,7 @@ function registerLogCommand(program2) {
     if (!identity) {
       const target = nameArg ?? "current directory";
       process.stderr.write(
-        chalk10.red(
+        chalk14.red(
           `Could not determine skill identity for "${target}". Provide a skill name or run from a skill directory.
 `
         )
@@ -7076,7 +7879,7 @@ function registerLogCommand(program2) {
     }
     const limit = Number.parseInt(options.limit ?? "20", 10);
     if (Number.isNaN(limit) || limit < 1) {
-      process.stderr.write(chalk10.red("Limit must be a positive number.\n"));
+      process.stderr.write(chalk14.red("Limit must be a positive number.\n"));
       process.exit(1);
     }
     const spinner = ora3("Fetching history...").start();
@@ -7091,10 +7894,10 @@ function registerLogCommand(program2) {
         return;
       }
       if (commits.length === 0) {
-        process.stdout.write(chalk10.dim("No commits found.\n"));
+        process.stdout.write(chalk14.dim("No commits found.\n"));
         return;
       }
-      process.stdout.write(chalk10.bold(`
+      process.stdout.write(chalk14.bold(`
 History for @${identity.org}/${identity.name}:
 
 `));
@@ -7103,7 +7906,7 @@ History for @${identity.org}/${identity.name}:
         const date = formatDate(commit.author.date || commit.createdAt);
         const firstLine = commit.message.split("\n")[0] ?? commit.message;
         process.stdout.write(
-          `  ${chalk10.yellow(shortSha)} ${chalk10.dim("|")} ${chalk10.dim(date)} ${chalk10.dim("|")} ${firstLine}
+          `  ${chalk14.yellow(shortSha)} ${chalk14.dim("|")} ${chalk14.dim(date)} ${chalk14.dim("|")} ${firstLine}
 `
         );
       }
@@ -7121,31 +7924,14 @@ History for @${identity.org}/${identity.name}:
 import { createHash as createHash3, randomBytes } from "crypto";
 import { createServer } from "http";
 import { URL as URL2 } from "url";
-import chalk12 from "chalk";
+import chalk16 from "chalk";
 import open from "open";
 
 // src/registry/client.ts
 var DEFAULT_REGISTRY = "https://app.agentver.com/api/v1";
-var REQUEST_TIMEOUT_MS = 3e4;
-var MAX_RETRY_ATTEMPTS = 3;
-var RETRY_BASE_DELAY_MS = 1e3;
-var RegistryTimeoutError = class extends Error {
-  constructor() {
-    super("Registry request timed out. The service may be experiencing issues.");
-    this.name = "RegistryTimeoutError";
-  }
-};
-function getRegistryUrl() {
-  return process.env.AGENTVER_REGISTRY ?? DEFAULT_REGISTRY;
-}
-function isRetryable(error, response) {
-  if (error instanceof RegistryTimeoutError) return false;
-  if (error instanceof DOMException && error.name === "AbortError") return false;
-  if (!response) return true;
-  return response.status >= 500;
-}
-function delay(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+var REQUEST_TIMEOUT_MS2 = 3e4;
+function getRegistryUrl() {
+  return process.env.AGENTVER_REGISTRY ?? DEFAULT_REGISTRY;
 }
 async function registryFetch(path, options = {}) {
   const credentials = await getCredentials();
@@ -7159,57 +7945,23 @@ async function registryFetch(path, options = {}) {
   } else if (credentials?.apiKey) {
     headers["X-API-Key"] = credentials.apiKey;
   }
-  let lastError;
-  let lastResponse;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-    try {
-      const response = await fetch(url, {
-        method: options.method ?? "GET",
-        headers,
-        body: options.body ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        return response.json();
-      }
-      lastResponse = response;
-      lastError = new Error(
-        `Registry error (${response.status}): ${await response.text().catch(() => "Unknown error")}`
-      );
-      if (!isRetryable(void 0, response)) {
-        throw lastError;
-      }
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new RegistryTimeoutError();
-      }
-      lastError = error;
-      lastResponse = void 0;
-      if (!isRetryable(error)) {
-        throw error;
-      }
-    }
-    if (attempt < MAX_RETRY_ATTEMPTS) {
-      const retryDelay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
-      process.stderr.write(
-        `Registry request failed (attempt ${attempt}/${MAX_RETRY_ATTEMPTS}), retrying in ${retryDelay / 1e3}s...
-`
-      );
-      await delay(retryDelay);
+  return fetchWithRetry({
+    label: "Registry",
+    timeoutMs: REQUEST_TIMEOUT_MS2,
+    buildRequest: () => ({
+      url,
+      method: options.method ?? "GET",
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    }),
+    onAuthExpired: () => {
+      throw new Error("Authentication expired. Run `agentver login` to re-authenticate.");
     }
-  }
-  if (lastResponse && !lastResponse.ok) {
-    throw lastError;
-  }
-  throw lastError;
+  });
 }
 
 // src/utils/network.ts
-import chalk11 from "chalk";
+import chalk15 from "chalk";
 var ONLINE_CHECK_TIMEOUT_MS = 3e3;
 async function checkOnline() {
   const registryUrl = getRegistryUrl();
@@ -7229,10 +7981,10 @@ async function checkOnline() {
 }
 function showOfflineError() {
   console.error(
-    chalk11.red("Unable to reach the Agentver registry.") + " Please check your internet connection.\n"
+    chalk15.red("Unable to reach the Agentver registry.") + " Please check your internet connection.\n"
   );
   console.error(
-    chalk11.dim(
+    chalk15.dim(
       `If you're behind a proxy, set the HTTPS_PROXY environment variable.
 If the registry is down, try again later.
 
@@ -7305,6 +8057,7 @@ function startCallbackServer(expectedState) {
         port: address.port,
         waitForCallback: () => callbackPromise,
         close: () => {
+          server.closeAllConnections();
           server.close();
         }
       });
@@ -7369,9 +8122,9 @@ function registerLoginCommand(program2) {
         });
         return;
       }
-      console.log(chalk12.green("Saved API key. You are now authenticated."));
+      console.log(chalk16.green("Saved API key. You are now authenticated."));
       if (target) {
-        console.log(chalk12.dim(`Connected to ${target}`));
+        console.log(chalk16.dim(`Connected to ${target}`));
       }
       return;
     }
@@ -7411,28 +8164,31 @@ function registerLoginCommand(program2) {
       const redirectUri = `http://localhost:${port}/callback`;
       const authUrl = `${baseUrl}/auth/cli?code_challenge=${encodeURIComponent(codeChallenge)}&state=${encodeURIComponent(state)}&redirect_uri=${encodeURIComponent(redirectUri)}`;
       spinner.text = "Opening browser for authentication...";
-      console.log(chalk12.dim(`
+      console.log(chalk16.dim(`
   If the browser doesn't open, visit:
   ${authUrl}
 `));
       await open(authUrl);
       spinner.text = "Waiting for authentication in browser...";
+      let authTimeout;
       const { code } = await Promise.race([
         callbackServer.waitForCallback(),
         new Promise((_resolve, reject) => {
-          setTimeout(() => {
+          authTimeout = setTimeout(() => {
             reject(new Error("Authentication timed out after 120 seconds"));
           }, AUTH_TIMEOUT_MS);
         })
       ]);
+      clearTimeout(authTimeout);
       spinner.text = "Exchanging authorisation code for token...";
       const tokenResponse = await exchangeCodeForToken(apiUrl, code, codeVerifier, redirectUri);
       saveCredentials({ token: tokenResponse.access_token });
       spinner.succeed("Authenticated successfully.");
       const connectedUrl = url ?? getPlatformUrl();
       if (connectedUrl) {
-        console.log(chalk12.dim(`Connected to ${connectedUrl}`));
+        console.log(chalk16.dim(`Connected to ${connectedUrl}`));
       }
+      process.exit(0);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       spinner.fail(`Authentication failed: ${message}`);
@@ -7444,7 +8200,7 @@ function registerLoginCommand(program2) {
 }
 
 // src/commands/logout.ts
-import chalk13 from "chalk";
+import chalk17 from "chalk";
 function registerLogoutCommand(program2) {
   program2.command("logout").description("Log out from the Agentver registry").action(async () => {
     if (!await isAuthenticated()) {
@@ -7452,7 +8208,7 @@ function registerLogoutCommand(program2) {
         outputSuccess({ cleared: true });
         return;
       }
-      console.log(chalk13.dim("You are not currently logged in."));
+      console.log(chalk17.dim("You are not currently logged in."));
       return;
     }
     const platformUrl = getPlatformUrl();
@@ -7467,19 +8223,72 @@ function registerLogoutCommand(program2) {
       return;
     }
     if (platformUrl) {
-      console.log(`${chalk13.green("Logged out successfully.")} Disconnected from ${platformUrl}`);
+      console.log(`${chalk17.green("Logged out successfully.")} Disconnected from ${platformUrl}`);
     } else {
       console.log(
-        `${chalk13.green("Logged out successfully.")} Run \`agentver login\` to sign in again.`
+        `${chalk17.green("Logged out successfully.")} Run \`agentver login\` to sign in again.`
       );
     }
   });
 }
 
+// src/commands/pin.ts
+import chalk18 from "chalk";
+function registerPinCommand(program2) {
+  program2.command("pin <name>").description("Pin a package to skip it during updates").action((name) => {
+    const jsonMode = isJSONMode();
+    const projectRoot = process.cwd();
+    const manifest = readManifest(projectRoot);
+    const pkg2 = manifest.packages[name];
+    if (!pkg2) {
+      if (jsonMode) {
+        outputError("NOT_FOUND", `Package "${name}" is not installed.`);
+      } else {
+        console.error(chalk18.red(`Package "${name}" is not installed.`));
+      }
+      process.exit(1);
+    }
+    pkg2.pinned = true;
+    writeManifest(projectRoot, manifest);
+    if (jsonMode) {
+      outputSuccess({ name, pinned: true });
+      return;
+    }
+    console.log(
+      chalk18.green(`Pinned ${name}`) + chalk18.dim(" \u2014 this package will be skipped during updates")
+    );
+  });
+}
+function registerUnpinCommand(program2) {
+  program2.command("unpin <name>").description("Unpin a package so it is included in updates").action((name) => {
+    const jsonMode = isJSONMode();
+    const projectRoot = process.cwd();
+    const manifest = readManifest(projectRoot);
+    const pkg2 = manifest.packages[name];
+    if (!pkg2) {
+      if (jsonMode) {
+        outputError("NOT_FOUND", `Package "${name}" is not installed.`);
+      } else {
+        console.error(chalk18.red(`Package "${name}" is not installed.`));
+      }
+      process.exit(1);
+    }
+    delete pkg2.pinned;
+    writeManifest(projectRoot, manifest);
+    if (jsonMode) {
+      outputSuccess({ name, pinned: false });
+      return;
+    }
+    console.log(
+      chalk18.green(`Unpinned ${name}`) + chalk18.dim(" \u2014 this package will be included in updates")
+    );
+  });
+}
+
 // src/commands/publish.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { basename as basename4, join as join14, resolve as resolve2 } from "path";
-import chalk14 from "chalk";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { basename as basename4, join as join17, resolve as resolve2 } from "path";
+import chalk19 from "chalk";
 import ora4 from "ora";
 var SEMVER_REGEX = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 function parseFrontmatter2(content) {
@@ -7506,9 +8315,9 @@ function parseFrontmatter2(content) {
   };
 }
 function detectNamespace(skillDir) {
-  const skillMdPath = join14(skillDir, "SKILL.md");
-  if (!existsSync12(skillMdPath)) return null;
-  const content = readFileSync10(skillMdPath, "utf-8");
+  const skillMdPath = join17(skillDir, "SKILL.md");
+  if (!existsSync14(skillMdPath)) return null;
+  const content = readFileSync13(skillMdPath, "utf-8");
   const fm = parseFrontmatter2(content);
   if (!fm) return null;
   const parts = skillDir.split("/");
@@ -7522,16 +8331,16 @@ function detectNamespace(skillDir) {
 function registerPublishCommand(program2) {
   program2.command("publish [path]").description("Publish a skill to the registry").option("--version <semver>", "Version to publish (uses frontmatter version if omitted)").option("--dry-run", "Validate without publishing").option("--skip-audit", "Skip security scan").option("--json", "Output as JSON").action(async (pathArg, options) => {
     const skillDir = pathArg ? resolve2(process.cwd(), pathArg) : process.cwd();
-    if (!existsSync12(join14(skillDir, "SKILL.md"))) {
+    if (!existsSync14(join17(skillDir, "SKILL.md"))) {
       process.stderr.write(
-        chalk14.red(`No SKILL.md found in ${skillDir}. Cannot publish without a skill manifest.
+        chalk19.red(`No SKILL.md found in ${skillDir}. Cannot publish without a skill manifest.
 `)
       );
       process.exit(1);
     }
     const spinner = ora4("Reading skill metadata...").start();
     try {
-      const skillMdContent = readFileSync10(join14(skillDir, "SKILL.md"), "utf-8");
+      const skillMdContent = readFileSync13(join17(skillDir, "SKILL.md"), "utf-8");
       const frontmatter = parseFrontmatter2(skillMdContent);
       if (!frontmatter) {
         spinner.fail(
@@ -7573,7 +8382,7 @@ function registerPublishCommand(program2) {
           spinner.fail("Security audit failed. Fix the issues before publishing.");
           for (const finding of scanResult.findings) {
             process.stderr.write(
-              `  ${chalk14.red("BLOCK")} ${finding.file}:${String(finding.line ?? "?")} \u2014 ${finding.message}
+              `  ${chalk19.red("BLOCK")} ${finding.file}:${String(finding.line ?? "?")} \u2014 ${finding.message}
 `
             );
           }
@@ -7583,7 +8392,7 @@ function registerPublishCommand(program2) {
           spinner.warn("Security audit warnings found:");
           for (const finding of scanResult.findings) {
             process.stderr.write(
-              `  ${chalk14.yellow("WARN")} ${finding.file}:${String(finding.line ?? "?")} \u2014 ${finding.message}
+              `  ${chalk19.yellow("WARN")} ${finding.file}:${String(finding.line ?? "?")} \u2014 ${finding.message}
 `
             );
           }
@@ -7612,13 +8421,13 @@ function registerPublishCommand(program2) {
           );
         } else {
           process.stdout.write(
-            chalk14.yellow("[dry-run]") + ` Would publish ${chalk14.green(frontmatter.name)}@${chalk14.cyan(version)}
+            chalk19.yellow("[dry-run]") + ` Would publish ${chalk19.green(frontmatter.name)}@${chalk19.cyan(version)}
 `
           );
-          process.stdout.write(chalk14.dim(`  Namespace: @${namespace.org}/${namespace.name}
+          process.stdout.write(chalk19.dim(`  Namespace: @${namespace.org}/${namespace.name}
 `));
           process.stdout.write(
-            chalk14.dim(
+            chalk19.dim(
               `  Files (${filesToPublish.length}): ${filesToPublish.map((f) => f.path).join(", ")}
 `
             )
@@ -7651,7 +8460,7 @@ function registerPublishCommand(program2) {
         );
       } else {
         spinner.succeed(
-          `Published ${chalk14.green(frontmatter.name)}@${chalk14.cyan(result.version)} ${chalk14.dim(`(${result.commitSha.slice(0, 7)})`)}`
+          `Published ${chalk19.green(frontmatter.name)}@${chalk19.cyan(result.version)} ${chalk19.dim(`(${result.commitSha.slice(0, 7)})`)}`
         );
       }
     } catch (error) {
@@ -7662,11 +8471,11 @@ function registerPublishCommand(program2) {
 }
 
 // src/commands/remove.ts
-import { existsSync as existsSync13, lstatSync as lstatSync2, rmSync as rmSync2 } from "fs";
-import { join as join15 } from "path";
-import chalk15 from "chalk";
+import { existsSync as existsSync15, lstatSync as lstatSync3, rmSync as rmSync2 } from "fs";
+import { join as join18 } from "path";
+import chalk20 from "chalk";
 function registerRemoveCommand(program2) {
-  program2.command("remove <name>").description("Remove an installed package").option("--dry-run", "Show what would be removed without making changes").action(async (name, options) => {
+  program2.command("remove <name>").alias("uninstall").description("Remove an installed package").option("--dry-run", "Show what would be removed without making changes").action(async (name, options) => {
     const jsonMode = isJSONMode();
     const projectRoot = process.cwd();
     const manifest = readManifest(projectRoot);
@@ -7676,7 +8485,7 @@ function registerRemoveCommand(program2) {
         outputError("NOT_FOUND", `Package "${name}" is not installed.`);
         process.exit(1);
       }
-      console.error(chalk15.red(`Package "${name}" is not installed.`));
+      console.error(chalk20.red(`Package "${name}" is not installed.`));
       process.exit(1);
     }
     const shortName = name.split("/").pop();
@@ -7688,15 +8497,15 @@ function registerRemoveCommand(program2) {
       for (const agentId of pkg2.agents) {
         const placementPath = getSkillPlacementPath(agentId, shortName, "project");
         if (placementPath) {
-          removedPaths.push(join15(projectRoot, placementPath));
+          removedPaths.push(join18(projectRoot, placementPath));
         }
       }
     } else {
       for (const agentId of pkg2.agents) {
         const placementPath = getSkillPlacementPath(agentId, shortName, "project");
         if (!placementPath) continue;
-        const fullPath = join15(projectRoot, placementPath);
-        if (existsSync13(fullPath)) {
+        const fullPath = join18(projectRoot, placementPath);
+        if (existsSync15(fullPath)) {
           removedPaths.push(fullPath);
         }
       }
@@ -7710,28 +8519,28 @@ function registerRemoveCommand(program2) {
         });
         return;
       }
-      console.log(`${chalk15.yellow("[dry-run]")} Would remove ${chalk15.green(name)}`);
+      console.log(`${chalk20.yellow("[dry-run]")} Would remove ${chalk20.green(name)}`);
       if (hasCanonical) {
         const canonicalPath = getCanonicalSkillPath(projectRoot, shortName, "project");
-        console.log(chalk15.dim("  Canonical path to remove:"));
-        console.log(chalk15.dim(`    ${canonicalPath}`));
-        console.log(chalk15.dim("  Agent symlinks to remove:"));
+        console.log(chalk20.dim("  Canonical path to remove:"));
+        console.log(chalk20.dim(`    ${canonicalPath}`));
+        console.log(chalk20.dim("  Agent symlinks to remove:"));
         for (const agentId of pkg2.agents) {
           const placementPath = getSkillPlacementPath(agentId, shortName, "project");
           if (placementPath) {
-            console.log(chalk15.dim(`    ${join15(projectRoot, placementPath)}`));
+            console.log(chalk20.dim(`    ${join18(projectRoot, placementPath)}`));
           }
         }
       } else {
-        const pathsToRemove = removedPaths.filter((p) => existsSync13(p));
+        const pathsToRemove = removedPaths.filter((p) => existsSync15(p));
         if (pathsToRemove.length > 0) {
-          console.log(chalk15.dim("  Paths to remove:"));
+          console.log(chalk20.dim("  Paths to remove:"));
           for (const p of pathsToRemove) {
-            console.log(chalk15.dim(`    ${p}`));
+            console.log(chalk20.dim(`    ${p}`));
           }
         }
       }
-      console.log(chalk15.dim("  Would update manifest and lockfile"));
+      console.log(chalk20.dim("  Would update manifest and lockfile"));
       return;
     }
     const spinner = createSpinner(`Removing ${name}...`).start();
@@ -7742,8 +8551,8 @@ function registerRemoveCommand(program2) {
       for (const agentId of pkg2.agents) {
         const placementPath = getSkillPlacementPath(agentId, shortName, "project");
         if (!placementPath) continue;
-        const fullPath = join15(projectRoot, placementPath);
-        if (existsSync13(fullPath) || isSymlinkPath(fullPath)) {
+        const fullPath = join18(projectRoot, placementPath);
+        if (existsSync15(fullPath) || isSymlinkPath(fullPath)) {
           rmSync2(fullPath, { recursive: true, force: true });
         }
       }
@@ -7761,35 +8570,35 @@ function registerRemoveCommand(program2) {
         paths: removedPaths
       });
     } else {
-      spinner.succeed(`Removed ${chalk15.green(name)}`);
+      spinner.succeed(`Removed ${chalk20.green(name)}`);
     }
   });
 }
 function isSymlinkPath(filePath) {
   try {
-    return lstatSync2(filePath).isSymbolicLink();
+    return lstatSync3(filePath).isSymbolicLink();
   } catch {
     return false;
   }
 }
 
 // src/commands/save.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { basename as basename5, join as join16, resolve as resolve3 } from "path";
-import chalk16 from "chalk";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { basename as basename5, join as join19, resolve as resolve3 } from "path";
+import chalk21 from "chalk";
 import ora5 from "ora";
 function detectSkillName(skillDir) {
-  const skillMdPath = join16(skillDir, "SKILL.md");
-  if (!existsSync14(skillMdPath)) {
+  const skillMdPath = join19(skillDir, "SKILL.md");
+  if (!existsSync16(skillMdPath)) {
     return null;
   }
-  const content = readFileSync11(skillMdPath, "utf-8");
+  const content = readFileSync14(skillMdPath, "utf-8");
   const nameMatch = content.match(/^name:\s*(.+)$/m);
   return nameMatch?.[1]?.trim() ?? basename5(skillDir);
 }
 function resolveSkillContext(options) {
   const skillDir = options.path ? resolve3(process.cwd(), options.path) : process.cwd();
-  if (!existsSync14(skillDir)) {
+  if (!existsSync16(skillDir)) {
     return null;
   }
   const skillName = detectSkillName(skillDir);
@@ -7815,7 +8624,7 @@ function registerSaveCommand(program2) {
     if (!context) {
       const target = options.path ?? process.cwd();
       process.stderr.write(
-        chalk16.red(`No SKILL.md found in ${target}. Run this from a skill directory.
+        chalk21.red(`No SKILL.md found in ${target}. Run this from a skill directory.
 `)
       );
       process.exit(1);
@@ -7825,7 +8634,7 @@ function registerSaveCommand(program2) {
     const namespace = findNamespace(projectRoot, skillName);
     if (!namespace) {
       process.stderr.write(
-        chalk16.red(
+        chalk21.red(
           `Skill "${skillName}" not found in manifest. Install it first or check the directory.
 `
         )
@@ -7861,13 +8670,13 @@ function registerSaveCommand(program2) {
           );
         } else {
           process.stdout.write(
-            chalk16.yellow("[dry-run]") + ` Would save ${chalk16.green(skillName)} to @${namespace.org}/${namespace.name}
+            chalk21.yellow("[dry-run]") + ` Would save ${chalk21.green(skillName)} to @${namespace.org}/${namespace.name}
 `
           );
-          process.stdout.write(chalk16.dim(`  Message: ${commitMessage}
+          process.stdout.write(chalk21.dim(`  Message: ${commitMessage}
 `));
           process.stdout.write(
-            chalk16.dim(`  Files: ${filesToSave.map((f) => f.path).join(", ")}
+            chalk21.dim(`  Files: ${filesToSave.map((f) => f.path).join(", ")}
 `)
           );
         }
@@ -7904,7 +8713,7 @@ function registerSaveCommand(program2) {
         );
       } else {
         spinner.succeed(
-          `Saved ${chalk16.green(skillName)} ${chalk16.dim(`(${result.commitSha.slice(0, 7)})`)}`
+          `Saved ${chalk21.green(skillName)} ${chalk21.dim(`(${result.commitSha.slice(0, 7)})`)}`
         );
       }
     } catch (error) {
@@ -7915,19 +8724,19 @@ function registerSaveCommand(program2) {
 }
 
 // src/commands/scan.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir7 } from "os";
-import chalk17 from "chalk";
+import { readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir8 } from "os";
+import chalk22 from "chalk";
 function registerScanCommand(program2) {
   program2.command("scan [path]").description("Scan directory for agent configs and skills").action(async (path) => {
     const jsonMode = isJSONMode();
     const targetPath = path ?? process.cwd();
     const projectAgents = detectInstalledAgents(targetPath);
-    const globalAgents = detectGlobalAgents(homedir7());
+    const globalAgents = detectGlobalAgents(homedir8());
     const seenIds = new Set(projectAgents.map((a) => a.id));
     const agents = [...projectAgents, ...globalAgents.filter((a) => !seenIds.has(a.id))];
     const projectFiles = scanForSkillFiles(targetPath);
-    const globalFiles = scanGlobalSkillFiles(homedir7());
+    const globalFiles = scanGlobalSkillFiles(homedir8());
     const seenPaths = new Set(projectFiles.map((f) => f.path));
     const files = [...projectFiles, ...globalFiles.filter((f) => !seenPaths.has(f.path))];
     if (jsonMode) {
@@ -7946,58 +8755,58 @@ function registerScanCommand(program2) {
       outputSuccess(result);
       return;
     }
-    console.log(chalk17.bold("\nDetected agents:\n"));
+    console.log(chalk22.bold("\nDetected agents:\n"));
     if (agents.length === 0) {
-      console.log(chalk17.dim("  No agents detected."));
+      console.log(chalk22.dim("  No agents detected."));
     } else {
       for (const agent of agents) {
-        console.log(`  ${chalk17.green(agent.name)} ${chalk17.dim(agent.configPath)}`);
+        console.log(`  ${chalk22.green(agent.name)} ${chalk22.dim(agent.configPath)}`);
       }
     }
-    console.log(chalk17.bold("\nDiscovered files:\n"));
+    console.log(chalk22.bold("\nDiscovered files:\n"));
     if (files.length === 0) {
-      console.log(chalk17.dim("  No skill or config files found."));
+      console.log(chalk22.dim("  No skill or config files found."));
     } else {
       for (const file of files) {
-        const typeLabel = chalk17.dim(`[${file.detectedType}]`);
-        const agentLabel = chalk17.cyan(`(${file.agentId})`);
-        console.log(`  ${typeLabel} ${agentLabel} ${file.name} ${chalk17.dim(file.path)}`);
+        const typeLabel = chalk22.dim(`[${file.detectedType}]`);
+        const agentLabel = chalk22.cyan(`(${file.agentId})`);
+        console.log(`  ${typeLabel} ${agentLabel} ${file.name} ${chalk22.dim(file.path)}`);
       }
     }
     const skillFiles = files.filter((f) => f.detectedType === "SKILL");
     if (skillFiles.length > 0) {
-      console.log(chalk17.bold("\nSkill spec validation:\n"));
+      console.log(chalk22.bold("\nSkill spec validation:\n"));
       for (const file of skillFiles) {
         let content;
         try {
-          content = readFileSync12(file.path, "utf-8");
+          content = readFileSync15(file.path, "utf-8");
         } catch {
-          console.log(`  ${chalk17.red("\u2717")} ${file.name} ${chalk17.dim("Could not read file")}`);
+          console.log(`  ${chalk22.red("\u2717")} ${file.name} ${chalk22.dim("Could not read file")}`);
           continue;
         }
         const result = validateSkillMd(content);
         if (result.valid && result.specCompliant) {
           console.log(
-            `  ${chalk17.green("\u2713")} ${file.name} ${chalk17.green("Agent Skills spec compliant")}`
+            `  ${chalk22.green("\u2713")} ${file.name} ${chalk22.green("Agent Skills spec compliant")}`
           );
         } else if (result.valid && !result.specCompliant) {
           console.log(
-            `  ${chalk17.yellow("\u2713")} ${file.name} ${chalk17.yellow("Valid (Agentver extended)")}`
+            `  ${chalk22.yellow("\u2713")} ${file.name} ${chalk22.yellow("Valid (Agentver extended)")}`
           );
         } else {
-          console.log(`  ${chalk17.red("\u2717")} ${file.name} ${chalk17.red("Invalid")}`);
+          console.log(`  ${chalk22.red("\u2717")} ${file.name} ${chalk22.red("Invalid")}`);
           for (const error of result.errors) {
-            console.log(`    ${chalk17.red(`\u2514 ${error}`)}`);
+            console.log(`    ${chalk22.red(`\u2514 ${error}`)}`);
           }
         }
         if (result.warnings.length > 0) {
           for (const warning of result.warnings) {
-            console.log(`    ${chalk17.yellow(`\u26A0 ${warning}`)}`);
+            console.log(`    ${chalk22.yellow(`\u26A0 ${warning}`)}`);
           }
         }
         if (result.agentverExtensions.length > 0) {
           console.log(
-            `    ${chalk17.dim(`Agentver extensions: ${result.agentverExtensions.join(", ")}`)}`
+            `    ${chalk22.dim(`Agentver extensions: ${result.agentverExtensions.join(", ")}`)}`
           );
         }
       }
@@ -8005,7 +8814,7 @@ function registerScanCommand(program2) {
     const manifest = readManifest(targetPath);
     const manifestEntries = Object.entries(manifest.packages);
     if (manifestEntries.length > 0) {
-      console.log(chalk17.bold(`
+      console.log(chalk22.bold(`
 Installed skills (${manifestEntries.length}):
 `));
       for (const [name, pkg2] of manifestEntries) {
@@ -8016,12 +8825,12 @@ Installed skills (${manifestEntries.length}):
           const ref = `@${source.ref}`;
           const commit = `(${source.commit.slice(0, 7)})`;
           console.log(
-            `  ${chalk17.green(name.padEnd(18))} ${chalk17.dim(sourcePath.padEnd(40))} ${chalk17.cyan(ref.padEnd(10))} ${chalk17.dim(commit)}  ${chalk17.dim(agentList)}`
+            `  ${chalk22.green(name.padEnd(18))} ${chalk22.dim(sourcePath.padEnd(40))} ${chalk22.cyan(ref.padEnd(10))} ${chalk22.dim(commit)}  ${chalk22.dim(agentList)}`
           );
         } else {
           const sourceLabel = `${source.hostname} (well-known)`;
           console.log(
-            `  ${chalk17.green(name.padEnd(18))} ${chalk17.dim(sourceLabel.padEnd(40))} ${chalk17.dim("[well-known]").padEnd(10)}  ${chalk17.dim(agentList)}`
+            `  ${chalk22.green(name.padEnd(18))} ${chalk22.dim(sourceLabel.padEnd(40))} ${chalk22.dim("[well-known]").padEnd(10)}  ${chalk22.dim(agentList)}`
           );
         }
       }
@@ -8031,7 +8840,7 @@ Installed skills (${manifestEntries.length}):
 }
 
 // src/commands/search.ts
-import chalk18 from "chalk";
+import chalk23 from "chalk";
 import ora6 from "ora";
 
 // src/registry/skills-sh.ts
@@ -8109,60 +8918,60 @@ function formatInstallCount(count) {
 }
 function renderPlatformResults(results, total) {
   if (results.length === 0) return;
-  process.stdout.write(chalk18.bold(`
+  process.stdout.write(chalk23.bold(`
 Platform results (${total}):
 
 `));
   for (const result of results) {
-    const desc = result.description ? chalk18.dim(` \u2014 ${result.description}`) : "";
-    const stars = result.starCount > 0 ? chalk18.yellow(` \u2605 ${result.starCount}`) : "";
-    const installs = result.installCount > 0 ? chalk18.cyan(` \u2193 ${formatInstallCount(result.installCount)}`) : "";
-    const cats = result.categories.length > 0 ? chalk18.dim(` [${result.categories.map((c) => c.name).join(", ")}]`) : "";
-    process.stdout.write(`  ${chalk18.green(result.slug)}${stars}${installs}${cats}${desc}
+    const desc = result.description ? chalk23.dim(` \u2014 ${result.description}`) : "";
+    const stars = result.starCount > 0 ? chalk23.yellow(` \u2605 ${result.starCount}`) : "";
+    const installs = result.installCount > 0 ? chalk23.cyan(` \u2193 ${formatInstallCount(result.installCount)}`) : "";
+    const cats = result.categories.length > 0 ? chalk23.dim(` [${result.categories.map((c) => c.name).join(", ")}]`) : "";
+    process.stdout.write(`  ${chalk23.green(result.slug)}${stars}${installs}${cats}${desc}
 `);
   }
   process.stdout.write("\n");
 }
 function renderCommunityResults(results) {
   if (results.length === 0) return;
-  process.stdout.write(chalk18.bold(`
+  process.stdout.write(chalk23.bold(`
 Skills from skills.sh:
 
 `));
   for (const result of results) {
-    const nameCol = chalk18.green(result.name);
-    const sourceCol = chalk18.dim(`(${result.source})`);
-    const installCol = chalk18.cyan(`\u2193 ${formatInstallCount(result.installCount)}`);
+    const nameCol = chalk23.green(result.name);
+    const sourceCol = chalk23.dim(`(${result.source})`);
+    const installCol = chalk23.cyan(`\u2193 ${formatInstallCount(result.installCount)}`);
     process.stdout.write(`  ${nameCol} ${sourceCol}  ${installCol}
 `);
     if (result.description) {
-      process.stdout.write(`    ${chalk18.dim(result.description)}
+      process.stdout.write(`    ${chalk23.dim(result.description)}
 `);
     }
     process.stdout.write("\n");
   }
   process.stdout.write(
-    chalk18.dim("  Install with: ") + chalk18.white("agentver install github.com/{source}/{name}") + "\n\n"
+    chalk23.dim("  Install with: ") + chalk23.white("agentver install github.com/{source}/{name}") + "\n\n"
   );
 }
 function renderWellKnownResults(hostname3, skills) {
   if (skills.length === 0) return;
-  process.stdout.write(chalk18.bold(`
+  process.stdout.write(chalk23.bold(`
 Skills from ${hostname3}:
 
 `));
   for (const skill of skills) {
-    process.stdout.write(`  ${chalk18.green(skill.name)} ${chalk18.dim(`\u2014 ${skill.description}`)}
+    process.stdout.write(`  ${chalk23.green(skill.name)} ${chalk23.dim(`\u2014 ${skill.description}`)}
 `);
     process.stdout.write(
-      `    ${chalk18.dim("Install:")} ${chalk18.white(`agentver install ${hostname3}/${skill.name}`)}
+      `    ${chalk23.dim("Install:")} ${chalk23.white(`agentver install ${hostname3}/${skill.name}`)}
 `
     );
     process.stdout.write("\n");
   }
 }
 function renderNoResults(query) {
-  process.stdout.write(chalk18.dim(`No results for "${query}"
+  process.stdout.write(chalk23.dim(`No results for "${query}"
 `));
 }
 function registerSearchCommand(program2) {
@@ -8177,7 +8986,7 @@ function registerSearchCommand(program2) {
       if (requestedSource) {
         if (!["platform", "community", "well-known", "all"].includes(requestedSource)) {
           process.stderr.write(
-            chalk18.red(
+            chalk23.red(
               `Invalid source "${requestedSource}". Use: platform, community, well-known, or all
 `
             )
@@ -8187,7 +8996,7 @@ function registerSearchCommand(program2) {
         source = requestedSource;
         if (source === "platform" && !connected) {
           process.stderr.write(
-            chalk18.red("Not connected to a platform. Run `agentver login <url>` to connect.\n")
+            chalk23.red("Not connected to a platform. Run `agentver login <url>` to connect.\n")
           );
           process.exit(1);
         }
@@ -8255,7 +9064,7 @@ function registerSearchCommand(program2) {
         if (communityResults.length > 0) {
           const example = communityResults[0];
           process.stdout.write(
-            chalk18.dim("  Example: ") + chalk18.white(`agentver install ${toGitInstallSource(example)}`) + "\n"
+            chalk23.dim("  Example: ") + chalk23.white(`agentver install ${toGitInstallSource(example)}`) + "\n"
           );
         }
       } catch (error) {
@@ -8267,13 +9076,13 @@ function registerSearchCommand(program2) {
 }
 
 // src/commands/status.ts
-import chalk19 from "chalk";
+import chalk24 from "chalk";
 var STATUS_SYMBOLS = {
-  "up-to-date": chalk19.green("\u2713"),
-  modified: chalk19.yellow("M"),
-  upstream: chalk19.cyan("U"),
-  both: chalk19.red("MU"),
-  unknown: chalk19.dim("?")
+  "up-to-date": chalk24.green("\u2713"),
+  modified: chalk24.yellow("M"),
+  upstream: chalk24.cyan("U"),
+  both: chalk24.red("MU"),
+  unknown: chalk24.dim("?")
 };
 function parseManifestUri2(uri) {
   const parts = uri.split("/");
@@ -8295,7 +9104,7 @@ async function readLocalFiles2(projectRoot, packageName, agents) {
   return [];
 }
 async function checkPackageStatus(projectRoot, name, manifestEntry, lockfileIntegrity, offline) {
-  const { source, agents } = manifestEntry;
+  const { source, agents, pinned } = manifestEntry;
   if (source.type === "well-known") {
     let locallyModified2 = false;
     try {
@@ -8313,7 +9122,8 @@ async function checkPackageStatus(projectRoot, name, manifestEntry, lockfileInte
       sourceUri: source.hostname,
       ref: "well-known",
       commit: "",
-      agents
+      agents,
+      pinned: pinned || void 0
     };
   }
   if (source.uri === "unknown") {
@@ -8323,7 +9133,8 @@ async function checkPackageStatus(projectRoot, name, manifestEntry, lockfileInte
       sourceUri: source.uri,
       ref: source.ref,
       commit: source.commit,
-      agents
+      agents,
+      pinned: pinned || void 0
     };
   }
   let locallyModified = false;
@@ -8367,18 +9178,20 @@ async function checkPackageStatus(projectRoot, name, manifestEntry, lockfileInte
     ref: source.ref,
     commit: source.commit,
     upstreamCommit: upstreamChanged ? upstreamCommit : void 0,
-    agents
+    agents,
+    pinned: pinned || void 0
   };
 }
 function formatStatusLine(status) {
   const symbol = STATUS_SYMBOLS[status.category];
   const padding = status.category === "both" ? "" : " ";
   if (status.category === "unknown") {
-    return `  ${symbol}  ${chalk19.white(status.name)}  ${chalk19.dim("unknown source")}`;
+    return `  ${symbol}  ${chalk24.white(status.name)}  ${chalk24.dim("unknown source")}`;
   }
   const shortCommit = status.commit.slice(0, 7);
-  const upstream = status.upstreamCommit ? ` ${chalk19.dim("\u2192")} ${chalk19.cyan(`upstream: ${status.upstreamCommit.slice(0, 7)}`)}` : "";
-  return `  ${symbol}${padding} ${chalk19.white(status.name)}  ${chalk19.dim(status.sourceUri)}  ${chalk19.cyan(`@${status.ref}`)} ${chalk19.dim(`(${shortCommit})`)}${upstream}`;
+  const upstream = status.upstreamCommit ? ` ${chalk24.dim("\u2192")} ${chalk24.cyan(`upstream: ${status.upstreamCommit.slice(0, 7)}`)}` : "";
+  const pinned = status.pinned ? chalk24.yellow(" [pinned]") : "";
+  return `  ${symbol}${padding} ${chalk24.white(status.name)}${pinned}  ${chalk24.dim(status.sourceUri)}  ${chalk24.cyan(`@${status.ref}`)} ${chalk24.dim(`(${shortCommit})`)}${upstream}`;
 }
 function buildStatusOutput(statuses) {
   return {
@@ -8396,7 +9209,8 @@ function toStatusResult(output) {
       name: p.name,
       status: p.category,
       modified: p.category === "modified" || p.category === "both",
-      upstream: p.category === "upstream" || p.category === "both"
+      upstream: p.category === "upstream" || p.category === "both",
+      pinned: p.pinned || void 0
     })),
     summary: {
       total: output.total,
@@ -8418,7 +9232,7 @@ function registerStatusCommand(program2) {
       if (jsonMode) {
         outputSuccess(toStatusResult(buildStatusOutput([])));
       } else {
-        console.log(chalk19.dim("No packages installed."));
+        console.log(chalk24.dim("No packages installed."));
       }
       return;
     }
@@ -8441,7 +9255,7 @@ function registerStatusCommand(program2) {
       outputSuccess(toStatusResult(buildStatusOutput(statuses)));
       return;
     }
-    console.log(chalk19.bold(`
+    console.log(chalk24.bold(`
 Installed skills (${statuses.length}):
 `));
     for (const status of statuses) {
@@ -8452,16 +9266,16 @@ Installed skills (${statuses.length}):
 }
 
 // src/commands/suggest.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join17 } from "path";
-import chalk20 from "chalk";
+import { existsSync as existsSync17 } from "fs";
+import { join as join20 } from "path";
+import chalk25 from "chalk";
 var HTTP_TIMEOUT_MS2 = 15e3;
 async function readLocalFiles3(projectRoot, packageName, agents) {
   for (const agentId of agents) {
     const placementPath = getSkillPlacementPath(agentId, packageName, "project");
     if (!placementPath) continue;
-    const fullPath = join17(projectRoot, placementPath);
-    if (!existsSync15(fullPath)) continue;
+    const fullPath = join20(projectRoot, placementPath);
+    if (!existsSync17(fullPath)) continue;
     const files = await readFilesFromDirectory(fullPath);
     return files.map((f) => ({ path: f.path, content: f.content }));
   }
@@ -8509,141 +9323,211 @@ async function postToPlatform(path, body) {
     throw error;
   }
 }
+function buildEndpoint(manifestEntry, packageName) {
+  if (manifestEntry.source.type !== "git") return "";
+  const orgSlug = manifestEntry.source.uri.split("/")[1] ?? "";
+  return `/skills/@${orgSlug}/${packageName}/suggestions`;
+}
+async function submitSuggestion(projectRoot, packageName, manifestEntry, title, description) {
+  const localFiles = await readLocalFiles3(projectRoot, packageName, manifestEntry.agents);
+  if (localFiles.length === 0) {
+    throw new Error(`No local files found for "${packageName}".`);
+  }
+  const endpoint = buildEndpoint(manifestEntry, packageName);
+  const requestBody = {
+    title,
+    description,
+    files: localFiles
+  };
+  const result = await postToPlatform(endpoint, requestBody);
+  return { localFiles, result };
+}
 function registerSuggestCommand(program2) {
-  program2.command("suggest <title>").alias("propose").description("Create a suggestion from local modifications (requires platform connection)").option("-d, --description <text>", "Suggestion description").option("--dry-run", "Show what would be suggested without submitting").action(async (title, options) => {
-    const json = isJSONMode();
-    const platformUrl = getPlatformUrl();
-    const creds = await getCredentials();
-    if (!options.dryRun && (!platformUrl || !creds?.token && !creds?.apiKey)) {
-      if (json) {
-        outputError(
-          "AUTH_REQUIRED",
-          "Not connected to a platform. Run `agentver login <url>` first."
-        );
+  program2.command("suggest <title>").alias("propose").description("Create a suggestion from local modifications (requires platform connection)").option("-d, --description <text>", "Suggestion description").option("--name <name>", "Target a specific modified package by name").option("--dry-run", "Show what would be suggested without submitting").action(
+    async (title, options) => {
+      const json = isJSONMode();
+      const platformUrl = getPlatformUrl();
+      const creds = await getCredentials();
+      if (!options.dryRun && (!platformUrl || !creds?.token && !creds?.apiKey)) {
+        if (json) {
+          outputError(
+            "AUTH_REQUIRED",
+            "Not connected to a platform. Run `agentver login <url>` first."
+          );
+          process.exit(1);
+        }
+        console.error(chalk25.red("Not connected to a platform. Run `agentver login <url>` first."));
         process.exit(1);
       }
-      console.error(chalk20.red("Not connected to a platform. Run `agentver login <url>` first."));
-      process.exit(1);
-    }
-    const projectRoot = process.cwd();
-    const manifest = readManifest(projectRoot);
-    const lockfile = readLockfile(projectRoot);
-    const modifiedPackages = [];
-    for (const [name, manifestEntry2] of Object.entries(manifest.packages)) {
-      const lockfileEntry = lockfile.packages[name];
-      if (!lockfileEntry) continue;
-      const { agents: agents2 } = manifestEntry2;
-      const localFiles = await readLocalFiles3(projectRoot, name, agents2);
-      if (localFiles.length === 0) continue;
-      const currentIntegrity = computeSha256FromFiles(localFiles);
-      if (currentIntegrity !== lockfileEntry.integrity) {
-        modifiedPackages.push(name);
-      }
-    }
-    if (modifiedPackages.length === 0) {
-      if (json) {
-        outputError("NO_CHANGES", "No modified packages detected.");
-        process.exit(1);
+      const projectRoot = process.cwd();
+      const manifest = readManifest(projectRoot);
+      const lockfile = readLockfile(projectRoot);
+      const modifiedPackages = [];
+      for (const [name, manifestEntry] of Object.entries(manifest.packages)) {
+        const lockfileEntry = lockfile.packages[name];
+        if (!lockfileEntry) continue;
+        const { agents } = manifestEntry;
+        const localFiles = await readLocalFiles3(projectRoot, name, agents);
+        if (localFiles.length === 0) continue;
+        const currentIntegrity = computeSha256FromFiles(localFiles);
+        if (currentIntegrity !== lockfileEntry.integrity) {
+          modifiedPackages.push(name);
+        }
       }
-      console.log(chalk20.dim("No modified packages detected."));
-      return;
-    }
-    const targetName = modifiedPackages[0];
-    const manifestEntry = manifest.packages[targetName];
-    const { source, agents } = manifestEntry;
-    if (source.type === "well-known") {
-      if (json) {
-        outputError(
-          "UNSUPPORTED_SOURCE",
-          `Package "${targetName}" was installed from a well-known source. Suggestions are not supported.`
-        );
-      } else {
-        console.error(
-          chalk20.red(
-            `Package "${targetName}" was installed from a well-known source (${source.hostname}).`
-          )
-        );
-        console.error(chalk20.dim("Suggestions are not supported for well-known sources."));
+      if (modifiedPackages.length === 0) {
+        if (json) {
+          outputError("NO_CHANGES", "No modified packages detected.");
+          process.exit(1);
+        }
+        console.log(chalk25.dim("No modified packages detected."));
+        return;
       }
-      process.exit(1);
-    }
-    const spinner = createSpinner("Reading local files...").start();
-    try {
-      const localFiles = await readLocalFiles3(projectRoot, targetName, agents);
-      if (localFiles.length === 0) {
-        spinner.fail(`No local files found for "${targetName}".`);
+      const targets = options.name ? modifiedPackages.filter((n) => n === options.name) : modifiedPackages;
+      if (targets.length === 0 && options.name) {
+        const message = `Package "${options.name}" is not in the modified list. Modified: ${modifiedPackages.join(", ")}`;
         if (json) {
-          outputError("NOT_FOUND", `No local files found for "${targetName}".`);
+          outputError("NOT_FOUND", message);
+          process.exit(1);
+        }
+        console.error(chalk25.red(message));
+        process.exit(1);
+      }
+      const unsupportedTargets = targets.filter(
+        (name) => manifest.packages[name]?.source.type === "well-known"
+      );
+      if (unsupportedTargets.length > 0) {
+        for (const name of unsupportedTargets) {
+          const source = manifest.packages[name].source;
+          if (json) {
+            outputError(
+              "UNSUPPORTED_SOURCE",
+              `Package "${name}" was installed from a well-known source. Suggestions are not supported.`
+            );
+          } else {
+            console.error(
+              chalk25.red(
+                `Package "${name}" was installed from a well-known source (${source.type === "well-known" ? source.hostname : "unknown"}).`
+              )
+            );
+            console.error(chalk25.dim("Suggestions are not supported for well-known sources."));
+          }
         }
+      }
+      const validTargets = targets.filter((n) => !unsupportedTargets.includes(n));
+      if (validTargets.length === 0) {
         process.exit(1);
       }
-      const orgSlug = source.uri.split("/")[1] ?? "";
-      const pkgName = targetName;
       if (options.dryRun) {
-        const dryRunResult = {
-          package: targetName,
-          title,
-          description: options.description,
-          files: localFiles.map((f) => ({
-            path: f.path,
-            contentLength: f.content.length
-          })),
-          endpoint: `/api/v1/skills/@${orgSlug}/${pkgName}/suggestions`
-        };
-        spinner.stop();
+        const dryRunResults = [];
+        for (const targetName of validTargets) {
+          const manifestEntry = manifest.packages[targetName];
+          const localFiles = await readLocalFiles3(projectRoot, targetName, manifestEntry.agents);
+          const endpoint = `/api/v1${buildEndpoint(manifestEntry, targetName)}`;
+          dryRunResults.push({
+            package: targetName,
+            title,
+            description: options.description,
+            files: localFiles.map((f) => ({
+              path: f.path,
+              contentLength: f.content.length
+            })),
+            endpoint
+          });
+        }
         if (json) {
-          outputSuccess(dryRunResult);
+          outputSuccess(dryRunResults);
         } else {
-          console.log(chalk20.bold("\nDry run \u2014 suggestion preview:\n"));
-          console.log(`  ${chalk20.dim("Package:")}  ${targetName}`);
-          console.log(`  ${chalk20.dim("Title:")}    ${title}`);
-          if (options.description) {
-            console.log(`  ${chalk20.dim("Desc:")}     ${options.description}`);
-          }
-          console.log(`  ${chalk20.dim("Files:")}`);
-          for (const f of dryRunResult.files) {
-            console.log(`    ${chalk20.cyan(f.path)} (${f.contentLength} bytes)`);
+          console.log(chalk25.bold("\nDry run \u2014 suggestion preview:\n"));
+          for (const entry of dryRunResults) {
+            console.log(`  ${chalk25.dim("Package:")}  ${entry.package}`);
+            console.log(`  ${chalk25.dim("Title:")}    ${entry.title}`);
+            if (entry.description) {
+              console.log(`  ${chalk25.dim("Desc:")}     ${entry.description}`);
+            }
+            console.log(`  ${chalk25.dim("Files:")}`);
+            for (const f of entry.files) {
+              console.log(`    ${chalk25.cyan(f.path)} (${f.contentLength} bytes)`);
+            }
+            console.log(`  ${chalk25.dim("Endpoint:")} ${entry.endpoint}`);
+            console.log();
           }
-          console.log(`  ${chalk20.dim("Endpoint:")} ${dryRunResult.endpoint}`);
-          console.log();
+          console.log(
+            chalk25.dim(
+              `${dryRunResults.length} package${dryRunResults.length === 1 ? "" : "s"} would get suggestions.`
+            )
+          );
         }
         return;
       }
-      spinner.text = "Submitting suggestion...";
-      const requestBody = {
-        title,
-        description: options.description,
-        files: localFiles
-      };
-      const result = await postToPlatform(
-        `/skills/@${orgSlug}/${pkgName}/suggestions`,
-        requestBody
-      );
-      if (json) {
-        outputSuccess({
-          proposalId: result.id,
-          title: result.title ?? title,
-          url: result.url ?? ""
-        });
-        return;
-      }
-      spinner.succeed(`Suggestion created: ${chalk20.bold(result.title ?? title)}`);
-      if (result.url) {
-        console.log(chalk20.dim(`  ${result.url}`));
+      const outcomes = [];
+      for (const targetName of validTargets) {
+        const manifestEntry = manifest.packages[targetName];
+        const spinner = createSpinner(`Creating suggestion for ${targetName}...`).start();
+        try {
+          const { result } = await submitSuggestion(
+            projectRoot,
+            targetName,
+            manifestEntry,
+            title,
+            options.description
+          );
+          const proposeResult = {
+            proposalId: result.id,
+            title: result.title ?? title,
+            url: result.url ?? ""
+          };
+          outcomes.push({ package: targetName, success: true, result: proposeResult });
+          if (!json) {
+            spinner.succeed(
+              `Created suggestion for ${chalk25.bold(targetName)}: ${chalk25.bold(proposeResult.title)}`
+            );
+            if (result.url) {
+              console.log(chalk25.dim(`  ${result.url}`));
+            }
+          } else {
+            spinner.stop();
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          outcomes.push({ package: targetName, success: false, error: message });
+          if (!json) {
+            spinner.fail(`Failed to create suggestion for ${chalk25.bold(targetName)}: ${message}`);
+          } else {
+            spinner.stop();
+          }
+        }
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      spinner.fail(`Failed to create suggestion: ${message}`);
+      const succeeded = outcomes.filter((o) => o.success);
+      const failed = outcomes.filter((o) => !o.success);
       if (json) {
-        outputError("SUGGEST_FAILED", message);
+        if (validTargets.length === 1) {
+          const outcome = outcomes[0];
+          if (outcome.success) {
+            outputSuccess(outcome.result);
+          } else {
+            outputError("SUGGEST_FAILED", outcome.error);
+            process.exit(1);
+          }
+        } else {
+          outputSuccess(outcomes);
+        }
+      } else if (validTargets.length > 1) {
+        console.log();
+        console.log(
+          chalk25.bold(
+            `Created ${succeeded.length} suggestion${succeeded.length === 1 ? "" : "s"}` + (failed.length > 0 ? ` (${failed.length} failed)` : "")
+          )
+        );
+      }
+      if (failed.length > 0 && succeeded.length === 0) {
+        process.exit(1);
       }
-      process.exit(1);
     }
-  });
+  );
 }
 
 // src/commands/suggestions.ts
-import chalk21 from "chalk";
+import chalk26 from "chalk";
 var HTTP_TIMEOUT_MS3 = 15e3;
 async function getFromPlatform(path) {
   const platformUrl = getPlatformUrl();
@@ -8698,21 +9582,21 @@ function formatDate2(isoDate) {
   }
 }
 var STATUS_COLOURS = {
-  OPEN: chalk21.green,
-  IN_REVIEW: chalk21.yellow,
-  APPROVED: chalk21.blue,
-  MERGED: chalk21.magenta,
-  REJECTED: chalk21.red,
-  CLOSED: chalk21.dim
+  OPEN: chalk26.green,
+  IN_REVIEW: chalk26.yellow,
+  APPROVED: chalk26.blue,
+  MERGED: chalk26.magenta,
+  REJECTED: chalk26.red,
+  CLOSED: chalk26.dim
 };
 function formatSuggestionRow(suggestion, idWidth, titleWidth, slugWidth, authorWidth) {
-  const id = chalk21.dim(`#${suggestion.id}`.padEnd(idWidth + 1));
+  const id = chalk26.dim(`#${suggestion.id}`.padEnd(idWidth + 1));
   const title = suggestion.title.padEnd(titleWidth);
-  const slug = chalk21.cyan(suggestion.packageSlug.padEnd(slugWidth));
-  const statusFn = STATUS_COLOURS[suggestion.status] ?? chalk21.dim;
+  const slug = chalk26.cyan(suggestion.packageSlug.padEnd(slugWidth));
+  const statusFn = STATUS_COLOURS[suggestion.status] ?? chalk26.dim;
   const status = statusFn(suggestion.status.padEnd(11));
-  const author = chalk21.dim(suggestion.author.padEnd(authorWidth));
-  const date = chalk21.dim(formatDate2(suggestion.createdAt));
+  const author = chalk26.dim(suggestion.author.padEnd(authorWidth));
+  const date = chalk26.dim(formatDate2(suggestion.createdAt));
   return `  ${id}  ${title}  ${slug}  ${status}  ${author}  ${date}`;
 }
 function registerSuggestionsCommand(program2) {
@@ -8728,7 +9612,7 @@ function registerSuggestionsCommand(program2) {
         );
         process.exit(1);
       }
-      console.error(chalk21.red("Not connected to a platform. Run `agentver login <url>` first."));
+      console.error(chalk26.red("Not connected to a platform. Run `agentver login <url>` first."));
       process.exit(1);
     }
     const spinner = createSpinner("Fetching suggestions...").start();
@@ -8760,7 +9644,7 @@ function registerSuggestionsCommand(program2) {
       }
       if (suggestions.length === 0) {
         const filterLabel = statusFilter === "ALL" ? "" : ` ${options.status}`;
-        console.log(chalk21.dim(`No${filterLabel} suggestions found.`));
+        console.log(chalk26.dim(`No${filterLabel} suggestions found.`));
         return;
       }
       const idWidth = Math.max(...suggestions.map((s) => `#${s.id}`.length));
@@ -8768,7 +9652,7 @@ function registerSuggestionsCommand(program2) {
       const slugWidth = Math.max(...suggestions.map((s) => s.packageSlug.length));
       const authorWidth = Math.max(...suggestions.map((s) => s.author.length));
       const heading = statusFilter === "ALL" ? `Suggestions (${suggestions.length})` : `${options.status.charAt(0).toUpperCase() + options.status.slice(1)} suggestions (${suggestions.length})`;
-      console.log(chalk21.bold(`
+      console.log(chalk26.bold(`
 ${heading}:
 `));
       for (const suggestion of suggestions) {
@@ -8789,7 +9673,7 @@ ${heading}:
 // src/commands/sync.ts
 import { createHash as createHash4 } from "crypto";
 import { hostname as hostname2 } from "os";
-import chalk22 from "chalk";
+import chalk27 from "chalk";
 var SYNC_TIMEOUT_MS = 3e4;
 function getMachineId2() {
   return createHash4("sha256").update(hostname2()).digest("hex");
@@ -8806,7 +9690,7 @@ function registerSyncCommand(program2) {
         process.exit(1);
       }
       console.error(
-        chalk22.red("Not connected to a platform.") + " Run " + chalk22.cyan("`agentver login <url>`") + " first."
+        chalk27.red("Not connected to a platform.") + " Run " + chalk27.cyan("`agentver login <url>`") + " first."
       );
       process.exit(1);
     }
@@ -8820,7 +9704,7 @@ function registerSyncCommand(program2) {
         process.exit(1);
       }
       console.error(
-        chalk22.red("Not connected to a platform.") + " Run " + chalk22.cyan("`agentver login <url>`") + " first."
+        chalk27.red("Not connected to a platform.") + " Run " + chalk27.cyan("`agentver login <url>`") + " first."
       );
       process.exit(1);
     }
@@ -8892,7 +9776,7 @@ function registerSyncCommand(program2) {
         return;
       }
       spinner.succeed(
-        `Synced ${chalk22.green(String(result.synced))} skill${result.synced === 1 ? "" : "s"} to platform` + (result.removed > 0 ? chalk22.dim(` (${result.removed} removed)`) : "")
+        `Synced ${chalk27.green(String(result.synced))} skill${result.synced === 1 ? "" : "s"} to platform` + (result.removed > 0 ? chalk27.dim(` (${result.removed} removed)`) : "")
       );
     } catch (error) {
       if (error instanceof DOMException && error.name === "AbortError") {
@@ -8916,23 +9800,23 @@ function registerSyncCommand(program2) {
 }
 
 // src/commands/update.ts
-import { join as join20 } from "path";
-import chalk23 from "chalk";
+import { join as join23 } from "path";
+import chalk28 from "chalk";
 import ora7 from "ora";
 import prompts3 from "prompts";
 
 // src/storage/patches.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync13, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { join as join21 } from "path";
 var PATCHES_DIR = ".agentver/patches";
 var CONTEXT_LINES2 = 3;
 function getPatchPath(projectRoot, packageName) {
-  return join18(projectRoot, PATCHES_DIR, `${packageName}.patch`);
+  return join21(projectRoot, PATCHES_DIR, `${packageName}.patch`);
 }
 function savePatch(projectRoot, packageName, patchContent) {
   const patchPath = getPatchPath(projectRoot, packageName);
-  const dir = join18(projectRoot, PATCHES_DIR);
-  if (!existsSync16(dir)) {
+  const dir = join21(projectRoot, PATCHES_DIR);
+  if (!existsSync18(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   writeFileSync8(patchPath, patchContent, "utf-8");
@@ -8940,7 +9824,7 @@ function savePatch(projectRoot, packageName, patchContent) {
 }
 function removePatch(projectRoot, packageName) {
   const patchPath = getPatchPath(projectRoot, packageName);
-  if (existsSync16(patchPath)) {
+  if (existsSync18(patchPath)) {
     rmSync3(patchPath);
   }
 }
@@ -8987,30 +9871,30 @@ function applyPatch(projectRoot, patchContent) {
   };
 }
 function applyFilePatch(projectRoot, filePatch) {
-  const fullPath = join18(projectRoot, filePatch.filePath);
+  const fullPath = join21(projectRoot, filePatch.filePath);
   const hasOnlyAdditions = filePatch.hunks.every(
     (h) => h.lines.every((l) => l.startsWith("+") || l.startsWith(" "))
   );
   const hasOnlyDeletions = filePatch.hunks.every(
     (h) => h.lines.every((l) => l.startsWith("-") || l.startsWith(" "))
   );
-  if (hasOnlyAdditions && !existsSync16(fullPath)) {
+  if (hasOnlyAdditions && !existsSync18(fullPath)) {
     const content = filePatch.hunks.flatMap((h) => h.lines.filter((l) => l.startsWith("+")).map((l) => l.slice(1))).join("\n");
-    const dir = join18(fullPath, "..");
-    if (!existsSync16(dir)) {
+    const dir = join21(fullPath, "..");
+    if (!existsSync18(dir)) {
       mkdirSync9(dir, { recursive: true });
     }
     writeFileSync8(fullPath, content, "utf-8");
     return true;
   }
-  if (hasOnlyDeletions && existsSync16(fullPath)) {
+  if (hasOnlyDeletions && existsSync18(fullPath)) {
     rmSync3(fullPath);
     return true;
   }
-  if (!existsSync16(fullPath)) {
+  if (!existsSync18(fullPath)) {
     return false;
   }
-  const currentContent = readFileSync13(fullPath, "utf-8");
+  const currentContent = readFileSync16(fullPath, "utf-8");
   const currentLines = currentContent.split("\n");
   let offset = 0;
   for (const hunk of filePatch.hunks) {
@@ -9294,17 +10178,17 @@ function backtrackMyers(trace, oldLines, newLines, finalD, max) {
 }
 
 // src/utils/backup.ts
-import { cpSync, existsSync as existsSync17, mkdirSync as mkdirSync10, mkdtempSync, rmSync as rmSync4 } from "fs";
+import { cpSync, existsSync as existsSync19, mkdirSync as mkdirSync10, mkdtempSync, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join19 } from "path";
+import { join as join22 } from "path";
 function createBackup(packageName, projectRoot, skillDir) {
-  const tempDir = mkdtempSync(join19(tmpdir2(), "agentver-backup-"));
+  const tempDir = mkdtempSync(join22(tmpdir2(), "agentver-backup-"));
   const manifest = readManifest(projectRoot);
   const manifestEntry = manifest.packages[packageName] ?? null;
   const lockfile = readLockfile(projectRoot);
   const lockfileEntry = lockfile.packages[packageName] ?? null;
-  if (skillDir && existsSync17(skillDir)) {
-    const backupSkillDir = join19(tempDir, "files");
+  if (skillDir && existsSync19(skillDir)) {
+    const backupSkillDir = join22(tempDir, "files");
     mkdirSync10(backupSkillDir, { recursive: true });
     cpSync(skillDir, backupSkillDir, { recursive: true });
   }
@@ -9319,9 +10203,9 @@ function createBackup(packageName, projectRoot, skillDir) {
 }
 function restoreBackup(backup) {
   if (backup.skillDir) {
-    const backupSkillDir = join19(backup.tempDir, "files");
-    if (existsSync17(backupSkillDir)) {
-      if (existsSync17(backup.skillDir)) {
+    const backupSkillDir = join22(backup.tempDir, "files");
+    if (existsSync19(backupSkillDir)) {
+      if (existsSync19(backup.skillDir)) {
         rmSync4(backup.skillDir, { recursive: true, force: true });
       }
       mkdirSync10(backup.skillDir, { recursive: true });
@@ -9344,7 +10228,7 @@ function restoreBackup(backup) {
   writeLockfile(backup.projectRoot, lockfile);
 }
 function cleanupBackup(backup) {
-  if (existsSync17(backup.tempDir)) {
+  if (existsSync19(backup.tempDir)) {
     rmSync4(backup.tempDir, { recursive: true, force: true });
   }
 }
@@ -9450,13 +10334,13 @@ async function handlePatchUpdate(update, projectRoot, agents, spinner) {
   const applyResult = applyPatch(projectRoot, patchContent);
   if (applyResult.applied) {
     removePatch(projectRoot, update.name);
-    spinner.succeed(`${chalk23.green(update.name)}: updated and local patch reapplied successfully`);
+    spinner.succeed(`${chalk28.green(update.name)}: updated and local patch reapplied successfully`);
   } else {
     spinner.warn(
-      `${chalk23.yellow(update.name)}: updated but patch had conflicts in: ${applyResult.conflicts.join(", ")}`
+      `${chalk28.yellow(update.name)}: updated but patch had conflicts in: ${applyResult.conflicts.join(", ")}`
     );
-    console.log(chalk23.dim(`  Patch saved at: ${patchPath}`));
-    console.log(chalk23.dim("  Review the patch file and apply remaining changes manually."));
+    console.log(chalk28.dim(`  Patch saved at: ${patchPath}`));
+    console.log(chalk28.dim("  Review the patch file and apply remaining changes manually."));
   }
   return { commitSha: result.commitSha };
 }
@@ -9473,27 +10357,43 @@ function registerUpdateCommand(program2) {
         return;
       }
       console.log(
-        chalk23.dim(name ? `Package "${name}" is not installed.` : "No packages installed.")
+        chalk28.dim(name ? `Package "${name}" is not installed.` : "No packages installed.")
       );
       return;
     }
+    const pinnedNames = [];
     const updatable = packageNames.filter((n) => {
       const pkg2 = packages[n];
-      return pkg2 && pkg2.source.type === "git" && pkg2.source.uri !== "unknown";
+      if (!pkg2) return false;
+      if (pkg2.pinned === true) {
+        pinnedNames.push(n);
+        return false;
+      }
+      return pkg2.source.type === "git" && pkg2.source.uri !== "unknown";
     });
+    if (pinnedNames.length > 0 && !jsonMode) {
+      for (const pinnedName of pinnedNames) {
+        console.log(chalk28.dim(`Skipping ${pinnedName} (pinned)`));
+      }
+    }
     if (updatable.length === 0) {
       if (jsonMode) {
         outputSuccess({
           updated: [],
-          skipped: packageNames.map((n) => ({ name: n, reason: "No known Git source" }))
+          skipped: [
+            ...pinnedNames.map((n) => ({ name: n, reason: "pinned" })),
+            ...packageNames.filter((n) => !pinnedNames.includes(n)).map((n) => ({ name: n, reason: "No known Git source" }))
+          ]
         });
         return;
       }
-      console.log(
-        chalk23.dim(
-          "No packages with known Git sources. Reinstall packages using Git source URLs to enable updates."
-        )
-      );
+      if (pinnedNames.length === 0) {
+        console.log(
+          chalk28.dim(
+            "No packages with known Git sources. Reinstall packages using Git source URLs to enable updates."
+          )
+        );
+      }
       return;
     }
     const spinner = createSpinner("Checking for upstream changes...").start();
@@ -9533,17 +10433,17 @@ function registerUpdateCommand(program2) {
           outputSuccess({ updated: [], skipped: [] });
           return;
         }
-        console.log(chalk23.green("All packages are up to date."));
+        console.log(chalk28.green("All packages are up to date."));
         return;
       }
       if (!jsonMode) {
-        console.log(chalk23.bold(`
+        console.log(chalk28.bold(`
 Upstream changes available (${updates.length}):
 `));
         for (const update of updates) {
-          const modifiedIndicator = update.locallyModified ? ` ${chalk23.yellow("\u26A0 locally modified")}` : "";
+          const modifiedIndicator = update.locallyModified ? ` ${chalk28.yellow("\u26A0 locally modified")}` : "";
           console.log(
-            `  ${chalk23.green(update.name)}: ${chalk23.dim(update.currentCommit.slice(0, 7))} \u2192 ${chalk23.cyan(update.latestCommit.slice(0, 7))} ${chalk23.dim(`(${update.ref})`)}${modifiedIndicator}`
+            `  ${chalk28.green(update.name)}: ${chalk28.dim(update.currentCommit.slice(0, 7))} \u2192 ${chalk28.cyan(update.latestCommit.slice(0, 7))} ${chalk28.dim(`(${update.ref})`)}${modifiedIndicator}`
           );
         }
         console.log();
@@ -9556,7 +10456,7 @@ Upstream changes available (${updates.length}):
           });
           return;
         }
-        console.log(`${chalk23.yellow("[dry-run]")} No changes made.`);
+        console.log(`${chalk28.yellow("[dry-run]")} No changes made.`);
         return;
       }
       if (!jsonMode) {
@@ -9567,7 +10467,7 @@ Upstream changes available (${updates.length}):
           initial: true
         });
         if (!confirmed) {
-          console.log(chalk23.dim("Update cancelled."));
+          console.log(chalk28.dim("Update cancelled."));
           return;
         }
       }
@@ -9633,7 +10533,7 @@ Upstream changes available (${updates.length}):
           }
         }
         const shortName = update.name.split("/").pop();
-        const skillDir = resolveReadPath(projectRoot, shortName, agents) ?? (agentId ? join20(
+        const skillDir = resolveReadPath(projectRoot, shortName, agents) ?? (agentId ? join23(
           projectRoot,
           getSkillPlacementPath(agentId, shortName, "project") ?? ""
         ) : null);
@@ -9675,25 +10575,25 @@ Upstream changes available (${updates.length}):
       if (jsonMode) {
         outputSuccess({
           updated: jsonUpdated,
-          skipped: jsonSkipped
+          skipped: [...pinnedNames.map((n) => ({ name: n, reason: "pinned" })), ...jsonSkipped]
         });
         return;
       }
-      console.log(chalk23.bold("\nUpdate summary:\n"));
+      console.log(chalk28.bold("\nUpdate summary:\n"));
       for (const result of results) {
-        const patchNote = result.patched ? chalk23.dim(" (patch reapplied)") : "";
+        const patchNote = result.patched ? chalk28.dim(" (patch reapplied)") : "";
         console.log(
-          `  ${chalk23.green("\u2713")} ${result.name}: ${chalk23.dim(result.from)} \u2192 ${chalk23.cyan(result.to)}${patchNote}`
+          `  ${chalk28.green("\u2713")} ${result.name}: ${chalk28.dim(result.from)} \u2192 ${chalk28.cyan(result.to)}${patchNote}`
         );
       }
       for (const skippedName of skipped) {
-        console.log(`  ${chalk23.dim("\u2013")} ${skippedName}: ${chalk23.dim("skipped")}`);
+        console.log(`  ${chalk28.dim("\u2013")} ${skippedName}: ${chalk28.dim("skipped")}`);
       }
       for (const failure of failures) {
-        console.log(`  ${chalk23.red("\u2717")} ${failure.name}: ${failure.error}`);
+        console.log(`  ${chalk28.red("\u2717")} ${failure.name}: ${failure.error}`);
       }
       if (failures.length > 0) {
-        console.log(chalk23.dim("\nFailed packages were rolled back to their previous versions."));
+        console.log(chalk28.dim("\nFailed packages were rolled back to their previous versions."));
       }
       console.log();
     } catch (error) {
@@ -9712,16 +10612,16 @@ Upstream changes available (${updates.length}):
 // src/commands/upgrade.ts
 import { execFile as execFile2 } from "child_process";
 import { createRequire } from "module";
-import { dirname as dirname5, join as join21 } from "path";
+import { dirname as dirname6, join as join24 } from "path";
 import { fileURLToPath } from "url";
 import { promisify as promisify2 } from "util";
-import chalk24 from "chalk";
+import chalk29 from "chalk";
 var execFileAsync2 = promisify2(execFile2);
 var PACKAGE_NAME = "@agentver/cli";
 function getCurrentVersion() {
-  const __dirname2 = dirname5(fileURLToPath(import.meta.url));
+  const __dirname2 = dirname6(fileURLToPath(import.meta.url));
   const require3 = createRequire(import.meta.url);
-  const pkg2 = require3(join21(__dirname2, "..", "package.json"));
+  const pkg2 = require3(join24(__dirname2, "..", "package.json"));
   return pkg2.version;
 }
 async function getLatestVersion() {
@@ -9777,11 +10677,11 @@ function registerUpgradeCommand(program2) {
         if (json) {
           outputSuccess({ current: currentVersion, latest: latestVersion, upToDate: true });
         } else {
-          spinner.succeed(`Already on the latest version ${chalk24.green(`v${currentVersion}`)}`);
+          spinner.succeed(`Already on the latest version ${chalk29.green(`v${currentVersion}`)}`);
         }
         return;
       }
-      spinner.text = `Upgrading ${chalk24.dim(`v${currentVersion}`)} \u2192 ${chalk24.green(`v${latestVersion}`)}\u2026`;
+      spinner.text = `Upgrading ${chalk29.dim(`v${currentVersion}`)} \u2192 ${chalk29.green(`v${latestVersion}`)}\u2026`;
       const pm = await detectPackageManager();
       const args = getInstallArgs(pm);
       await execFileAsync2(pm, args, { timeout: 6e4 });
@@ -9794,7 +10694,7 @@ function registerUpgradeCommand(program2) {
         outputSuccess(result);
       } else {
         spinner.succeed(
-          `Upgraded ${chalk24.green(`v${currentVersion}`)} \u2192 ${chalk24.green(`v${latestVersion}`)} via ${pm}`
+          `Upgraded ${chalk29.green(`v${currentVersion}`)} \u2192 ${chalk29.green(`v${latestVersion}`)} via ${pm}`
         );
       }
     } catch (error) {
@@ -9811,7 +10711,7 @@ function registerUpgradeCommand(program2) {
 }
 
 // src/commands/verify.ts
-import chalk25 from "chalk";
+import chalk30 from "chalk";
 var FALLBACK_SOURCE2 = {
   host: "github.com",
   owner: "local",
@@ -9878,8 +10778,8 @@ function registerVerifyCommand(program2) {
           outputError("NO_SKILL", "No skill name provided and no packages installed");
           return;
         }
-        process.stderr.write(chalk25.red("No skill name provided and no packages installed.\n"));
-        process.stderr.write(chalk25.dim("Usage: agentver verify @org/skill-name\n"));
+        process.stderr.write(chalk30.red("No skill name provided and no packages installed.\n"));
+        process.stderr.write(chalk30.dim("Usage: agentver verify @org/skill-name\n"));
         process.exitCode = 1;
         return;
       }
@@ -9894,10 +10794,10 @@ function registerVerifyCommand(program2) {
           return;
         }
         process.stderr.write(
-          chalk25.red("Multiple packages installed. Please specify which to verify:\n")
+          chalk30.red("Multiple packages installed. Please specify which to verify:\n")
         );
         for (const pkg2 of packageNames) {
-          process.stderr.write(`  ${chalk25.cyan(pkg2)}
+          process.stderr.write(`  ${chalk30.cyan(pkg2)}
 `);
         }
         process.exitCode = 1;
@@ -9914,7 +10814,7 @@ function registerVerifyCommand(program2) {
         return;
       }
       process.stderr.write(
-        chalk25.red(`Invalid skill name "${skillName}". Expected format: @org/skill-name
+        chalk30.red(`Invalid skill name "${skillName}". Expected format: @org/skill-name
 `)
       );
       process.exitCode = 1;
@@ -9922,7 +10822,7 @@ function registerVerifyCommand(program2) {
     }
     if (!jsonMode) {
       process.stderr.write(`
-${chalk25.bold(`Verifying @${parsed.org}/${parsed.skill}...`)}
+${chalk30.bold(`Verifying @${parsed.org}/${parsed.skill}...`)}
 
 `);
     }
@@ -10064,26 +10964,26 @@ ${chalk25.bold(`Verifying @${parsed.org}/${parsed.skill}...`)}
     }
     process.stderr.write("\n");
     if (overallPassed) {
-      process.stderr.write(chalk25.green.bold("Skill is verified and safe to use.\n"));
+      process.stderr.write(chalk30.green.bold("Skill is verified and safe to use.\n"));
     } else {
-      process.stderr.write(chalk25.red.bold("Skill verification failed.\n"));
+      process.stderr.write(chalk30.red.bold("Skill verification failed.\n"));
       process.exitCode = 1;
     }
   });
 }
 
 // src/commands/version.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
-import { basename as basename6, join as join22 } from "path";
-import chalk26 from "chalk";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { basename as basename6, join as join25 } from "path";
+import chalk31 from "chalk";
 import ora8 from "ora";
 var SEMVER_REGEX2 = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 function resolveSkillIdentity3() {
   const cwd = process.cwd();
-  const skillMdPath = join22(cwd, "SKILL.md");
+  const skillMdPath = join25(cwd, "SKILL.md");
   let skillName = null;
-  if (existsSync18(skillMdPath)) {
-    const content = readFileSync14(skillMdPath, "utf-8");
+  if (existsSync20(skillMdPath)) {
+    const content = readFileSync17(skillMdPath, "utf-8");
     const nameMatch = content.match(/^name:\s*(.+)$/m);
     skillName = nameMatch?.[1]?.trim() ?? basename6(cwd);
   }
@@ -10111,7 +11011,7 @@ function registerVersionCommand(program2) {
   version.command("create <semver>").description("Create a version tag for the current skill").option("--notes <text>", "Release notes").option("--json", "Output as JSON").action(async (semver, options) => {
     if (!SEMVER_REGEX2.test(semver)) {
       process.stderr.write(
-        chalk26.red(`Invalid semver "${semver}". Expected format: 1.0.0 or 1.0.0-beta.1
+        chalk31.red(`Invalid semver "${semver}". Expected format: 1.0.0 or 1.0.0-beta.1
 `)
       );
       process.exit(1);
@@ -10119,7 +11019,7 @@ function registerVersionCommand(program2) {
     const identity = resolveSkillIdentity3();
     if (!identity) {
       process.stderr.write(
-        chalk26.red("Could not determine skill identity. Run this from a skill directory.\n")
+        chalk31.red("Could not determine skill identity. Run this from a skill directory.\n")
       );
       process.exit(1);
     }
@@ -10127,7 +11027,7 @@ function registerVersionCommand(program2) {
     const lockEntry = lockfile.packages[identity.name];
     const commitSha = lockEntry?.source.type === "git" ? lockEntry.source.commit : void 0;
     if (!commitSha || commitSha === "unknown") {
-      process.stderr.write(chalk26.red("No commit SHA found in lockfile. Save changes first.\n"));
+      process.stderr.write(chalk31.red("No commit SHA found in lockfile. Save changes first.\n"));
       process.exit(1);
     }
     const spinner = ora8(`Creating version ${semver}...`).start();
@@ -10159,7 +11059,7 @@ function registerVersionCommand(program2) {
         );
       } else {
         spinner.succeed(
-          `Version ${chalk26.cyan(semver)} created ${chalk26.dim(`(${result.commitSha.slice(0, 7)})`)}`
+          `Version ${chalk31.cyan(semver)} created ${chalk31.dim(`(${result.commitSha.slice(0, 7)})`)}`
         );
       }
     } catch (error) {
@@ -10173,7 +11073,7 @@ function registerVersionCommand(program2) {
     const identity = resolveSkillIdentity3();
     if (!identity) {
       process.stderr.write(
-        chalk26.red("Could not determine skill identity. Run this from a skill directory.\n")
+        chalk31.red("Could not determine skill identity. Run this from a skill directory.\n")
       );
       process.exit(1);
     }
@@ -10188,16 +11088,16 @@ function registerVersionCommand(program2) {
         return;
       }
       if (versions.length === 0) {
-        process.stdout.write(chalk26.dim("No versions found.\n"));
+        process.stdout.write(chalk31.dim("No versions found.\n"));
         return;
       }
-      process.stdout.write(chalk26.bold(`
+      process.stdout.write(chalk31.bold(`
 Versions for @${identity.org}/${identity.name}:
 
 `));
       for (const v of versions) {
         process.stdout.write(
-          `  ${chalk26.cyan(v.name)} ${chalk26.dim(`(${v.commitSha.slice(0, 7)})`)} ${chalk26.dim(v.message)}
+          `  ${chalk31.cyan(v.name)} ${chalk31.dim(`(${v.commitSha.slice(0, 7)})`)} ${chalk31.dim(v.message)}
 `
         );
       }
@@ -10212,7 +11112,7 @@ Versions for @${identity.org}/${identity.name}:
 }
 
 // src/commands/whoami.ts
-import chalk27 from "chalk";
+import chalk32 from "chalk";
 function registerWhoamiCommand(program2) {
   program2.command("whoami").description("Show authentication state").action(async () => {
     const credentials = await getCredentials();
@@ -10221,15 +11121,15 @@ function registerWhoamiCommand(program2) {
         outputSuccess({ authenticated: false });
         return;
       }
-      console.log(chalk27.dim("Not authenticated. Run `agentver login` to sign in."));
+      console.log(chalk32.dim("Not authenticated. Run `agentver login` to sign in."));
       return;
     }
     if (!isJSONMode()) {
       if (credentials.apiKey) {
         const prefix = credentials.apiKey.slice(0, 8);
-        console.log(`Authenticated via API key: ${chalk27.green(`${prefix}...`)}`);
+        console.log(`Authenticated via API key: ${chalk32.green(`${prefix}...`)}`);
       } else {
-        console.log(chalk27.green("Authenticated via OAuth."));
+        console.log(chalk32.green("Authenticated via OAuth."));
       }
     }
     const platformUrl = getPlatformUrl();
@@ -10238,11 +11138,11 @@ function registerWhoamiCommand(program2) {
         outputSuccess({ authenticated: true });
         return;
       }
-      console.log(chalk27.dim("Platform: not connected (run `agentver login <url>` to connect)"));
+      console.log(chalk32.dim("Platform: not connected (run `agentver login <url>` to connect)"));
       return;
     }
     if (!isJSONMode()) {
-      console.log(`Platform: ${chalk27.cyan(platformUrl)}`);
+      console.log(`Platform: ${chalk32.cyan(platformUrl)}`);
     }
     const me = await platformFetchSilent("/me");
     if (isJSONMode()) {
@@ -10269,38 +11169,44 @@ function registerWhoamiCommand(program2) {
 }
 
 // bin/agentver.ts
-var __dirname = dirname6(fileURLToPath2(import.meta.url));
+var __dirname = dirname7(fileURLToPath2(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join23(__dirname, "..", "package.json"));
+var pkg = require2(join26(__dirname, "..", "package.json"));
 updateNotifier({ pkg }).notify({
   message: `Update available: {currentVersion} \u2192 {latestVersion}
-Run ${chalk28.cyan("agentver upgrade")} to update`
+Run ${chalk33.cyan("agentver upgrade")} to update`
 });
 var program = new Command();
 program.name("agentver").description("Agent skill registry \u2014 store, version, and distribute AI agent skills").version(pkg.version).option("--json", "Output results as structured JSON");
 registerAdoptCommand(program);
-registerInstallCommand(program);
 registerAuditCommand(program);
+registerCompletionCommand(program);
+registerConfigCommand(program);
+registerDiffCommand(program);
+registerDoctorCommand(program);
+registerDraftCommand(program);
+registerInfoCommand(program);
+registerInitCommand(program);
+registerInstallCommand(program);
+registerListCommand(program);
+registerLogCommand(program);
 registerLoginCommand(program);
 registerLogoutCommand(program);
-registerListCommand(program);
-registerSearchCommand(program);
-registerUpdateCommand(program);
+registerPinCommand(program);
+registerPublishCommand(program);
 registerRemoveCommand(program);
-registerInitCommand(program);
+registerSaveCommand(program);
 registerScanCommand(program);
-registerWhoamiCommand(program);
+registerSearchCommand(program);
 registerStatusCommand(program);
-registerDiffCommand(program);
-registerSyncCommand(program);
 registerSuggestCommand(program);
 registerSuggestionsCommand(program);
-registerSaveCommand(program);
-registerPublishCommand(program);
-registerDraftCommand(program);
+registerSyncCommand(program);
+registerUnpinCommand(program);
+registerUpdateCommand(program);
 registerUpgradeCommand(program);
 registerVerifyCommand(program);
 registerVersionCommand(program);
-registerLogCommand(program);
+registerWhoamiCommand(program);
 program.parse();
 //# sourceMappingURL=agentver.js.map