@owlmeans/agent-skills 0.1.15 → 0.1.16

package/src/args.ts

@@ -2,8 +2,10 @@ export interface CliArgs {
   dir: string
   yes: boolean
   only: string[]
-  claudeOnly: boolean
-  copilotOnly: boolean
+  /** @deprecated no-op — skills install to `.agents/skills/` for every agent. */
+  claudeOnly?: boolean
+  /** @deprecated no-op — skills install to `.agents/skills/` for every agent. */
+  copilotOnly?: boolean
   extras: boolean
   force: boolean
   dryRun: boolean
@@ -12,14 +14,16 @@ export interface CliArgs {
 
 const HELP = `owlmeans-agent-skills — install embedded @owlmeans/* agent guidance
 
+Skills are written to .agents/skills/<name>/SKILL.md — the Agent Skills standard
+location read by Copilot, Codex and other agents. Projects with a .claude/
+directory also get the per-skill symlinks Claude Code needs.
+
 Usage: npx @owlmeans/agent-skills [options]
 
 Options:
   --dir <path>        target project directory (default: cwd)
   --yes, -y           skip interactive confirmation
   --only <pkg,...>    comma-separated @owlmeans/* package names to install from
-  --claude-only       install only Claude Code skills
-  --copilot-only      install only Copilot instructions
   --extras            include extras bundled with the installer (default: on)
   --no-extras         skip installer-bundled extras
   --force             overwrite locally-edited files (no AUTO-GENERATED banner)
@@ -27,14 +31,15 @@ Options:
   --help, -h          show this help
 `
 
+const OBSOLETE_TOOL_FLAG =
+  'note: %s is obsolete — skills install to .agents/skills/ for every agent.\n'
+
 export const parseArgs = (argv: string[]): CliArgs | null => {
   const args = argv.slice(2) // strip node + script
   const result: CliArgs = {
     dir: process.cwd(),
     yes: false,
     only: [],
-    claudeOnly: false,
-    copilotOnly: false,
     extras: true,
     force: false,
     dryRun: false,
@@ -60,10 +65,8 @@ export const parseArgs = (argv: string[]): CliArgs | null => {
         result.dryRun = true
         break
       case '--claude-only':
-        result.claudeOnly = true
-        break
       case '--copilot-only':
-        result.copilotOnly = true
+        process.stderr.write(OBSOLETE_TOOL_FLAG.replace('%s', a))
         break
       case '--extras':
         result.extras = true

package/src/discover.ts

@@ -211,17 +211,20 @@ export interface DiscoverOptions {
   extras?: boolean
   /** Restrict to entries from these package names. */
   only?: string[]
-  /** Install only skills. */
-  claudeOnly?: boolean
-  /** Install only instructions. */
-  copilotOnly?: boolean
 }
 
-/** Collect all DiscoveredEntries, deduplicated by (kind, name). */
+/**
+ * Collect all DiscoveredEntries, deduplicated by name.
+ *
+ * Only `kind: 'skill'` entries are installed. Packages published before schema v2
+ * also carry `kind: 'instruction'` twins of the same knowledge (the Copilot format
+ * that predates the Agent Skills standard); they are dropped here so a mixed
+ * node_modules never installs both halves.
+ */
 export const discover = (targetDir: string, opts: DiscoverOptions = {}): DiscoveredEntry[] => {
-  const { extras = true, only, claudeOnly = false, copilotOnly = false } = opts
+  const { extras = true, only } = opts
 
-  const allEntries = scanNodeModules(targetDir)
+  const allEntries = scanNodeModules(targetDir).filter(e => e.kind === 'skill')
 
   if (extras) {
     // Get installer's own package name+version from its package.json
@@ -235,13 +238,13 @@ export const discover = (targetDir: string, opts: DiscoverOptions = {}): Discove
         if (pkg.version) selfVersion = pkg.version
       }
     } catch { /* use defaults */ }
-    allEntries.push(...scanSelfExtras(selfName, selfVersion))
+    allEntries.push(...scanSelfExtras(selfName, selfVersion).filter(e => e.kind === 'skill'))
   }
 
-  // Deduplicate by (kind, name): prefer highest semver version
+  // Deduplicate by name: prefer highest semver version
   const byKey = new Map<string, DiscoveredEntry>()
   for (const e of allEntries) {
-    const key = `${e.kind}:${e.name}`
+    const key = e.name
     const existing = byKey.get(key)
     if (existing == null) {
       byKey.set(key, e)
@@ -257,10 +260,6 @@ export const discover = (targetDir: string, opts: DiscoverOptions = {}): Discove
     result = result.filter(e => only.some(n => matchPkgName(n, e.packageName)))
   }
 
-  // Apply tool filters
-  if (claudeOnly) result = result.filter(e => e.kind === 'skill')
-  if (copilotOnly) result = result.filter(e => e.kind === 'instruction')
-
   return result
 }
 

package/src/llm/index.ts

@@ -0,0 +1,13 @@
+/**
+ * The LLM-facing half of this package: a prompt plugin that turns a mention of an
+ * `@owlmeans/*` package in a prompt into that package's published skills.
+ *
+ * Deliberately NOT re-exported from the package index. The installer CLI has no runtime
+ * dependencies and must keep it that way; this entry point resolves `@owlmeans/llm` and
+ * `@owlmeans/llm-common`, which only a consumer already using the LLM layer will have.
+ */
+
+export * from './types.js'
+export * from './manifest.js'
+export * from './resolve.js'
+export * from './plugin.js'

package/src/llm/manifest.ts

@@ -0,0 +1,75 @@
+import { DEFAULT_SKILL_ORDER, PromptBlock } from '@owlmeans/llm-common'
+import type { SkillDefinition } from '@owlmeans/llm-common'
+import type { Manifest, ManifestEntry } from '../discover.js'
+
+/** `@owlmeans/foo` → `foo`; the repo lays packages out under their unscoped name. */
+export const unscoped = (packageName: string): string =>
+  packageName.slice(packageName.indexOf('/') + 1)
+
+export const parseManifest = (raw: string): Manifest | null => {
+  try {
+    const manifest = JSON.parse(raw) as Manifest
+    if (typeof manifest.schemaVersion !== 'number' || !Array.isArray(manifest.entries)) {
+      return null
+    }
+    return manifest
+  } catch {
+    return null
+  }
+}
+
+const BANNER = /^<!--\s*AUTO-GENERATED[^>]*-->\s*/
+
+/**
+ * Strip the YAML frontmatter and the generated-file banner from an embedded SKILL.md.
+ *
+ * Both are installer bookkeeping — `name`, `description`, `applyTo`, "do not edit". Sent
+ * to a model they are pure noise in the most expensive part of the prompt, and the
+ * "do not edit" line actively misleads it about what it is being shown.
+ */
+export const stripMeta = (content: string): string => {
+  let body = content.replace(/^/, '')
+  if (body.startsWith('---')) {
+    const end = body.indexOf('\n---', 3)
+    if (end >= 0) {
+      const after = body.indexOf('\n', end + 1)
+      body = after >= 0 ? body.slice(after + 1) : ''
+    }
+  }
+
+  return body.replace(BANNER, '').trim()
+}
+
+/**
+ * Skill entries worth loading, in a deterministic order.
+ *
+ * Instruction entries appear only in manifests published before schema v2 and are
+ * dropped: they are the Copilot twin of the same knowledge, so including both would
+ * double the token cost of every package for no added information.
+ */
+export const skillEntries = (
+  manifest: Manifest,
+  categories: readonly string[],
+): ManifestEntry[] =>
+  manifest.entries
+    .filter(entry => entry.kind === 'skill' && categories.includes(entry.category))
+    .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+
+/**
+ * Turn one embedded skill file into a definition bound to the `Packages` block.
+ *
+ * The alias is namespaced by package so two packages documenting the same concept cannot
+ * collide in the registry, and the order weight is pushed past the default so package
+ * knowledge always renders after whatever the host declared itself.
+ */
+export const toSkill = (
+  packageName: string,
+  entry: ManifestEntry,
+  body: string,
+): SkillDefinition => ({
+  alias: `${packageName}#${entry.name}`,
+  title: `${packageName} — ${entry.name}`,
+  body,
+  block: PromptBlock.Packages,
+  order: DEFAULT_SKILL_ORDER + 1,
+})

package/src/llm/plugin.ts

@@ -0,0 +1,133 @@
+import { PromptBlock, resolveFileProvider } from '@owlmeans/llm-common'
+import { renderSkill } from '@owlmeans/llm/prompt'
+import type { LlmPromptPlugin, PromptContext } from '@owlmeans/llm'
+import { loadPackageSkills } from './resolve.js'
+import { OWLMEANS_SCOPE } from './types.js'
+import type { PackageSkills, PackageSkillsOptions } from './types.js'
+
+export const PACKAGE_SKILLS_PLUGIN = 'owlmeans-packages'
+
+const DEFAULT_MAX_PACKAGES = 5
+const DEFAULT_CATEGORIES = ['package-specific', 'multi-package'] as const
+
+const escape = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+const textOf = (content: unknown): string => {
+  if (typeof content === 'string') {
+    return content
+  }
+  if (Array.isArray(content)) {
+    return content
+      .map(part => {
+        const text = (part as { text?: unknown }).text
+        return typeof text === 'string' ? text : ''
+      })
+      .join('\n')
+  }
+
+  return ''
+}
+
+/**
+ * A prompt plugin that notices which `@owlmeans/*` packages a request talks about and
+ * loads their published skills into the system prompt.
+ *
+ * Everything the package documents is loaded — there is no relevance filtering, by
+ * design: choosing a subset would need a judgement the model is better placed to make
+ * than a regex, and a partial answer about an API is worse than none.
+ *
+ * The result lands in the `Packages` block, which sits behind its own cache breakpoint.
+ * That is the whole reason the block exists: what a request mentions changes call to
+ * call, and it must not shift a single byte of the role and skills every call shares.
+ */
+export const owlmeansPackagesPlugin = (options: PackageSkillsOptions = {}): LlmPromptPlugin => {
+  const scopes = options.scopes ?? [OWLMEANS_SCOPE]
+  // No dots and no trailing hyphen, so `@owlmeans/llm.` yields `@owlmeans/llm` — prose
+  // and code both end package names with punctuation.
+  const pattern = new RegExp(
+    `(?:${scopes.map(escape).join('|')})\\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?`, 'g'
+  )
+  const exclude = options.exclude ?? []
+  const maxPackages = options.maxPackages ?? DEFAULT_MAX_PACKAGES
+  const categories = options.categories ?? [...DEFAULT_CATEGORIES]
+
+  /**
+   * Resolved packages, negatives included. Without caching the misses, a prompt that
+   * mentions a package which does not publish skills would hit GitHub on every call.
+   */
+  const cache = new Map<string, Promise<PackageSkills | null>>()
+
+  /**
+   * Per-provider caches, keyed by the provider INSTANCE.
+   *
+   * A host's file provider is usually per-project (a sandbox, a slot, one checkout), so
+   * two executions can resolve the same package name to different content. Sharing one
+   * cache across them would serve project A's skills to project B. A `WeakMap` keeps the
+   * entries alive exactly as long as the provider is.
+   */
+  const perProvider = new WeakMap<object, Map<string, Promise<PackageSkills | null>>>()
+
+  const load = (packageName: string, ctx: PromptContext): Promise<PackageSkills | null> => {
+    // The context's provider is the specific one — it sees the project this call is
+    // actually about. The constructor option is the fallback for a host that wires one
+    // globally. Without this, a per-execution provider was never consulted at all.
+    const provider = resolveFileProvider(ctx.files) ?? resolveFileProvider(options.files)
+    const store = provider != null
+      ? perProvider.get(provider) ?? (() => {
+        const fresh = new Map<string, Promise<PackageSkills | null>>()
+        perProvider.set(provider, fresh)
+        return fresh
+      })()
+      : cache
+
+    const pending = store.get(packageName)
+    if (pending != null) {
+      return pending
+    }
+    const promise = loadPackageSkills(packageName, { ...options, files: provider }, categories)
+    store.set(packageName, promise)
+
+    return promise
+  }
+
+  const detect = (ctx: PromptContext): string[] => {
+    const found = new Set<string>()
+    for (const message of ctx.messages) {
+      const text = textOf((message as { content?: unknown }).content)
+      if (text === '') {
+        continue
+      }
+      for (const match of text.matchAll(pattern)) {
+        found.add(match[0])
+      }
+    }
+
+    // Alphabetical, not first-seen: two prompts that mention the same packages in a
+    // different order must still produce the same bytes.
+    return [...found]
+      .filter(name => !exclude.includes(name))
+      .sort()
+      .slice(0, maxPackages)
+  }
+
+  return {
+    alias: PACKAGE_SKILLS_PLUGIN,
+    order: 50,
+
+    inspect: async ctx => {
+      const names = detect(ctx)
+      if (names.length === 0) {
+        return
+      }
+      const resolved = await Promise.all(names.map(name => load(name, ctx)))
+      for (const found of resolved) {
+        if (found == null) {
+          continue
+        }
+        for (const skill of found.skills) {
+          ctx.add(PromptBlock.Packages, renderSkill(skill))
+        }
+      }
+    },
+  }
+}

package/src/llm/resolve.ts

@@ -0,0 +1,180 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve as resolvePath } from 'node:path'
+import { resolveFileProvider } from '@owlmeans/llm-common'
+import type { LlmFileProvider, SkillDefinition } from '@owlmeans/llm-common'
+import { parseManifest, skillEntries, stripMeta, toSkill, unscoped } from './manifest.js'
+import type { PackageSkills, PackageSkillsOptions } from './types.js'
+
+const AGENT_META = 'agent-meta'
+const MANIFEST = 'manifest.json'
+const DEFAULT_REPO = 'owlmeans/common'
+const DEFAULT_REF = 'main'
+const DEFAULT_TIMEOUT = 5000
+
+/** Path of an embedded file relative to a project root, in the host's own terms. */
+const projectPath = (packageName: string, ...parts: string[]): string =>
+  ['node_modules', packageName, AGENT_META, ...parts].join('/')
+
+/**
+ * Source 1 — the host's own file access.
+ *
+ * Tried first because it is the only one that sees the project the model is actually
+ * working on: a sandbox, a remote workspace, a container this process cannot reach.
+ */
+const fromFiles = async (
+  packageName: string,
+  provider: LlmFileProvider,
+  categories: readonly string[],
+): Promise<PackageSkills | null> => {
+  const read = async (path: string): Promise<string> => {
+    try {
+      return await provider.readFile(path, true) ?? ''
+    } catch {
+      return ''
+    }
+  }
+
+  const manifest = parseManifest(await read(projectPath(packageName, MANIFEST)))
+  if (manifest == null) {
+    return null
+  }
+
+  const skills: SkillDefinition[] = []
+  for (const entry of skillEntries(manifest, categories)) {
+    const body = stripMeta(await read(projectPath(packageName, entry.file)))
+    if (body !== '') {
+      skills.push(toSkill(packageName, entry, body))
+    }
+  }
+
+  return skills.length > 0
+    ? { packageName, version: manifest.version, source: 'files', skills }
+    : null
+}
+
+/**
+ * Source 2 — an installed copy on this filesystem.
+ *
+ * Walks upward rather than assuming a layout: a hoisted install puts the package at the
+ * workspace root, a nested one puts it beside the consumer.
+ */
+const findLocalDir = (packageName: string, from: string): string | null => {
+  let current = resolvePath(from)
+  for (; ;) {
+    const candidate = join(current, 'node_modules', packageName, AGENT_META)
+    if (existsSync(join(candidate, MANIFEST))) {
+      return candidate
+    }
+    const parent = dirname(current)
+    if (parent === current) {
+      return null
+    }
+    current = parent
+  }
+}
+
+const fromLocal = (
+  packageName: string,
+  from: string,
+  categories: readonly string[],
+): PackageSkills | null => {
+  const dir = findLocalDir(packageName, from)
+  if (dir == null) {
+    return null
+  }
+  const read = (path: string): string => {
+    try {
+      return readFileSync(path, 'utf8')
+    } catch {
+      return ''
+    }
+  }
+
+  const manifest = parseManifest(read(join(dir, MANIFEST)))
+  if (manifest == null) {
+    return null
+  }
+
+  const skills: SkillDefinition[] = []
+  for (const entry of skillEntries(manifest, categories)) {
+    const body = stripMeta(read(join(dir, ...entry.file.split('/'))))
+    if (body !== '') {
+      skills.push(toSkill(packageName, entry, body))
+    }
+  }
+
+  return skills.length > 0
+    ? { packageName, version: manifest.version, source: 'local', skills }
+    : null
+}
+
+/**
+ * Source 3 — the canonical repository, for a package that is mentioned but not installed.
+ *
+ * It reads the EMBEDDED copies (`packages/<name>/agent-meta/`) rather than the canonical
+ * root ones: the embedded layout is uniform across packages and is exactly what the
+ * manifest describes, so one shape of URL works for every package.
+ */
+const fromRemote = async (
+  packageName: string,
+  options: PackageSkillsOptions,
+  categories: readonly string[],
+): Promise<PackageSkills | null> => {
+  if (options.fetch === false || typeof globalThis.fetch !== 'function') {
+    return null
+  }
+  const repo = options.repo ?? DEFAULT_REPO
+  const ref = options.ref ?? DEFAULT_REF
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT
+  const url = (file: string): string =>
+    `https://raw.githubusercontent.com/${repo}/${ref}/packages/${unscoped(packageName)}/${AGENT_META}/${file}`
+
+  // Every failure here is a miss, never a throw: a prompt plugin that breaks the call
+  // because GitHub was slow is worse than a prompt without one package's knowledge.
+  const get = async (file: string): Promise<string> => {
+    try {
+      const response = await fetch(url(file), { signal: AbortSignal.timeout(timeout) })
+      return response.ok ? await response.text() : ''
+    } catch {
+      return ''
+    }
+  }
+
+  const manifest = parseManifest(await get(MANIFEST))
+  if (manifest == null) {
+    return null
+  }
+
+  const entries = skillEntries(manifest, categories)
+  const bodies = await Promise.all(entries.map(async entry => stripMeta(await get(entry.file))))
+  const skills = entries
+    .map((entry, i) => ({ entry, body: bodies[i]! }))
+    .filter(({ body }) => body !== '')
+    .map(({ entry, body }) => toSkill(packageName, entry, body))
+
+  return skills.length > 0
+    ? { packageName, version: manifest.version, source: 'remote', skills }
+    : null
+}
+
+/** Try each source in order of trustworthiness and cost. */
+export const loadPackageSkills = async (
+  packageName: string,
+  options: PackageSkillsOptions,
+  categories: readonly string[],
+): Promise<PackageSkills | null> => {
+  const provider = resolveFileProvider(options.files)
+  if (provider != null) {
+    const found = await fromFiles(packageName, provider, categories)
+    if (found != null) {
+      return found
+    }
+  }
+
+  const local = fromLocal(packageName, options.dir ?? process.cwd(), categories)
+  if (local != null) {
+    return local
+  }
+
+  return fromRemote(packageName, options, categories)
+}

package/src/llm/types.ts

@@ -0,0 +1,71 @@
+import type { FileProviderRef, SkillDefinition } from '@owlmeans/llm-common'
+
+/** The default scope the plugin looks for in a prompt. */
+export const OWLMEANS_SCOPE = '@owlmeans'
+
+/** Where a package's skills came from — surfaced in logs, useful when a lookup surprises you. */
+export type SkillSource = 'files' | 'local' | 'remote'
+
+export interface PackageSkills {
+  packageName: string
+  version: string
+  source: SkillSource
+  skills: SkillDefinition[]
+}
+
+export interface PackageSkillsOptions {
+  /**
+   * Host file access, tried FIRST. It reads the consuming project's own tree, so it is
+   * the only path that works when the project lives somewhere this process cannot reach
+   * directly — a sandbox, a remote workspace, a container.
+   */
+  files?: FileProviderRef
+
+  /** Package scopes to detect. Defaults to `['@owlmeans']`. */
+  scopes?: string[]
+
+  /**
+   * Directory the local `node_modules` lookup starts from, walking upward.
+   * Defaults to `process.cwd()`.
+   */
+  dir?: string
+
+  /** GitHub `owner/repo` holding the canonical packages. Defaults to `owlmeans/common`. */
+  repo?: string
+
+  /**
+   * Git ref to read the embedded copies from. Defaults to `main`.
+   *
+   * The manifest deliberately carries no ref of its own — version-matching is guaranteed
+   * by shipping the copy inside the tarball, so there is nothing to pin against for a
+   * package that is NOT installed. Set this to a tag when reproducibility matters more
+   * than freshness.
+   */
+  ref?: string
+
+  /** Set to `false` to skip the GitHub fallback entirely (air-gapped runs). */
+  fetch?: boolean
+
+  /** Milliseconds before a remote lookup is abandoned. Defaults to 5000. */
+  timeout?: number
+
+  /**
+   * Packages to ignore — typically the ones whose skills the static `Skills` block
+   * already carries, so they are not paid for twice.
+   */
+  exclude?: string[]
+
+  /**
+   * Ceiling on how many mentioned packages are loaded into one prompt. Defaults to 5.
+   * A prompt that name-drops a dozen packages is usually not asking about all of them,
+   * and every one of them costs context.
+   */
+  maxPackages?: number
+
+  /**
+   * Manifest categories to include. Defaults to package knowledge only — `general`
+   * entries describe how an agent should behave, not what a package does, and belong in
+   * the host's own skill catalogue rather than in a package lookup.
+   */
+  categories?: Array<'package-specific' | 'multi-package' | 'general'>
+}

package/src/plan.ts

@@ -17,12 +17,14 @@ export interface InstallItem {
 /** The banner text injected by sync-agent-meta into every generated file. */
 export const AUTO_GENERATED_BANNER = '<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->'
 
-const targetPath = (targetDir: string, entry: DiscoveredEntry): string => {
-  if (entry.kind === 'skill') {
-    return join(targetDir, '.claude', 'skills', entry.name, 'SKILL.md')
-  }
-  return join(targetDir, '.github', 'instructions', `${entry.name}.instructions.md`)
-}
+/**
+ * Skills install into `.agents/skills/<name>/SKILL.md` — the canonical store of the
+ * Agent Skills standard, discovered natively by Copilot and Codex. Claude Code reads
+ * them through the per-skill symlinks in `.claude/skills/` that {@link applyInstall}
+ * maintains.
+ */
+const targetPath = (targetDir: string, entry: DiscoveredEntry): string =>
+  join(targetDir, '.agents', 'skills', entry.name, 'SKILL.md')
 
 export interface PlanOptions {
   /** Treat conflicts as 'overwrite' (--force). */

package/src/run.ts

@@ -18,25 +18,21 @@ const padEnd = (s: string, n: number): string => s + ' '.repeat(Math.max(0, n -
 
 const printTable = (items: InstallItem[]): void => {
   const colWidths = {
-    kind: 11,
-    name: Math.max(...items.map(i => i.entry.name.length), 4) + 2,
+    name: Math.max(...items.map(i => i.entry.name.length), 5) + 2,
     pkg: Math.max(...items.map(i => i.entry.packageName.length), 7) + 2,
     action: 10,
   }
 
   const header =
-    padEnd('kind', colWidths.kind) +
-    padEnd('name', colWidths.name) +
+    padEnd('skill', colWidths.name) +
     padEnd('package', colWidths.pkg) +
     'action'
   process.stdout.write(header + '\n')
   process.stdout.write('-'.repeat(header.length) + '\n')
 
   for (const item of items) {
-    const kindLabel = item.entry.kind === 'skill' ? 'skill' : 'instruction'
     const actionLabel = ACTION_LABEL[item.action]
     process.stdout.write(
-      padEnd(kindLabel, colWidths.kind) +
       padEnd(item.entry.name, colWidths.name) +
       padEnd(item.entry.packageName, colWidths.pkg) +
       actionLabel +
@@ -65,8 +61,8 @@ export const run = async (args: CliArgs): Promise<RunResult> => {
       process.stderr.write(
         `\nerror: linked monorepo detected — ${pkgList}${more} are symlinked.\n\n` +
         `In this setup, agents already load guidance from the linked monorepo's\n` +
-        `root .claude/skills/ and .github/instructions/. Installing embedded copies\n` +
-        `would place stale duplicates that conflict with the canonical live files.\n\n` +
+        `root AGENTS.md and .agents/skills/. Installing embedded copies would place\n` +
+        `stale duplicates that conflict with the canonical live files.\n\n` +
         `Pass --force only if you understand this and want to proceed anyway.\n\n`,
       )
       return { code: 4, message: 'linked monorepo' }
@@ -77,8 +73,6 @@ export const run = async (args: CliArgs): Promise<RunResult> => {
   const entries = discover(targetDir, {
     extras: args.extras,
     only: args.only.length > 0 ? args.only : undefined,
-    claudeOnly: args.claudeOnly,
-    copilotOnly: args.copilotOnly,
   })
 
   if (entries.length === 0) {
@@ -156,12 +150,15 @@ export const run = async (args: CliArgs): Promise<RunResult> => {
   }
 
   // 7. Apply
-  const result = applyInstall(resolvedItems)
+  const result = applyInstall(resolvedItems, targetDir)
 
   process.stdout.write(
     `Done: ${result.installed} installed, ${result.updated} updated, ` +
     `${result.skipped} up-to-date, ${result.conflicts} skipped (conflicts).\n`,
   )
+  if (result.linked > 0) {
+    process.stdout.write(`Linked ${result.linked} skill(s) into .claude/skills/ for Claude Code.\n`)
+  }
 
   return { code: 0 }
 }