@lythos/skill-deck 0.7.2 → 0.9.1

package/src/refresh.test.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env bun
+/**
+ * refresh.test.ts — unit tests for refresh.ts helpers
+ *
+ * Run: bun test packages/lythoskill-deck/src/refresh.test.ts
+ */
+
+import { describe, it, expect, afterEach, spyOn } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { execSync } from 'node:child_process'
+import * as childProcess from 'node:child_process'
+
+import { findGitRoot } from './refresh.ts'
+
+let cleanup: string[] = []
+let execSpy: ReturnType<typeof spyOn> | null = null
+
+afterEach(() => {
+  if (execSpy) {
+    execSpy.mockRestore()
+    execSpy = null
+  }
+  for (const dir of cleanup) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  cleanup = []
+})
+
+function makeTmp(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'deck-refresh-'))
+  cleanup.push(dir)
+  return dir
+}
+
+describe('findGitRoot', () => {
+  it('returns the directory itself when .git is directly present', () => {
+    const dir = makeTmp()
+    execSync('git init', { cwd: dir, stdio: 'ignore' })
+    const root = findGitRoot(dir, dir)
+    expect(root).not.toBeNull()
+    expect(realpathSync(root!)).toBe(realpathSync(dir))
+  })
+
+  it('finds git root in parent directory for monorepo layout', () => {
+    const repoDir = makeTmp()
+    const skillDir = join(repoDir, 'skills', 'my-skill')
+    mkdirSync(skillDir, { recursive: true })
+    execSync('git init', { cwd: repoDir, stdio: 'ignore' })
+    const root = findGitRoot(skillDir, repoDir)
+    expect(root).not.toBeNull()
+    expect(realpathSync(root!)).toBe(realpathSync(repoDir))
+  })
+
+  it('returns null for a non-git directory', () => {
+    const dir = makeTmp()
+    expect(findGitRoot(dir, dir)).toBeNull()
+  })
+})
+
+function initGitRepo(dir: string) {
+  execSync('git init', { cwd: dir, stdio: 'ignore' })
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'ignore' })
+  execSync('git config user.name "Test"', { cwd: dir, stdio: 'ignore' })
+  execSync('git commit --allow-empty -m "init"', { cwd: dir, stdio: 'ignore' })
+}
+
+function placeSkill(coldPool: string, relPath: string): string {
+  const skillDir = join(coldPool, relPath)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: fixture\n---\n')
+  return skillDir
+}
+
+function mockGitPull(status: 'up-to-date' | 'updated') {
+  const originalExecSync = childProcess.execSync
+  execSpy = spyOn(childProcess, 'execSync').mockImplementation(((cmd: string, options?: any) => {
+    if (cmd === 'git pull') {
+      return status === 'up-to-date'
+        ? 'Already up to date.\n'
+        : 'Updating abc123..def456\nFast-forward\n README.md | 1 +\n'
+    }
+    return originalExecSync(cmd, options)
+  }) as any)
+}
+
+describe('refreshDeck', () => {
+  it('C12: refresh all skills reports status for each cold pool repo', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const skillADir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+    const skillBDir = placeSkill(coldPool, 'github.com/owner/repo/skill-b')
+    initGitRepo(skillADir)
+    initGitRepo(skillBDir)
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n\n[tool.skills.skill-b]\npath = "github.com/owner/repo/skill-b"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    mockGitPull('up-to-date')
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const { refreshDeck } = await import('./refresh.ts')
+    refreshDeck(deckPath, projectDir)
+
+    logSpy.mockRestore()
+
+    expect(logs.some(l => l.includes('skill-a'))).toBe(true)
+    expect(logs.some(l => l.includes('skill-b'))).toBe(true)
+    expect(logs.some(l => l.includes('Up-to-date: 2'))).toBe(true)
+  })
+
+  it('C13: refresh single skill by alias only processes the target', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const skillADir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+    const skillBDir = placeSkill(coldPool, 'github.com/owner/repo/skill-b')
+    initGitRepo(skillADir)
+    initGitRepo(skillBDir)
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n\n[tool.skills.skill-b]\npath = "github.com/owner/repo/skill-b"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    mockGitPull('up-to-date')
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const { refreshDeck } = await import('./refresh.ts')
+    refreshDeck(deckPath, projectDir, 'skill-a')
+
+    logSpy.mockRestore()
+
+    expect(logs.some(l => l.includes('skill-a'))).toBe(true)
+    expect(logs.some(l => l.includes('skill-b'))).toBe(false)
+    expect(logs.some(l => l.includes('single skill'))).toBe(true)
+  })
+
+  it('C14: refresh with updated skills triggers linkDeck', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const skillADir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+    initGitRepo(skillADir)
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    mockGitPull('updated')
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const { refreshDeck } = await import('./refresh.ts')
+    refreshDeck(deckPath, projectDir)
+
+    logSpy.mockRestore()
+
+    expect(logs.some(l => l.includes('Running deck link'))).toBe(true)
+    expect(logs.some(l => l.includes('Updated: 1'))).toBe(true)
+  })
+
+  it('C15: refresh skips localhost skills', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const skillDir = placeSkill(coldPool, 'localhost/my-skill')
+    initGitRepo(skillDir)
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.local]\npath = "localhost/my-skill"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    mockGitPull('up-to-date')
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const { refreshDeck } = await import('./refresh.ts')
+    refreshDeck(deckPath, projectDir)
+
+    logSpy.mockRestore()
+
+    expect(logs.some(l => l.includes('local'))).toBe(true)
+    expect(logs.some(l => l.includes('Skipped: 1'))).toBe(true)
+  })
+
+  it('C16: refresh reports not-git for non-git directories', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+    // NO git init
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const { refreshDeck } = await import('./refresh.ts')
+    refreshDeck(deckPath, projectDir)
+
+    logSpy.mockRestore()
+
+    expect(logs.some(l => l.includes('not a git repository'))).toBe(true)
+  })
+
+  it('C17: refresh target not found exits with error', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    mkdirSync(coldPool, { recursive: true })
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const errors: string[] = []
+    const errorSpy = spyOn(console, 'error').mockImplementation((msg: string) => {
+      errors.push(String(msg))
+    })
+
+    const originalExit = process.exit
+    let exitCode: number | undefined
+    process.exit = ((code?: number) => {
+      exitCode = code ?? 0
+      throw new Error(`EXIT:${code}`)
+    }) as typeof process.exit
+
+    try {
+      const { refreshDeck } = await import('./refresh.ts')
+      refreshDeck(deckPath, projectDir, 'nonexistent')
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(1)
+      expect(errors.some(e => e.includes('not found'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      errorSpy.mockRestore()
+    }
+  })
+})

package/src/refresh.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+/**
+ * deck-refresh.ts — Refresh declared skills from their upstream sources
+ *
+ * Reads skill-deck.toml → traverses declared skills → git pull.
+ * Supports single-skill (by FQ path or alias) or all skills.
+ * Never modifies deck.toml.
+ */
+
+import { parse as parseToml } from "@iarna/toml";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { resolve, dirname, join, relative } from "node:path";
+import { findDeckToml, expandHome, findSource, linkDeck } from "./link.js";
+import { parseDeck } from "./parse-deck.js";
+
+interface RefreshResult {
+  name: string;
+  path: string;
+  status: "updated" | "up-to-date" | "skipped" | "failed" | "not-git";
+  message?: string;
+}
+
+export function findGitRoot(dir: string, coldPool: string): string | null {
+  // Standalone skill: .git directly in skill dir
+  if (existsSync(join(dir, ".git"))) {
+    return dir;
+  }
+
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+
+    const resolvedRoot = realpathSync(out);
+    const resolvedDir = realpathSync(dir);
+    const resolvedColdPool = realpathSync(coldPool);
+
+    // Must be an ancestor of dir (standalone case handled above)
+    if (!resolvedDir.startsWith(resolvedRoot + "/")) {
+      return null;
+    }
+
+    // Must be within cold_pool — prevents finding an unrelated git repo outside
+    if (resolvedRoot === resolvedColdPool || resolvedRoot.startsWith(resolvedColdPool + "/")) {
+      return out;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function gitPull(dir: string): { status: "updated" | "up-to-date" | "failed"; message: string } {
+  try {
+    const output = execSync("git pull", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30000,
+    }).trim();
+
+    if (output.includes("Already up to date") || output.includes("Already up-to-date")) {
+      return { status: "up-to-date", message: output };
+    }
+    return { status: "updated", message: output };
+  } catch (err: any) {
+    const stderr = err.stderr?.toString() || err.message || "";
+    return { status: "failed", message: stderr.trim() };
+  }
+}
+
+export function refreshDeck(cliDeckPath?: string, cliWorkdir?: string, target?: string): void {
+  const cliDeck = cliDeckPath || process.argv.find((_, i, a) => a[i - 1] === "--deck");
+  const DECK_PATH = cliDeck
+    ? resolve(cliDeck)
+    : findDeckToml(process.cwd()) || resolve("skill-deck.toml");
+
+  if (!existsSync(DECK_PATH)) {
+    console.error(`❌ skill-deck.toml not found in ${process.cwd()}`);
+    console.error(`\nCreate one or specify a path: bunx @lythos/skill-deck link --deck /path/to/deck.toml`);
+    process.exit(1);
+  }
+
+  const PROJECT_DIR = cliWorkdir ? resolve(cliWorkdir) : dirname(DECK_PATH);
+  const deckRaw = readFileSync(DECK_PATH, "utf-8");
+  const deck = parseToml(deckRaw) as any;
+
+  const COLD_POOL = expandHome(deck.deck?.cold_pool || "~/.agents/skill-repos", PROJECT_DIR);
+
+  // ── 收集声明 ────────────────────────────────────────────────
+
+  const declared: { name: string; alias: string; path: string; type: string }[] = [];
+
+  // Use parseDeck for alias-dict compatibility
+  const { entries: parsedEntries, deprecated: isDeprecated } = parseDeck(deckRaw);
+  if (isDeprecated) {
+    console.warn("⚠️  Deprecation: string-array skill entries are deprecated. Run `deck migrate-schema` to upgrade.");
+  }
+
+  for (const entry of parsedEntries) {
+    declared.push({ name: entry.path, alias: entry.alias, path: entry.path, type: entry.type });
+  }
+
+  if (declared.length === 0) {
+    console.log("📭 No skills declared in deck. Nothing to refresh.");
+    process.exit(0);
+  }
+
+  // ── 确定目标 ────────────────────────────────────────────────
+
+  let targets: { name: string; alias: string; path: string; type: string }[];
+
+  if (target) {
+    // Try resolve as alias first, then as FQ path
+    const byAlias = declared.find(d => d.alias === target);
+    if (byAlias) {
+      targets = [byAlias];
+    } else {
+      const byPath = declared.find(d => d.path === target);
+      if (byPath) {
+        targets = [byPath];
+      } else {
+        console.error(`❌ Skill not found in deck: ${target}`);
+        console.error(`   Declared aliases: ${declared.map(d => d.alias).join(", ")}`);
+        process.exit(1);
+      }
+    }
+  } else {
+    targets = declared;
+  }
+
+  // ── 执行刷新 ────────────────────────────────────────────────
+
+  const results: RefreshResult[] = [];
+  let updated = 0;
+  let upToDate = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const item of targets) {
+    const result = findSource(item.path, COLD_POOL, PROJECT_DIR);
+
+    if (result.error || !result.path) {
+      results.push({ name: item.alias, path: "", status: "failed", message: result.error || "Skill not found in cold pool" });
+      failed++;
+      continue;
+    }
+
+    const path = result.path;
+
+    // localhost skills are user-managed; skip
+    const relativePath = relative(COLD_POOL, path);
+    if (relativePath.startsWith("localhost")) {
+      results.push({ name: item.alias, path: relativePath, status: "skipped", message: "localhost skill — user-managed" });
+      skipped++;
+      continue;
+    }
+
+    const gitRoot = findGitRoot(path, COLD_POOL);
+    if (!gitRoot) {
+      results.push({ name: item.alias, path: relativePath, status: "not-git", message: "skipped: not a git repository" });
+      skipped++;
+      continue;
+    }
+
+    const pullResult = gitPull(gitRoot);
+    results.push({ name: item.alias, path: relativePath, status: pullResult.status, message: pullResult.message });
+
+    if (pullResult.status === "updated") updated++;
+    else if (pullResult.status === "up-to-date") upToDate++;
+    else failed++;
+  }
+
+  // ── 报告 ────────────────────────────────────────────────────
+
+  const scope = target ? `single skill` : `${declared.length} skill(s)`;
+  console.log(`\n📦 Skill Refresh Report — ${scope} checked`);
+  console.log(`   Updated: ${updated} | Up-to-date: ${upToDate} | Skipped: ${skipped} | Failed: ${failed}`);
+  console.log();
+
+  for (const r of results) {
+    const icon =
+      r.status === "updated" ? "🔄" :
+      r.status === "up-to-date" ? "✅" :
+      r.status === "skipped" ? "⏭️" :
+      r.status === "not-git" ? "📁" :
+      "❌";
+    console.log(`${icon} ${r.name}`);
+    if (r.message && r.status !== "up-to-date") {
+      const lines = r.message.split("\n").filter(l => l.trim());
+      for (const line of lines.slice(0, 3)) {
+        console.log(`   ${line.trim()}`);
+      }
+      if (lines.length > 3) {
+        console.log(`   ... (${lines.length - 3} more lines)`);
+      }
+    }
+  }
+
+  if (updated > 0) {
+    console.log(`\n💡 Run 'bunx @lythos/skill-deck link' to sync refreshed skills to working set.`);
+    console.log("🔗 Running deck link...");
+    linkDeck(cliDeckPath, cliWorkdir);
+  }
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}

package/src/remove.test.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env bun
+/**
+ * remove.test.ts — unit tests for remove.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/remove.test.ts
+ */
+
+import { describe, it, expect, afterEach, spyOn } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync, symlinkSync, lstatSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let cleanup: string[] = []
+
+afterEach(() => {
+  for (const dir of cleanup) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  cleanup = []
+})
+
+function makeTmp(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'deck-remove-'))
+  cleanup.push(dir)
+  return dir
+}
+
+function placeSkill(coldPool: string, relPath: string): string {
+  const skillDir = join(coldPool, relPath)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: fixture\n---\n')
+  return skillDir
+}
+
+function buildDeck(projectDir: string, coldPoolRel: string, alias: string, path: string): string {
+  const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.${alias}]\npath = "${path}"\n`
+  const deckPath = join(projectDir, 'skill-deck.toml')
+  writeFileSync(deckPath, deckContent)
+  return deckPath
+}
+
+describe('removeSkill', () => {
+  it('C9: remove by alias cleans deck.toml + symlink, preserves cold pool', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    const skillDir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+
+    const deckPath = buildDeck(projectDir, coldPoolRel, 'skill-a', 'github.com/owner/repo/skill-a')
+
+    const workingSet = join(projectDir, '.claude', 'skills')
+    mkdirSync(workingSet, { recursive: true })
+    symlinkSync(skillDir, join(workingSet, 'skill-a'))
+
+    const { removeSkill } = await import('./remove.ts')
+    removeSkill('skill-a', deckPath, projectDir)
+
+    const deckContent = readFileSync(deckPath, 'utf-8')
+    expect(deckContent).not.toContain('[tool.skills.skill-a]')
+    expect(deckContent).not.toContain('path = "github.com/owner/repo/skill-a"')
+
+    expect(existsSync(join(workingSet, 'skill-a'))).toBe(false)
+    expect(existsSync(skillDir)).toBe(true)
+    expect(existsSync(join(skillDir, 'SKILL.md'))).toBe(true)
+  })
+
+  it('C10: remove by FQ path cleans deck.toml + symlink, preserves cold pool', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    const skillDir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+
+    const deckPath = buildDeck(projectDir, coldPoolRel, 'skill-a', 'github.com/owner/repo/skill-a')
+
+    const workingSet = join(projectDir, '.claude', 'skills')
+    mkdirSync(workingSet, { recursive: true })
+    symlinkSync(skillDir, join(workingSet, 'skill-a'))
+
+    const { removeSkill } = await import('./remove.ts')
+    removeSkill('github.com/owner/repo/skill-a', deckPath, projectDir)
+
+    const deckContent = readFileSync(deckPath, 'utf-8')
+    expect(deckContent).not.toContain('[tool.skills.skill-a]')
+    expect(existsSync(join(workingSet, 'skill-a'))).toBe(false)
+    expect(existsSync(skillDir)).toBe(true)
+  })
+
+  it('C11: remove non-existent target exits with error', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    mkdirSync(coldPool, { recursive: true })
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const errors: string[] = []
+    const errorSpy = spyOn(console, 'error').mockImplementation((msg: string) => {
+      errors.push(String(msg))
+    })
+
+    const originalExit = process.exit
+    let exitCode: number | undefined
+    process.exit = ((code?: number) => {
+      exitCode = code ?? 0
+      throw new Error(`EXIT:${code}`)
+    }) as typeof process.exit
+
+    try {
+      const { removeSkill } = await import('./remove.ts')
+      removeSkill('not-in-deck', deckPath, projectDir)
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(1)
+      expect(errors.some(e => e.includes('Skill not found in deck'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      errorSpy.mockRestore()
+    }
+  })
+
+  it('C11.b: remove legacy string-array entry by alias', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    const skillDir = placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool]\nskills = ["github.com/owner/repo/skill-a"]\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const workingSet = join(projectDir, '.claude', 'skills')
+    mkdirSync(workingSet, { recursive: true })
+    symlinkSync(skillDir, join(workingSet, 'skill-a'))
+
+    const { removeSkill } = await import('./remove.ts')
+    removeSkill('skill-a', deckPath, projectDir)
+
+    const deckContentAfter = readFileSync(deckPath, 'utf-8')
+    expect(deckContentAfter).not.toContain('skills = [')
+    expect(existsSync(join(workingSet, 'skill-a'))).toBe(false)
+    expect(existsSync(skillDir)).toBe(true)
+  })
+})