@lythos/skill-deck 0.9.0 → 0.9.1

package/src/parse-deck.test.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+/**
+ * parse-deck.test.ts — unit tests for parse-deck.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/parse-deck.test.ts
+ */
+
+import { describe, it, expect } from 'bun:test'
+import { parseDeck } from './parse-deck.ts'
+
+describe('parseDeck', () => {
+  it('parses dict format entries', () => {
+    const raw = `[tool.skills.foo]\npath = "github.com/owner/repo"\n`
+    const result = parseDeck(raw)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].alias).toBe('foo')
+    expect(result.entries[0].path).toBe('github.com/owner/repo')
+    expect(result.entries[0].type).toBe('tool')
+    expect(result.deprecated).toBe(false)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('errors when dict entry lacks path', () => {
+    const raw = `[tool.skills.foo]\nname = "foo"\n`
+    const result = parseDeck(raw)
+    expect(result.errors.length).toBeGreaterThan(0)
+    expect(result.errors[0]).toContain('Missing path')
+  })
+
+  it('errors when dict entry has invalid schema', () => {
+    const raw = `[tool.skills.foo]\npath = ""\n`
+    const result = parseDeck(raw)
+    expect(result.errors.length).toBeGreaterThan(0)
+  })
+
+  it('parses legacy string-array format and marks deprecated', () => {
+    const raw = `[tool]\nskills = ["github.com/owner/repo"]\n`
+    const result = parseDeck(raw)
+    expect(result.deprecated).toBe(true)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].alias).toBe('repo')
+    expect(result.entries[0].path).toBe('github.com/owner/repo')
+    expect(result.entries[0].type).toBe('tool')
+  })
+
+  it('returns empty for deck with no skill sections', () => {
+    const raw = `[deck]\nmax_cards = 10\n`
+    const result = parseDeck(raw)
+    expect(result.entries).toHaveLength(0)
+    expect(result.deprecated).toBe(false)
+    expect(result.errors).toHaveLength(0)
+  })
+})

package/src/prune.test.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env bun
+/**
+ * prune.test.ts — unit tests for prune.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/prune.test.ts
+ */
+
+import { describe, it, expect, afterEach, spyOn } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } 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-prune-'))
+  cleanup.push(dir)
+  return dir
+}
+
+function placeRepo(coldPool: string, host: string, owner: string, repo: string): string {
+  const repoDir = join(coldPool, host, owner, repo)
+  mkdirSync(repoDir, { recursive: true })
+  return repoDir
+}
+
+function placeSkillInRepo(repoDir: string, skillName: string): string {
+  const skillDir = join(repoDir, 'skills', skillName)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: fixture\n---\n')
+  return skillDir
+}
+
+describe('pruneDeck', () => {
+  it('C15: prune with unreferenced repos deletes them when --yes is set', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const repoA = placeRepo(coldPool, 'github.com', 'owner', 'repo-a')
+    placeSkillInRepo(repoA, 'skill-a')
+
+    const repoB = placeRepo(coldPool, 'github.com', 'owner', 'repo-b')
+    placeSkillInRepo(repoB, 'skill-b')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo-a/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const { pruneDeck } = await import('./prune.ts')
+    await pruneDeck(deckPath, projectDir, true)
+
+    expect(existsSync(repoA)).toBe(true)
+    expect(existsSync(join(repoA, 'skills', 'skill-a', 'SKILL.md'))).toBe(true)
+
+    expect(existsSync(repoB)).toBe(false)
+  })
+
+  it('C16: prune with all referenced repos is a no-op', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const repoA = placeRepo(coldPool, 'github.com', 'owner', 'repo-a')
+    placeSkillInRepo(repoA, 'skill-a')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo-a/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 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 { pruneDeck } = await import('./prune.ts')
+      await pruneDeck(deckPath, projectDir, true)
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(0)
+      expect(logs.some(l => l.includes('Nothing to prune'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      logSpy.mockRestore()
+    }
+  })
+
+  it('C17: prune with empty cold pool reports nothing to prune', 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 logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.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 { pruneDeck } = await import('./prune.ts')
+      await pruneDeck(deckPath, projectDir, true)
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(0)
+      expect(logs.some(l => l.includes('empty'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      logSpy.mockRestore()
+    }
+  })
+})

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

@@ -8,7 +8,7 @@
  */
 
 import { parse as parseToml } from "@iarna/toml";
-import { existsSync, readFileSync } from "node:fs";
+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";
@@ -21,8 +21,37 @@ interface RefreshResult {
   message?: string;
 }
 
-function isGitRepo(dir: string): boolean {
-  return existsSync(join(dir, ".git"));
+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 } {
@@ -131,13 +160,14 @@ export function refreshDeck(cliDeckPath?: string, cliWorkdir?: string, target?:
       continue;
     }
 
-    if (!isGitRepo(path)) {
-      results.push({ name: item.alias, path: relativePath, status: "not-git", message: "Not a git repository" });
+    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(path);
+    const pullResult = gitPull(gitRoot);
     results.push({ name: item.alias, path: relativePath, status: pullResult.status, message: pullResult.message });
 
     if (pullResult.status === "updated") updated++;

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)
+  })
+})