@klhapp/skillmux 1.10.0 → 1.11.1

package/src/adapters.ts

@@ -28,7 +28,7 @@ export interface Capabilities {
   restart_required_keys: string[];
 }
 
-export interface TargetAdapterOptions {
+export interface ContextAdapterOptions {
   configPath?: string;
   allowInsecure?: boolean;
   clients?: Clients;
@@ -46,10 +46,10 @@ export interface AuditPruneResult extends PruneResult {
 }
 
 /**
- * Target adapter: `local` = this CLI process has the Skillmux runtime (vault, index,
+ * Context adapter: `local` = this CLI process has the Skillmux runtime (vault, index,
  * audit db, embeddings/reranker clients) in-process; `remote` = thin network client to an external process.
  */
-export interface TargetAdapter {
+export interface ContextAdapter {
   getCapabilities(): Promise<Capabilities>;
   getConfigShow(): Promise<{ effective: Config; sources: Record<string, string>; active_revision: string }>;
   getConfigGet(key: string): Promise<unknown>;
@@ -74,11 +74,11 @@ export function isLoopbackHost(hostname: string): boolean {
   );
 }
 
-export class LocalAdapter implements TargetAdapter {
+export class LocalAdapter implements ContextAdapter {
   private configPath: string;
   private clients?: Clients;
 
-  constructor(opts?: TargetAdapterOptions) {
+  constructor(opts?: ContextAdapterOptions) {
     this.configPath = resolveConfigPath(opts?.configPath);
     this.clients = opts?.clients;
   }
@@ -132,7 +132,7 @@ export class LocalAdapter implements TargetAdapter {
     return setDottedKey(key, rawValStr, {
       configPath: this.configPath,
       dryRun: opts?.dryRun,
-      targetName: "local",
+      contextName: "local",
     });
   }
 
@@ -210,12 +210,12 @@ export class LocalAdapter implements TargetAdapter {
   }
 }
 
-export class RemoteAdapter implements TargetAdapter {
+export class RemoteAdapter implements ContextAdapter {
   private serverUrl: string;
   private tokenEnv?: string;
   private allowInsecure: boolean;
 
-  constructor(target: { server: string; token_env?: string }, opts?: TargetAdapterOptions) {
+  constructor(target: { server: string; token_env?: string }, opts?: ContextAdapterOptions) {
     this.serverUrl = target.server.replace(/\/$/, "");
     this.tokenEnv = target.token_env;
     this.allowInsecure = opts?.allowInsecure ?? false;
@@ -429,10 +429,10 @@ export class RemoteAdapter implements TargetAdapter {
   }
 }
 
-export function createTargetAdapter(target: ResolvedContext, opts?: TargetAdapterOptions): TargetAdapter {
-  if (target.type === "local") {
+export function createContextAdapter(context: ResolvedContext, opts?: ContextAdapterOptions): ContextAdapter {
+  if (context.type === "local") {
     return new LocalAdapter(opts);
   } else {
-    return new RemoteAdapter({ server: target.server, token_env: target.token_env }, opts);
+    return new RemoteAdapter({ server: context.server, token_env: context.token_env }, opts);
   }
 }

package/src/cli.ts

@@ -17,7 +17,7 @@ import { type StatsResponse } from "./stats";
 import { scanVault } from "./vault";
 
 import { resolveContext, type ResolvedContext } from "./context";
-import { createTargetAdapter, isLoopbackHost, type TargetAdapter } from "./adapters";
+import { createContextAdapter, isLoopbackHost, type ContextAdapter } from "./adapters";
 import {
   emitSuccess,
   CliError,
@@ -28,6 +28,7 @@ import {
   warn,
 } from "./output";
 import { generateCompletions, type ShellType } from "./completions";
+import { SUPPORTED_AGENT_IDS } from "./init-agents";
 import { runAudit } from "./commands/audit";
 import { handleConfigCommand } from "./commands/config";
 import { handleContextCommand } from "./commands/context";
@@ -45,7 +46,7 @@ import { runTarget } from "./commands/target";
 import { runSync } from "./commands/sync";
 import { runInit } from "./commands/init";
 
-const KNOWN_COMMANDS = [
+export const KNOWN_COMMANDS = [
   "context",
   "config",
   "completions",
@@ -69,39 +70,120 @@ const KNOWN_COMMANDS = [
   "local-vault",
 ];
 
-const LOCAL_ONLY_COMMANDS = new Set([
-  "install",
-  "update",
-  "outdated",
-  "sync",
-  "core",
-  "project",
-  "target",
-  "local-vault",
-  "index",
-  "models",
-  "scan",
-  "init",
-  "serve",
-]);
+/**
+ * Declared context support for every command in KNOWN_COMMANDS — the single
+ * source of truth getLocalOnlyCommand() enforces against. A command missing
+ * from here, or misclassified, is a bug: see tests/cli-context-support.test.ts,
+ * which fails the build rather than letting a command silently drift out of
+ * sync the way `config init` did (it was never rejected for a remote context,
+ * nor actually remote-capable — it just silently ran local logic that choked
+ * on an unrecognized --context/--server flag with a confusing error).
+ *
+ * - "local-only": operates on this machine's vault/filesystem/agents only;
+ *   a remote context is rejected outright.
+ * - "remote-capable": routed through ContextAdapter — same command, backed by
+ *   LocalAdapter or RemoteAdapter depending on the resolved context.
+ * - "context-agnostic": the resolved context isn't used to decide behavior at
+ *   all (context management is inherently local; completions never touch
+ *   vault/server state).
+ *
+ * Subcommand-level exceptions within an otherwise-classified command (e.g.
+ * `config init`, which bootstraps *this machine's* config file and so is
+ * local-only despite `config` overall being remote-capable) are handled in
+ * getLocalOnlyCommand() itself, not in this top-level map.
+ */
+export type CommandContextSupport = "local-only" | "remote-capable" | "context-agnostic";
+
+export const COMMAND_CONTEXT_SUPPORT: Record<string, CommandContextSupport> = {
+  context: "context-agnostic",
+  config: "remote-capable",
+  completions: "context-agnostic",
+  serve: "local-only",
+  index: "local-only",
+  sync: "local-only",
+  init: "local-only",
+  project: "local-only",
+  target: "local-only",
+  core: "local-only",
+  report: "remote-capable",
+  audit: "remote-capable",
+  scan: "local-only",
+  install: "local-only",
+  outdated: "local-only",
+  update: "local-only",
+  eval: "remote-capable",
+  doctor: "remote-capable",
+  models: "local-only",
+  skill: "local-only",
+  "local-vault": "local-only",
+};
 
-function getLocalOnlyCommand(command: string, subCommand: string): string | null {
-  if (LOCAL_ONLY_COMMANDS.has(command)) {
-    return command;
-  }
+const LOCAL_ONLY_COMMANDS = new Set(
+  Object.entries(COMMAND_CONTEXT_SUPPORT)
+    .filter(([, support]) => support === "local-only")
+    .map(([command]) => command),
+);
+
+export function getLocalOnlyCommand(command: string, subCommand: string): string | null {
   if (command === "skill" && (subCommand === "which" || !subCommand)) {
     return "skill which";
   }
+  if (command === "config" && subCommand === "init") {
+    return "config init";
+  }
+  if (LOCAL_ONLY_COMMANDS.has(command)) {
+    return command;
+  }
   return null;
 }
 
+/**
+ * Why a local-only command can't take a remote context, keyed by the exact
+ * string getLocalOnlyCommand() returns. Drives the guidance sentence
+ * remoteContextUnsupported() appends, so the rejection points somewhere
+ * useful instead of just saying no.
+ */
+type LocalOnlyReason = "vault-content" | "native-delivery" | "local-runtime" | "local-config";
+
+const LOCAL_ONLY_REASON: Record<string, LocalOnlyReason> = {
+  install: "vault-content",
+  update: "vault-content",
+  outdated: "vault-content",
+  scan: "vault-content",
+  init: "native-delivery",
+  sync: "native-delivery",
+  target: "native-delivery",
+  core: "native-delivery",
+  project: "native-delivery",
+  "local-vault": "native-delivery",
+  "skill which": "native-delivery",
+  serve: "local-runtime",
+  models: "local-runtime",
+  index: "local-runtime",
+  "config init": "local-config",
+};
+
+const LOCAL_ONLY_GUIDANCE: Record<LocalOnlyReason, string> = {
+  "vault-content":
+    "To change a remote deployment's vault contents, update its git-backed source and redeploy or pull on that host — skillmux doesn't replicate vault checkouts over the network.",
+  "native-delivery":
+    "This manages skill delivery into agent directories on the machine you run it from; there's no remote equivalent — run it on the machine that owns those directories.",
+  "local-runtime":
+    "This operates on the local runtime process on the machine you run it from.",
+  "local-config":
+    "This bootstraps this machine's own config file. To inspect or change a remote deployment's configuration, use \"skillmux config show/set --context <name>\" instead.",
+};
+
 function remoteContextUnsupported(rejectedCommand: string): CliError {
+  const reason = LOCAL_ONLY_REASON[rejectedCommand];
+  const guidance = reason ? ` ${LOCAL_ONLY_GUIDANCE[reason]}` : "";
   return new CliError(
-    `\`${rejectedCommand}\` operates on the local vault only; --context/--server isn't supported here`,
+    `\`${rejectedCommand}\` operates on the local vault only; --context/--server isn't supported here.${guidance}`,
     2,
     "REMOTE_CONTEXT_UNSUPPORTED",
     {
       rejected_command: rejectedCommand,
+      ...(reason ? { reason } : {}),
     },
   );
 }
@@ -196,14 +278,14 @@ async function main() {
     else if (arg === "--server") flagServer = rawArgv[++i];
   }
 
-  let resolvedTarget: ResolvedContext = { type: "local", name: "local" };
+  let resolvedContext: ResolvedContext = { type: "local", name: "local" };
 
   if (
     process.env.RUNNING_IN_DOCKER === "true" &&
     isDockerHostManagementCommand(command, subCommand)
   ) {
     await handleError(containerCommandUnsupported(command, subCommand), {
-      target: resolvedTarget,
+      context: resolvedContext,
       isJson,
       isVerbose,
     });
@@ -218,38 +300,38 @@ async function main() {
   }
 
   try {
-    resolvedTarget = await resolveContext({
+    resolvedContext = await resolveContext({
       context: flagContext,
       server: flagServer,
     });
   } catch (err: any) {
-    await handleError(err, { target: resolvedTarget, isJson, isVerbose });
+    await handleError(err, { context: resolvedContext, isJson, isVerbose });
     return;
   }
 
   const localOnlyCommand = getLocalOnlyCommand(command, subCommand);
-  if (localOnlyCommand && resolvedTarget.type === "remote") {
+  if (localOnlyCommand && resolvedContext.type === "remote") {
     await handleError(remoteContextUnsupported(localOnlyCommand), {
-      target: resolvedTarget,
+      context: resolvedContext,
       isJson,
       isVerbose,
     });
     return;
   }
 
-  const adapter = createTargetAdapter(resolvedTarget, { allowInsecure });
+  const adapter = createContextAdapter(resolvedContext, { allowInsecure });
 
   try {
     switch (command) {
       case "context":
         await handleContextCommand(subCommand, commandArgs, {
-          target: resolvedTarget,
+          context: resolvedContext,
           isJson,
         });
         break;
       case "config":
         await handleConfigCommand(adapter, subCommand, commandArgs, {
-          target: resolvedTarget,
+          context: resolvedContext,
           isJson,
           dryRun: isDryRun,
         });
@@ -308,7 +390,7 @@ async function main() {
       case "report":
         await runReport(rawArgv.slice(1), {
           isJson,
-          target: resolvedTarget,
+          context: resolvedContext,
           allowInsecure,
           adapter,
         });
@@ -317,7 +399,7 @@ async function main() {
         await runAudit(subCommand, commandArgs, {
           isJson,
           dryRun: isDryRun,
-          target: resolvedTarget,
+          context: resolvedContext,
           adapter,
         });
         break;
@@ -339,11 +421,16 @@ async function main() {
         } else if (subCommand === "") {
           await runEval({ isJson, adapter });
         } else {
-          throw new Error(`usage: skillmux eval [promote --since <window> [--target <path>] [--dry-run] [--yes] [--json]]`);
+          throw new Error(`usage: skillmux eval [promote --since <window> [--out <path>] [--dry-run] [--yes] [--json]]`);
         }
         break;
       case "doctor":
-        await runDoctor({ isJson, target: resolvedTarget, adapter });
+        await runDoctor({
+          isJson,
+          context: resolvedContext,
+          adapter,
+          args: rawArgv.slice(1),
+        });
         break;
       case "which":
         throw new Error(
@@ -375,7 +462,7 @@ async function main() {
       }
     }
   } catch (err: any) {
-    await handleError(err, { target: resolvedTarget, isJson, isVerbose });
+    await handleError(err, { context: resolvedContext, isJson, isVerbose });
   }
 }
 
@@ -390,7 +477,7 @@ async function handleCompletionsCommand(shell: string) {
 
 async function handleError(
   err: any,
-  opts: { target: ResolvedContext; isJson: boolean; isVerbose: boolean },
+  opts: { context: ResolvedContext; isJson: boolean; isVerbose: boolean },
 ) {
   const code = mapExitCode(err);
   process.exitCode = code;
@@ -411,7 +498,7 @@ async function handleError(
   if (opts.isJson) {
     const env = formatJsonEnvelope({
       ok: false,
-      target: opts.target,
+      context: opts.context,
       error: {
         code: err instanceof CliError ? err.code : `EXIT_${code}`,
         message: msg,
@@ -456,6 +543,11 @@ usage:
   skillmux config diff
   skillmux config status
 
+config init bootstraps this machine's config file from a populated vault. It
+is not a prerequisite for anything: "skillmux init --vault <path>" runs the
+same bootstrap when no config exists, so reach for config init only when you
+are setting up the config without the guided init.
+
 Accepts --context <name> / --server <url> to target a remote deployment.`,
 
   completions: `completions: generate a shell completion script
@@ -476,45 +568,97 @@ alongside a stdio transport without opening the full HTTP surface.`,
 usage:
   skillmux index`,
 
-  sync: `sync: apply the manifest to native client target directories
+  sync: `sync: apply the manifest to native agent target directories
 
 usage:
-  skillmux sync [--dry-run] [--restore-monolith] [--install-hook] [--yes] [--json]`,
+  skillmux sync [--dry-run] [--restore-monolith] [--install-hook] [--yes] [--json]
+
+--dry-run prints what would change without writing. --yes approves creating
+a target directory that does not exist yet; without it, an unseen directory
+is skipped rather than created.
+
+--install-hook installs a git post-merge hook in the vault checkout so a
+"git pull" re-syncs the targets automatically.
+
+--restore-monolith undoes managed-pin delivery for a target: instead of
+individual pinned skills, the target directory is replaced by a single
+symlink to the whole vault. It refuses to touch a directory skillmux does
+not own, one carrying a local_vault marker, or one whose marker points at a
+different vault.`,
 
   init: `init: guided setup for native skill management
 
 usage:
-  skillmux init [--client <name>...] [--target <name>...] [--dir <dir>]
-                [--vault <path>] [--core <skill_id>...]
-                [--migrate-full-vault] [--no-instructions] [--no-sync]
+  skillmux init [--agent <name>...] [--vault <path>] [--core <skill_id>...]
+                [--migrate-full-vault] [--show-mcp-setup] [--register-mcp]
+                [--no-instructions] [--no-sync]
                 [--interactive|--yes|--dry-run] [--json]
 
-clients: claude-code, codex, gemini-cli, opencode, github-copilot, windsurf,
-         antigravity, goose, hermes, skillmux-mcp
-targets: agent-skills, claude-code, codex, custom`,
+agents: ${SUPPORTED_AGENT_IDS.join(", ")}
+
+Native pins and MCP are independent — skip both of the flags below for
+native-only setup, and init writes no instruction files (the managed
+block only teaches resolve_skill/fetch_skill, which are MCP tools).
+--show-mcp-setup prints the MCP registration snippet to copy in yourself,
+for any agent, and also writes the instruction block for every selected
+agent. --register-mcp instead runs that agent's own CLI to register
+skillmux automatically, but only for claude-code and codex (the only
+agents with a verified registration command), and writes the instruction
+block just for those; interactively, init asks about this only when
+you've selected one of those two. --no-instructions forces instruction
+writes off even when an MCP flag is set. A tool not in the agents list
+above isn't supported by init yet — add it to SUPPORTED_AGENT_IDS rather
+than guessing a directory. To adopt an arbitrary existing directory
+directly, use "skillmux target add <name> --dir <dir>" instead of init.`,
 
   project: `project: manage project-scoped skill pins and sync groups
 
 usage:
   skillmux project init [path] [--name <group>] [--skill <skill_id>...]
-                [--client <name>...] [--target <name>...] [--no-sync]
-                [--interactive|--yes|--dry-run] [--json]
+                [--agent <name>...] [--target <name>...] [--register-mcp]
+                [--no-sync] [--interactive|--yes|--dry-run] [--json]
   skillmux project list
   skillmux project show <group>
   skillmux project add-path <group> [path] --yes
   skillmux project remove-path <group> [path] --yes
   skillmux project pin <group> <skill_id>... --yes
   skillmux project unpin <group> <skill_id>... --yes
-  skillmux project attach <group> (--client <id>... | --target <name>...) --yes
-  skillmux project detach <group> (--client <id>... | --target <name>...) --yes`,
+  skillmux project attach <group> (--agent <id>... | --target <name>...) --yes
+  skillmux project detach <group> (--agent <id>... | --target <name>...) --yes
+
+--agent and --target both name sync targets, and either may be repeated.
+--target <name> names a target directly, including a custom one created by
+"skillmux target add". --agent <id> is shorthand for "whatever target that
+agent maps to", resolved from the targets init already configured, so it
+fails if that agent was never set up or maps to no target at all (goose and
+hermes use full-vault delivery and have none). Several agents can share one
+target, so attaching two agents that map to the same directory attaches it
+once.
+
+--register-mcp is the project-local counterpart to "skillmux init
+--register-mcp": only for claude-code (the only agent whose own CLI has a
+project MCP scope — codex's mcp add has no scope flag, so it's always
+global). It runs "claude mcp add -s project" for this project directory,
+which writes a committed .mcp.json shared with your team, and writes a
+project-root CLAUDE.md with the resolve_skill/fetch_skill discovery
+paragraph — same reasoning as init: no instruction file is written unless
+MCP is actually being registered.`,
 
   target: `target: manage native sync target directories
 
 usage:
   skillmux target list
   skillmux target show <name>
-  skillmux target add <name> --dir <dir> --yes
-  skillmux target remove <name> --yes`,
+  skillmux target add <name> [--dir <dir>] --yes
+  skillmux target remove <name> --yes
+
+--dir may be omitted when <name> is a built-in target with a deterministic
+path: agent-skills, claude-code, codex. Any other <name> requires --dir.
+
+A target is a directory, not a product. Several agents can map to the same
+one (opencode, github-copilot and windsurf all share agent-skills), which is
+why "skillmux project attach" accepts --agent as shorthand for the target
+that agent resolves to.`,
 
   core: `core: pin or unpin core-tier skills
 
@@ -537,28 +681,66 @@ Accepts --context <name> / --server <url> to prune a remote deployment's audit d
   scan: `scan: check the vault for install-time or integrity issues
 
 usage:
-  skillmux scan [path] [--format text|json] [--fail-on low|medium|high] [--json]`,
+  skillmux scan [path] [--fail-on low|medium|high|none] [--json]
+
+Scans [path], or the configured vault when omitted. Reporting only: it
+exits 0 whatever it finds unless --fail-on names a severity, which is why
+it has no default threshold while install and update default to high.
+
+--format text|json is deprecated: it emits JSON outside the standard
+envelope. Use --json instead; --format will be removed in a future 1.x
+release.`,
 
   install: `install: install a skill from a git source
 
 usage:
-  skillmux install <repo>[/path] [--force] [--fail-on low|medium|high] [--dry-run] [--allow-local-source] [--json]`,
+  skillmux install <repo>[/path] [--yes] [--force] [--fail-on low|medium|high|none] [--dry-run] [--allow-local-source] [--json]
+
+--yes approves writing the skill into the vault. Without it an interactive
+run asks first, and a non-interactive one (no TTY, or --json) fails rather
+than installing unattended, matching "skillmux update".
+
+The fetched skill is scanned before it is written to the vault. --fail-on
+sets the severity that aborts the install and defaults to high; pass
+--fail-on none to install despite findings. A lower threshold is stricter:
+low aborts on low, medium and high.
+
+--force overwrites a skill that already exists in the vault instead of
+refusing. --dry-run reports where the skill would land without writing.
+--allow-local-source permits a file:// or local path source, which is
+otherwise rejected.`,
 
   outdated: `outdated: list installed skills with a newer upstream version
 
 usage:
-  skillmux outdated [--allow-local-source] [--json]`,
+  skillmux outdated [--allow-local-source] [--json]
+
+Read-only: it reports what "skillmux update" would change and writes
+nothing. --allow-local-source includes skills installed from a local or
+file:// source, which are skipped by default because their upstream is a
+path on this machine rather than a shared remote.`,
 
   update: `update: update one or all skills to their latest source version
 
 usage:
-  skillmux update [skill-id] [--yes] [--dry-run] [--force] [--allow-local-source] [--fail-on low|medium|high] [--json]`,
+  skillmux update [skill-id] [--yes] [--dry-run] [--force] [--allow-local-source] [--fail-on low|medium|high|none] [--json]
+
+Updates every installed skill, or just <skill-id>. --yes is required to
+apply non-interactively. --dry-run prints the plan without writing.
+
+--fail-on works exactly as it does for install and defaults to high, so a
+skill whose new version carries a high-severity finding is skipped rather
+than updated; --fail-on none restores the old permissive behavior.
+
+--force updates a skill whose local content no longer matches the hash
+recorded at install time, which otherwise blocks the update to avoid
+discarding local edits. --allow-local-source permits local/file:// sources.`,
 
   eval: `eval: run retrieval evaluation against the holdout set
 
 usage:
   skillmux eval [--json]
-  skillmux eval promote --since <window> [--target <path>] [--dry-run] [--yes] [--json]
+  skillmux eval promote --since <window> [--out <path>] [--dry-run] [--yes] [--json]
 
 Accepts --context <name> / --server <url> to evaluate a remote deployment.`,
 
@@ -613,32 +795,33 @@ See docs/deployment.md for server deployment examples.`);
   console.log(`usage: skillmux <command> [options]
 
 Setup:
-  skillmux config init --vault <path> --yes
-  skillmux init [--client <name>...] [--target <name>...] [--dir <dir>]
-                [--vault <path>] [--core <skill_id>...]
-                [--migrate-full-vault] [--no-instructions] [--no-sync]
+  skillmux init [--agent <name>...] [--vault <path>] [--core <skill_id>...]
+                [--migrate-full-vault] [--show-mcp-setup] [--register-mcp]
+                [--no-instructions] [--no-sync]
                 [--interactive|--yes|--dry-run] [--json]
   skillmux project init [path] [--name <group>] [--skill <skill_id>...]
-                [--client <name>...] [--target <name>...] [--no-sync]
+                [--agent <name>...] [--target <name>...] [--no-sync]
                 [--interactive|--yes|--dry-run] [--json]
   skillmux project <list|show|add-path|remove-path|pin|unpin|attach|detach>
-  skillmux target <list|show|add|remove>
+  skillmux target <list|show|add|remove>  (a target is a directory sync writes into)
   skillmux core <pin|unpin> <skill_id>... [--yes] [--dry-run] [--json]
   skillmux skill which <skill_id>  (local vault shadow resolution; unrelated to MCP routing)
+  skillmux config init --vault <path> --yes
+                (bootstraps this machine's config on its own; not a
+                prerequisite, since "skillmux init --vault" does the same)
 
-Init clients:
-  claude-code, codex, gemini-cli, opencode, github-copilot, windsurf,
-  antigravity, goose, hermes, skillmux-mcp
-
-Init targets:
-  agent-skills, claude-code, codex, custom
+Init agents:
+  ${SUPPORTED_AGENT_IDS.join(", ")}
+  ("skillmux init --show-mcp-setup" also prints the MCP registration
+  snippet, independent of which agents you select. A tool not in this
+  list isn't supported by init yet — see "skillmux init --help".)
 
 Operations:
   skillmux report [--context <name> | --server <url> | --db <path>] --since <window> [--json]
   skillmux audit prune [--older-than <window>] [--dry-run] [--yes] [--json]
-  skillmux eval promote --since <window> [--target <path>] [--dry-run] [--yes] [--json]
+  skillmux eval promote --since <window> [--out <path>] [--dry-run] [--yes] [--json]
   skillmux outdated [--allow-local-source] [--json]
-  skillmux update [skill-id] [--yes] [--dry-run] [--force] [--allow-local-source] [--fail-on low|medium|high] [--json]
+  skillmux update [skill-id] [--yes] [--dry-run] [--force] [--allow-local-source] [--fail-on low|medium|high|none] [--json]
 
 Commands:
   serve, index, sync, init, project, target, core, report, audit, scan, install, outdated, update,
@@ -713,7 +896,7 @@ async function runIndex(): Promise<void> {
   }
 }
 
-async function runEval(options: { isJson: boolean; adapter: TargetAdapter }): Promise<void> {
+async function runEval(options: { isJson: boolean; adapter: ContextAdapter }): Promise<void> {
   const config = await loadConfig();
   configure({ config, clients: createClients(config) });
 

package/src/commands/audit.ts

@@ -1,13 +1,13 @@
 import { emitSuccess } from "../output";
 import { confirmIfNeeded } from "./shared";
-import type { TargetAdapter } from "../adapters";
+import type { ContextAdapter } from "../adapters";
 import type { ResolvedContext } from "../context";
 import { isGlobalFlag, isGlobalFlagWithValue } from "../global-flags";
 
 export async function runAudit(
   subCommand: string,
   args: string[],
-  options: { isJson: boolean; dryRun: boolean; target: ResolvedContext; adapter: TargetAdapter },
+  options: { isJson: boolean; dryRun: boolean; context: ResolvedContext; adapter: ContextAdapter },
 ): Promise<void> {
   if (subCommand !== "prune") {
     throw new Error("usage: skillmux audit prune [--older-than <window>] [--dry-run] [--yes] [--json]");