@lythos/skill-deck 0.9.45 → 0.9.46

package/README.md

@@ -9,7 +9,7 @@
 This package exposes a **CLI**. Invoke via:
 
 ```bash
-bunx @lythos/skill-deck@0.9.45 <command> [options]
+bunx @lythos/skill-deck@0.9.46 <command> [options]
 ```
 
 No installation required. `bunx` auto-downloads the package.
@@ -55,17 +55,15 @@ prompt = "Search for latest info, then generate professional document with diagr
 
 | Situation | Command |
 |-----------|---------|
-| Sync working set with `skill-deck.toml` | `bunx @lythos/skill-deck@0.9.45 link` |
-| Validate `skill-deck.toml` before committing | `bunx @lythos/skill-deck@0.9.45 validate` |
-| Download a skill to cold pool and add to deck | `bunx @lythos/skill-deck@0.9.45 add owner/repo` |
-| Pull latest versions of declared skills | `bunx @lythos/skill-deck@0.9.45 refresh` |
-| Refresh a single skill by alias | `bunx @lythos/skill-deck@0.9.45 refresh tdd` |
-| Remove a skill from deck and working set | `bunx @lythos/skill-deck@0.9.45 remove tdd` |
-| GC unreferenced repos from cold pool | `bunx @lythos/skill-deck@0.9.45 prune` |
-| Switch skill from snapshot to sync mode | `bunx @lythos/skill-deck@0.9.45 sync tdd` |
-| Switch skill from sync to snapshot mode | `bunx @lythos/skill-deck@0.9.45 freeze tdd` |
-| Check cold pool for drift vs lock file | `bunx @lythos/skill-deck@0.9.45 reconcile` |
-| Use a custom deck file or working dir | `bunx @lythos/skill-deck@0.9.45 link --deck ./my-deck.toml --workdir /path/to/project` |
+| Sync working set with `skill-deck.toml` | `bunx @lythos/skill-deck@0.9.46 link` |
+| Validate `skill-deck.toml` before committing | `bunx @lythos/skill-deck@0.9.46 validate` |
+| Download a skill to cold pool and add to deck | `bunx @lythos/skill-deck@0.9.46 add owner/repo` |
+| Pull latest versions of declared skills | `bunx @lythos/skill-deck@0.9.46 refresh` |
+| Refresh a single skill by alias | `bunx @lythos/skill-deck@0.9.46 refresh tdd` |
+| Remove a skill from deck and working set | `bunx @lythos/skill-deck@0.9.46 remove tdd` |
+| Switch skill to symlink mode (live) | `bunx @lythos/skill-deck@0.9.46 to-symlink tdd` |
+| Switch skill to snapshot mode (pinned) | `bunx @lythos/skill-deck@0.9.46 to-snapshot tdd` |
+| Use a custom deck file or working dir | `bunx @lythos/skill-deck@0.9.46 link --deck ./my-deck.toml --workdir /path/to/project` |
 
 ### Commands
 
@@ -76,10 +74,8 @@ prompt = "Search for latest info, then generate professional document with diagr
 | `add` | `<locator> [--alias <alias>] [--type <type>] [--deck <path>]` | Git clone skill to cold pool and append to skill-deck.toml. |
 | `refresh` | `[<fq\|alias>] [--deck <path>]` | Pull latest versions of declared skills from upstream git repos. Pass a name to refresh one skill. |
 | `remove` | `<fq\|alias> [--deck <path>]` | Remove skill from deck.toml and working set. Cold pool untouched. |
-| `prune` | `[--yes] [--deck <path>]` | GC cold pool repos no longer referenced. Interactive confirm (skip with `--yes`). |
-| `sync` | `<alias> [--deck <path>] [--workdir <dir>]` | Switch skill from snapshot (real dir) to sync (symlink) — live mode. |
-| `freeze` | `<alias> [--deck <path>] [--workdir <dir>]` | Switch skill from sync (symlink) to snapshot (real dir) — pin current HEAD. |
-| `reconcile` | `[--apply] [--deck <path>] [--workdir <dir>]` | Compare lock vs cold pool, report drift (missing/behind/extra). Plan-first. |
+| `to-symlink` | `<alias> [--deck <path>] [--workdir <dir>]` | Switch a skill to symlink mode (live link, follows cold pool) |
+| `to-snapshot` | `<alias> [--deck <path>] [--workdir <dir>]` | Switch a skill to snapshot mode (pinned cp of current HEAD) |
 
 ### Options
 
@@ -96,7 +92,7 @@ prompt = "Search for latest info, then generate professional document with diagr
 
 `link` refuses to operate if `working_set` resolves to your home directory or root (`/`).
 
-**Snapshot mode** (`--mode snapshot` or `link --mode snapshot`): copies the source directory into the working set instead of symlinking. This is needed for agents that don't support symlinks (e.g. Codex #11314). Snapshots are pinned to the cold pool version at link time. Use `deck sync <alias>` to switch back to live symlink mode, or `deck freeze <alias>` to pin a symlink as a snapshot.
+**Snapshot mode** (`--mode snapshot` or `link --mode snapshot`): copies the source directory into the working set instead of symlinking. This is needed for agents that don't support symlinks (e.g. Codex #11314). Snapshots are pinned to the cold pool version at link time. Use `deck to-symlink <alias>` to switch back to symlink mode, or `deck to-snapshot <alias>` to pin a symlink as a snapshot.
 
 ### Exit codes
 
@@ -128,7 +124,7 @@ path = "github.com/lythos-labs/lythoskill/skills/lythoskill-deck"
 EOF
 
 # 2. Link — creates symlinks in .claude/skills/
-bunx @lythos/skill-deck@0.9.45 link
+bunx @lythos/skill-deck@0.9.46 link
 ```
 
 ### Key Concepts
@@ -214,7 +210,7 @@ Caution: deck's deny-by-default will remove any skills not declared in your deck
 
 | Symptom | Cause | Fix |
 |---------|-------|-----|
-| `❌ Skill not found: <name>` | Skill declared in deck but not in cold pool | `bunx @lythos/skill-deck@0.9.45 add github.com/owner/repo/skill` or clone manually into cold pool |
+| `❌ Skill not found: <name>` | Skill declared in deck but not in cold pool | `bunx @lythos/skill-deck@0.9.46 add github.com/owner/repo/skill` or clone manually into cold pool |
 | `link` skips entries with warnings | Real files/directories exist in working set (not symlinks) | Delete the real directories in `working_set` and re-run `link`. Never create directories manually there |
 | `refresh` reports "Not a git repository" | Skill was copied (not cloned) into cold pool | Re-clone with `git clone` or use `deck add` which clones by default |
 | `deck update` prints deprecation warning | `update` was renamed to `refresh` in v0.8+ | Use `deck refresh` instead |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lythos/skill-deck",
-  "version": "0.9.45",
+  "version": "0.9.46",
   "description": "Declarative skill deck governance — cold pool, working set, deny-by-default",
   "keywords": [
     "ai-agent",

package/src/COVERAGE-GAPS.md

@@ -15,7 +15,7 @@
 - `catch {}` silent ignore（fs 边界错误，测了也是 mock，无业务意义）
 - 需要 >1GB 文件才能触发的分支（formatSize GB）
 - 依赖外部 network 的分支（git clone 真实失败、skills.sh backend）
-- 交互式 CLI 分支（prune confirm()）
+- 交互式 CLI 分支（prune/reconcile 已移到 @lythos/cold-pool CLI）
 - 仅为凑分支覆盖率而进行的微重构（降低可读性）
 
 ---
@@ -68,20 +68,9 @@ link.ts 是 deck 包最大文件（~540 行）， uncovered 行最多。主要
 |----|------|-----------|--------|
 | 47–50 | legacy string-array `continue`（空 name） | 有意义但 trivial | ⬜ 低优先级 |
 
-## prune.ts — 80.43% lines
-
-| 行 | 代码 | 未覆盖原因 | 是否追 |
-|----|------|-----------|--------|
-| 25–27 | `formatSize` GB 分支 | 需 >1GB 文件 | ❌ 不追 |
-| 74 | `calculateDirSize` catch | `catch {}` | ❌ 不追 |
-| 81–87 | `scanColdPoolRepos` catch | `catch {}` | ❌ 不追 |
-| 98–100 | empty cold pool | **已覆盖** (C17) | ✅ |
-| 118–122 | all-referenced no-op | **已覆盖** (C16) | ✅ |
-| 129–130 | failed > 0 exit(1) | 需构造删除失败（权限不足） | ❌ 不追 |
-| 167 | formatSize MB 分支 | 正常路径已覆盖 | ✅ |
-| 172–173 | 删除失败 catch | `catch {}` | ❌ 不追 |
-| 185–186 | formatSize 边界 | 正常路径已覆盖 | ✅ |
+## prune.ts / reconcile.ts — removed
 
+prune 和 reconcile 命令已从 deck CLI 移除，迁移到 `@lythos/cold-pool` CLI。见 ADR-20260509144134332 FSM + ADR-202605091556237xx。
 ## refresh.ts — 88.97% lines
 
 | 行 | 代码 | 未覆盖原因 | 是否追 |

package/src/cli.ts

@@ -6,9 +6,7 @@ import { refreshDeck } from './refresh.js'
 import { updateDeck } from './update.js'
 import { migrateSchema } from './migrate-schema.js'
 import { removeSkill } from './remove.js'
-import { pruneDeck } from './prune.js'
-import { syncSkill, freezeSkill } from './sync-freeze.js'
-import { reconcileDeck } from './reconcile.js'
+import { toSymlinkSkill, toSnapshotSkill } from './to-symlink-snapshot.js'
 import { resolveDeckPathSync, fetchDeckUrl, isUrl } from './resolve-deck.js'
 import { formatHelp } from './help.js'
 
@@ -44,7 +42,6 @@ const alias = flagValue('--alias')
 const type = flagValue('--type')
 const format = flagValue('--format')
 const noBackup = args.includes('--no-backup')
-const yes = args.includes('--yes')
 const dryRun = args.includes('--dry-run')
 const remote = args.includes('--remote')
 const mode = flagValue('--mode') as 'symlink' | 'snapshot' | undefined
@@ -58,10 +55,8 @@ const HELP_CONFIG = {
     { name: 'refresh', description: 'Pull latest versions of declared skills from upstream', args: '[<fq|alias>]' },
     { name: 'validate', description: 'Validate deck configuration', args: '[deck.toml]' },
     { name: 'remove', description: 'Remove a skill from deck.toml and working set', args: '<fq|alias>' },
-    { name: 'prune', description: 'GC cold pool repos no longer referenced by any deck', args: '[--yes]' },
-    { name: 'sync', description: 'Switch skill from snapshot (cp) to sync (symlink)', args: '<alias>' },
-    { name: 'freeze', description: 'Switch skill from sync (symlink) to snapshot (cp), pinning current HEAD', args: '<alias>' },
-    { name: 'reconcile', description: 'Compare lock file vs cold pool, report drift', args: '[--apply] [--yes]' },
+    { name: 'to-symlink', description: 'Switch a skill to symlink mode (live link, follows cold pool)', args: '<alias>' },
+    { name: 'to-snapshot', description: 'Switch a skill to snapshot mode (pinned cp of current HEAD)', args: '<alias>' },
     { name: 'migrate-schema', description: 'Convert string-array deck.toml to alias-as-key dict', args: '[--dry-run]' },
   ],
   options: [
@@ -72,8 +67,8 @@ const HELP_CONFIG = {
 
     { flag: '--alias <name>', description: 'Explicit alias for the skill (default: basename of path)' },
     { flag: '--type <type>', description: 'Target section: innate | tool | combo (default: tool)' },
-    { flag: '--dry-run', description: 'Show plan without executing (add, prune)' },
-    { flag: '--yes', description: 'Skip interactive confirmation (for prune)' },
+    { flag: '--dry-run', description: 'Show plan without executing (add)' },
+    { flag: '--yes', description: 'Skip interactive confirmation' },
     { flag: '--remote', description: 'For validate: probe each FQ locator against api.github.com' },
     { flag: '--format <text|json>', description: 'For validate: output format (default: text)' },
   ],
@@ -121,31 +116,22 @@ switch (command) {
     removeSkill(removeTarget, deckPath, workdir)
     break
   }
-  case 'sync': {
-    const syncTarget = args[1] && !args[1].startsWith('-') ? args[1] : undefined
-    if (!syncTarget) {
-      console.error('❌ Missing target. Usage: deck sync <alias>')
+  case 'to-symlink': {
+    const target = args[1] && !args[1].startsWith('-') ? args[1] : undefined
+    if (!target) {
+      console.error('❌ Missing target. Usage: deck to-symlink <alias>')
       process.exit(1)
     }
-    syncSkill(syncTarget, deckPath, workdir)
+    toSymlinkSkill(target, deckPath, workdir)
     break
   }
-  case 'freeze': {
-    const freezeTarget = args[1] && !args[1].startsWith('-') ? args[1] : undefined
-    if (!freezeTarget) {
-      console.error('❌ Missing target. Usage: deck freeze <alias>')
+  case 'to-snapshot': {
+    const target = args[1] && !args[1].startsWith('-') ? args[1] : undefined
+    if (!target) {
+      console.error('❌ Missing target. Usage: deck to-snapshot <alias>')
       process.exit(1)
     }
-    freezeSkill(freezeTarget, deckPath, workdir)
-    break
-  }
-  case 'reconcile': {
-    const apply = args.includes('--apply')
-    await reconcileDeck(deckPath, workdir, apply, yes)
-    break
-  }
-  case 'prune': {
-    await pruneDeck(deckPath, workdir, yes)
+    toSnapshotSkill(target, deckPath, workdir)
     break
   }
   case 'migrate-schema': {

package/src/remove.ts

@@ -104,5 +104,5 @@ export function removeSkill(target: string, cliDeckPath?: string, cliWorkdir?: s
     console.warn(`⚠️  Metadata cleanup skipped: ${e.message}`);
   }
 
-  console.log(`\n💡 Cold pool untouched. Run 'bunx @lythos/skill-deck prune' to GC unreferenced repos.`);
+  console.log(`\n💡 Cold pool untouched. Run 'bunx @lythos/cold-pool prune' to GC unreferenced repos.`);
 }

package/src/{sync-freeze.test.ts → to-symlink-snapshot.test.ts}

@@ -2,12 +2,12 @@ import { describe, expect, test, beforeEach, afterEach } from 'bun:test'
 import { mkdirSync, mkdtempSync, writeFileSync, rmSync, symlinkSync, readFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { syncSkill, freezeSkill } from './sync-freeze'
+import { toSymlinkSkill, toSnapshotSkill } from './to-symlink-snapshot'
 import { cpSync, lstatSync } from 'node:fs'
 
 // Build a minimal project with a cold pool, deck.toml, working set, and lock
 function setupProject(opts: { mode: 'snapshot' | 'symlink' }) {
-  const project = mkdtempSync(join(tmpdir(), 'sync-freeze-test-'))
+  const project = mkdtempSync(join(tmpdir(), 'to-symlink-snapshot-test-'))
   const coldPool = join(project, 'cold-pool')
   const workingSet = join(project, '.claude', 'skills')
 
@@ -67,7 +67,7 @@ path = "github.com/test-org/test-skill"
   return { project, coldPool, workingSet, skillDir, deckPath, dest }
 }
 
-describe('syncSkill — snapshot → symlink', () => {
+describe('toSymlinkSkill — snapshot → symlink', () => {
   test('switches real dir to symlink', () => {
     const { deckPath, dest, project } = setupProject({ mode: 'snapshot' })
     const originalCwd = process.cwd
@@ -76,7 +76,7 @@ describe('syncSkill — snapshot → symlink', () => {
     try {
       process.cwd = () => project
       process.exit = (() => { throw new Error('exit') }) as any
-      syncSkill('test-skill', deckPath, project)
+      toSymlinkSkill('test-skill', deckPath, project)
     } catch (e: any) {
       if (e.message !== 'exit') throw e
     } finally {
@@ -97,7 +97,7 @@ describe('syncSkill — snapshot → symlink', () => {
     try {
       process.cwd = () => project
       process.exit = (() => { throw new Error('exit') }) as any
-      syncSkill('test-skill', deckPath, project)
+      toSymlinkSkill('test-skill', deckPath, project)
     } catch (e: any) {
       if (e.message !== 'exit') throw e
     } finally {
@@ -111,7 +111,7 @@ describe('syncSkill — snapshot → symlink', () => {
   })
 })
 
-describe('freezeSkill — symlink → snapshot', () => {
+describe('toSnapshotSkill — symlink → snapshot', () => {
   test('switches symlink to real dir', () => {
     const { deckPath, dest, project } = setupProject({ mode: 'symlink' })
     const originalCwd = process.cwd
@@ -120,7 +120,7 @@ describe('freezeSkill — symlink → snapshot', () => {
     try {
       process.cwd = () => project
       process.exit = (() => { throw new Error('exit') }) as any
-      freezeSkill('test-skill', deckPath, project)
+      toSnapshotSkill('test-skill', deckPath, project)
     } catch (e: any) {
       if (e.message !== 'exit') throw e
     } finally {
@@ -144,7 +144,7 @@ describe('freezeSkill — symlink → snapshot', () => {
     try {
       process.cwd = () => project
       process.exit = (() => { throw new Error('exit') }) as any
-      freezeSkill('test-skill', deckPath, project)
+      toSnapshotSkill('test-skill', deckPath, project)
     } catch (e: any) {
       if (e.message !== 'exit') throw e
     } finally {

package/src/{sync-freeze.ts → to-symlink-snapshot.ts}

@@ -1,9 +1,10 @@
 #!/usr/bin/env bun
 /**
- * deck sync/freeze — snapshot↔symlink intent switching per skill.
+ * deck to-symlink/to-snapshot — switch a skill's link mode in the working set.
  *
- * Per ADR-20260507190157540: snapshot = default safe (cp), sync = live (symlink).
- * These commands switch an individual skill between modes without re-linking all.
+ * Per ADR-20260507190157540: snapshot = default safe (cp, pinned), symlink = live (follows cold pool).
+ * Per ADR-20260509144134332: command verbs renamed from sync/freeze to to-symlink/to-snapshot
+ * to align with schema mode field and avoid collision with `deck link` (the reconcile primitive).
  */
 
 import { existsSync, readFileSync, writeFileSync, rmSync, symlinkSync, cpSync, lstatSync } from 'node:fs'
@@ -52,10 +53,10 @@ function getProjectAndDeck(cliDeckPath?: string, cliWorkdir?: string) {
 }
 
 /**
- * Switch a skill from snapshot (real dir) to sync (symlink).
- * The skill stays in a real directory if it's already not a symlink.
+ * Switch a skill to symlink mode (live link to cold pool source).
+ * No-op if the working set entry is already a symlink.
  */
-export function syncSkill(target: string, cliDeckPath?: string, cliWorkdir?: string): void {
+export function toSymlinkSkill(target: string, cliDeckPath?: string, cliWorkdir?: string): void {
   const { DECK_PATH, PROJECT_DIR, deckRaw, WORKING_SET, COLD_POOL } = getProjectAndDeck(cliDeckPath, cliWorkdir)
 
   const { entries: parsedEntries } = parseDeck(deckRaw)
@@ -81,7 +82,7 @@ export function syncSkill(target: string, cliDeckPath?: string, cliWorkdir?: str
   } catch {}
 
   if (currentMode === 'symlink') {
-    console.log(`⏭️  ${match.alias} is already in sync mode (symlink)`)
+    console.log(`⏭️  ${match.alias} is already in symlink mode`)
     return
   }
 
@@ -93,7 +94,7 @@ export function syncSkill(target: string, cliDeckPath?: string, cliWorkdir?: str
   // Remove snapshot, create symlink
   rmSync(dest, { recursive: true, force: true })
   symlinkSync(source.path, dest)
-  console.log(`🔄 ${match.alias}: snapshot → sync (symlink to ${relative(PROJECT_DIR, source.path)})`)
+  console.log(`🔄 ${match.alias}: snapshot → symlink (target: ${relative(PROJECT_DIR, source.path)})`)
 
   // Update lock
   const lock = readLock(PROJECT_DIR)
@@ -108,9 +109,10 @@ export function syncSkill(target: string, cliDeckPath?: string, cliWorkdir?: str
 }
 
 /**
- * Switch a skill from sync (symlink) to snapshot (real dir, pin current HEAD).
+ * Switch a skill to snapshot mode (pinned copy from cold pool source).
+ * No-op if the working set entry is already a real directory (not a symlink).
  */
-export function freezeSkill(target: string, cliDeckPath?: string, cliWorkdir?: string): void {
+export function toSnapshotSkill(target: string, cliDeckPath?: string, cliWorkdir?: string): void {
   const { DECK_PATH, PROJECT_DIR, deckRaw, WORKING_SET, COLD_POOL } = getProjectAndDeck(cliDeckPath, cliWorkdir)
 
   const { entries: parsedEntries } = parseDeck(deckRaw)
@@ -148,14 +150,14 @@ export function freezeSkill(target: string, cliDeckPath?: string, cliWorkdir?: s
   // Remove symlink, cp snapshot
   rmSync(dest, { recursive: true, force: true })
   cpSync(source.path, dest, { recursive: true })
-  console.log(`🧊 ${match.alias}: sync → snapshot (pinned copy from ${relative(PROJECT_DIR, source.path)})`)
+  console.log(`🧊 ${match.alias}: symlink → snapshot (pinned copy from ${relative(PROJECT_DIR, source.path)})`)
 
   // Record HEAD in metadata
   try {
     const loc = parseLocator(match.path)
     if (loc && !loc.isLocalhost) {
       const pool = new ColdPool(COLD_POOL)
-      // Best-effort: record a note that this is now frozen
+      // Best-effort: note that this is now pinned (snapshot mode)
       // The actual HEAD recording happens via git-hash async, but we note the intent
       console.log(`   📌 Pinned. Run 'deck link' to regenerate lock with updated content_hash.`)
     }

package/src/prune-plan.test.ts

@@ -1,103 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { resolvePruneConfig, scanColdPool, calculateDirSize, buildPrunePlan } from './prune-plan'
-
-const deckToml = `[deck]
-cold_pool = "./cold-pool"
-
-[tool.skills.skill-a]
-path = "github.com/foo/bar/skill-a"
-
-[tool.skills.skill-b]
-path = "localhost/me/skill-b"
-`
-
-describe('resolvePruneConfig', () => {
-  test('explicit paths override defaults', () => {
-    const cfg = resolvePruneConfig({
-      deckPath: '/tmp/deck.toml',
-      workdir: '/custom/work',
-      coldPool: '/custom/pool',
-    })
-    expect(cfg.deckPath).toBe('/tmp/deck.toml')
-    expect(cfg.workdir).toBe('/custom/work')
-    expect(cfg.coldPool).toBe('/custom/pool')
-  })
-})
-
-describe('scanColdPool', () => {
-  test('empty for nonexistent directory', () => {
-    expect(scanColdPool('/tmp/nonexistent-' + Date.now())).toEqual([])
-  })
-
-  test('finds flat localhost skills in cold pool', () => {
-    const pool = join('/tmp', 'prune-test-pool-' + Date.now())
-    mkdirSync(join(pool, 'skill-b'), { recursive: true })
-    writeFileSync(join(pool, 'skill-b', 'SKILL.md'), '# test')
-
-    const repos = scanColdPool(pool)
-    expect(repos.some(r => r.endsWith('skill-b'))).toBe(true)
-
-    rmSync(pool, { recursive: true, force: true })
-  })
-})
-
-describe('calculateDirSize', () => {
-  test('calculates total size', () => {
-    const dir = join('/tmp', 'size-test-' + Date.now())
-    mkdirSync(join(dir, 'sub'), { recursive: true })
-    writeFileSync(join(dir, 'a.txt'), 'hello')
-    writeFileSync(join(dir, 'sub', 'b.txt'), 'world')
-
-    const size = calculateDirSize(dir)
-    expect(size).toBeGreaterThanOrEqual(10) // 'hello' + 'world' = 10 bytes
-    rmSync(dir, { recursive: true, force: true })
-  })
-})
-
-describe('buildPrunePlan', () => {
-  test('builds plan from deck config', () => {
-    const plan = buildPrunePlan(deckToml, { coldPool: '/tmp/test-pool' })
-    expect(plan.declared).toHaveLength(2)
-    expect(plan.declared).toContain('github.com/foo/bar/skill-a')
-  })
-
-  test('identifies unreferenced repos as candidates', () => {
-    const pool = join('/tmp', 'prune-plan-test-' + Date.now())
-    // Create a declared repo
-    mkdirSync(join(pool, 'github.com', 'foo', 'bar', 'skill-a'), { recursive: true })
-    // Create an UNREFERENCED repo (not in deck)
-    mkdirSync(join(pool, 'github.com', 'baz', 'qux'), { recursive: true })
-
-    const plan = buildPrunePlan(deckToml, { coldPool: pool })
-    const unreferenced = plan.candidates.map(c => c.repoRel)
-    expect(unreferenced).toContain('github.com/baz/qux')
-    // skill-a is declared, should NOT be a candidate
-    expect(unreferenced).not.toContain('github.com/foo/bar/skill-a')
-
-    rmSync(pool, { recursive: true, force: true })
-  })
-
-  test('empty candidates when all repos declared', () => {
-    const pool = join('/tmp', 'prune-all-declared-' + Date.now())
-    mkdirSync(join(pool, 'github.com', 'foo', 'bar', 'skill-a'), { recursive: true })
-    mkdirSync(join(pool, 'localhost', 'me', 'skill-b'), { recursive: true })
-
-    const plan = buildPrunePlan(deckToml, { coldPool: pool })
-    expect(plan.candidates).toHaveLength(0)
-
-    rmSync(pool, { recursive: true, force: true })
-  })
-
-  test('totalSize is sum of candidate sizes', () => {
-    const pool = join('/tmp', 'prune-size-test-' + Date.now())
-    mkdirSync(join(pool, 'github.com', 'unref', 'repo'), { recursive: true })
-    writeFileSync(join(pool, 'github.com', 'unref', 'repo', 'data.txt'), 'hello world')
-
-    const plan = buildPrunePlan(deckToml, { coldPool: pool })
-    expect(plan.totalSize).toBeGreaterThanOrEqual(11)
-
-    rmSync(pool, { recursive: true, force: true })
-  })
-})

package/src/prune-plan.ts

@@ -1,210 +0,0 @@
-import { existsSync, readdirSync, statSync } from 'node:fs'
-import { resolve, join } from 'node:path'
-import { findDeckToml, expandHome } from './link'
-import { parseDeck } from './parse-deck'
-
-// ── Types ──────────────────────────────────────────────────────────────────
-
-export interface PruneCandidate {
-  repoPath: string
-  repoRel: string                  // relative to cold pool
-  size: number                     // bytes
-}
-
-export interface PrunePlan {
-  deckPath: string
-  workdir: string
-  coldPool: string
-  candidates: PruneCandidate[]     // unreferenced repos to delete
-  declared: string[]               // declared skill names (for audit)
-  totalSize: number                // total reclaimable bytes
-}
-
-// ── Config resolution ──────────────────────────────────────────────────────
-
-export function resolvePruneConfig(opts?: {
-  deckPath?: string
-  workdir?: string
-  coldPool?: string
-}) {
-  const deckPath = opts?.deckPath
-    ? resolve(opts.deckPath)
-    : (findDeckToml(process.cwd()) || resolve('skill-deck.toml'))
-
-  const workdir = opts?.workdir
-    ? resolve(opts.workdir)
-    : join(deckPath, '..')
-
-  const coldPool = opts?.coldPool
-    ? resolve(opts.coldPool)
-    : expandHome('~/.agents/skill-repos', workdir)
-
-  return { deckPath, workdir, coldPool }
-}
-
-// ── Cold pool scanner (pure: reads, no delete) ─────────────────────────────
-
-/**
- * Scan cold pool for skill repos.
- *
- * Layout convention (per ADR-20260502012643344):
- *   - `<coldPool>/localhost/<name>/SKILL.md`   — local skill
- *   - `<coldPool>/<host>/<owner>/<repo>/...`   — remote skill
- *
- * Legacy drift detection: a top-level dir `<coldPool>/<x>/SKILL.md` (with
- * SKILL.md directly, not under `localhost/`) is non-canonical state from
- * older agents that bypassed FQ-only enforcement. We surface it here so
- * prune's heredoc can list it as cleanup candidate; future writes should
- * never produce this shape.
- */
-export function scanColdPool(coldPool: string): string[] {
-  const repos: string[] = []
-  if (!existsSync(coldPool)) return repos
-
-  try {
-    for (const host of readdirSync(coldPool, { withFileTypes: true })) {
-      if (!host.isDirectory() || host.name.startsWith('.')) continue
-      const hostPath = join(coldPool, host.name)
-
-      // Localhost layout: <coldPool>/localhost/<name>/SKILL.md
-      if (host.name === 'localhost') {
-        for (const entry of readdirSync(hostPath, { withFileTypes: true })) {
-          if (!entry.isDirectory() || entry.name.startsWith('.')) continue
-          repos.push(join(hostPath, entry.name))
-        }
-        continue
-      }
-
-      // Legacy drift: top-level dir with SKILL.md (not canonical)
-      if (existsSync(join(hostPath, 'SKILL.md'))) {
-        repos.push(hostPath)
-        continue
-      }
-
-      // Nested: <coldPool>/<host>/<owner>/<repo>/
-      for (const owner of readdirSync(hostPath, { withFileTypes: true })) {
-        if (!owner.isDirectory() || owner.name.startsWith('.')) continue
-        const ownerPath = join(hostPath, owner.name)
-        for (const repo of readdirSync(ownerPath, { withFileTypes: true })) {
-          if (!repo.isDirectory() || repo.name.startsWith('.')) continue
-          repos.push(join(ownerPath, repo.name))
-        }
-      }
-    }
-  } catch {}
-
-  return repos
-}
-
-// ── Size calculation (pure helper) ─────────────────────────────────────────
-
-export function calculateDirSize(dir: string): number {
-  let total = 0
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const p = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        total += calculateDirSize(p)
-      } else if (entry.isFile()) {
-        total += statSync(p).size
-      }
-    }
-  } catch {}
-  return total
-}
-
-// ── Plan builder (pure: no deletion, no mutation) ──────────────────────────
-
-export function buildPrunePlan(
-  deckRaw: string,
-  opts?: { deckPath?: string; workdir?: string; coldPool?: string }
-): PrunePlan {
-  const { deckPath, workdir, coldPool: configuredColdPool } = resolvePruneConfig(opts)
-
-  // Read cold_pool from deck.toml if not explicitly overridden
-  let coldPool = configuredColdPool
-  if (!opts?.coldPool) {
-    const deckMatch = deckRaw.match(/cold_pool\s*=\s*"([^"]+)"/)
-    if (deckMatch) {
-      coldPool = expandHome(deckMatch[1], workdir)
-    }
-  }
-
-  // Get declared skill paths from deck
-  const { entries: declared } = parseDeck(deckRaw)
-  const declaredPaths = new Set(declared.map(d => d.path))
-
-  // Scan cold pool for all repos
-  const allRepos = scanColdPool(coldPool)
-
-  // Find unreferenced: repos not declared in deck
-  const candidates: PruneCandidate[] = []
-  for (const repoPath of allRepos) {
-    // A repo is referenced if any declared skill path starts with its cold-pool-relative path
-    const repoRel = repoPath.slice(coldPool.length + 1) // relative to cold pool
-    const isReferenced = [...declaredPaths].some(d => d.startsWith(repoRel) || repoRel.startsWith(d))
-
-    if (!isReferenced) {
-      candidates.push({
-        repoPath,
-        repoRel,
-        size: calculateDirSize(repoPath),
-      })
-    }
-  }
-
-  const totalSize = candidates.reduce((sum, c) => sum + c.size, 0)
-
-  return {
-    deckPath,
-    workdir,
-    coldPool,
-    candidates,
-    declared: declared.map(d => d.path),
-    totalSize,
-  }
-}
-
-// ── Execution (IO layer, injectable for testing) ───────────────────────────
-
-export interface PruneResult {
-  repoRel: string
-  deleted: boolean
-  error?: string
-}
-
-export interface PruneIO {
-  delete?: (path: string) => void
-  log?: (msg: string) => void
-  formatSize?: (bytes: number) => string
-}
-
-export function executePrunePlan(plan: PrunePlan, io?: PruneIO): PruneResult[] {
-  const deleteFn = io?.delete ?? ((_path: string) => { throw new Error('delete not injected') })
-  const log = io?.log ?? (() => {})
-  const fmtSize = io?.formatSize ?? ((b: number) => b < 1024 ? `${b}B` : b < 1024 * 1024 ? `${(b / 1024).toFixed(1)}KB` : `${(b / (1024 * 1024)).toFixed(1)}MB`)
-
-  log(`\n🧹 Prune candidates — ${plan.candidates.length} repo(s), ${fmtSize(plan.totalSize)} total:\n`)
-  for (const c of plan.candidates) {
-    log(`   ${c.repoRel} (${fmtSize(c.size)})`)
-  }
-
-  const results: PruneResult[] = []
-  let deleted = 0, failed = 0
-
-  for (const c of plan.candidates) {
-    try {
-      deleteFn(c.repoPath)
-      log(`  🗑️  Deleted: ${c.repoRel}`)
-      results.push({ repoRel: c.repoRel, deleted: true })
-      deleted++
-    } catch (err: any) {
-      log(`  ❌ Failed to delete ${c.repoRel}: ${err.message}`)
-      results.push({ repoRel: c.repoRel, deleted: false, error: err.message })
-      failed++
-    }
-  }
-
-  log(`\n📦 Prune complete: ${deleted} deleted, ${failed} failed`)
-  return results
-}

package/src/prune.test.ts

@@ -1,150 +0,0 @@
-#!/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, existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { formatSize } from './prune.ts'
-
-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('formatSize', () => {
-  it('formats bytes correctly at each boundary', () => {
-    expect(formatSize(0)).toBe('0B')
-    expect(formatSize(512)).toBe('512B')
-    expect(formatSize(1023)).toBe('1023B')
-    expect(formatSize(1024)).toBe('1.0KB')
-    expect(formatSize(1536)).toBe('1.5KB')
-    expect(formatSize(1048576)).toBe('1.0MB')
-    expect(formatSize(1073741824)).toBe('1.0GB')
-  })
-})
-
-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/skills/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/skills/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/prune.ts

@@ -1,161 +0,0 @@
-#!/usr/bin/env bun
-/**
- * deck-prune.ts — Cold pool garbage collection
- *
- * Scans the cold pool for repositories no longer referenced by any
- * skill-deck.toml declaration and offers to delete them.
- * Does NOT modify deck.toml or the working set.
- */
-
-import { existsSync, readFileSync, rmSync } from "node:fs";
-import { resolve } from "node:path";
-import { createInterface } from "node:readline";
-import { findDeckToml } from "./link.js";
-import { buildPrunePlan, executePrunePlan } from "./prune-plan.js";
-
-interface PruneCandidate {
-  repoPath: string;
-  repoRel: string;
-  size: number;
-}
-
-export function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
-}
-
-function calculateDirSize(dir: string): number {
-  let total = 0;
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const p = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        total += calculateDirSize(p);
-      } else if (entry.isFile()) {
-        total += statSync(p).size;
-      }
-    }
-  } catch {}
-  return total;
-}
-
-function scanColdPoolRepos(coldPool: string): string[] {
-  const repos: string[] = [];
-  try {
-    for (const host of readdirSync(coldPool, { withFileTypes: true })) {
-      if (!host.isDirectory() || host.name.startsWith(".")) continue;
-      const hostPath = join(coldPool, host.name);
-
-      // Flat skill: cold-pool/skill-name/ (localhost style)
-      if (existsSync(join(hostPath, "SKILL.md"))) {
-        repos.push(hostPath);
-        continue;
-      }
-
-      for (const owner of readdirSync(hostPath, { withFileTypes: true })) {
-        if (!owner.isDirectory() || owner.name.startsWith(".")) continue;
-        const ownerPath = join(hostPath, owner.name);
-
-        // Standalone repo: cold-pool/host.tld/owner/repo/
-        if (existsSync(join(ownerPath, "SKILL.md"))) {
-          repos.push(ownerPath);
-          continue;
-        }
-
-        for (const repo of readdirSync(ownerPath, { withFileTypes: true })) {
-          if (!repo.isDirectory() || repo.name.startsWith(".")) continue;
-          repos.push(join(ownerPath, repo.name));
-        }
-      }
-    }
-  } catch {}
-  return repos;
-}
-
-function isRepoReferenced(repoPath: string, declaredPaths: string[], coldPool: string, projectDir: string): boolean {
-  for (const path of declaredPaths) {
-    const result = findSource(path, coldPool, projectDir);
-    if (result.path) {
-      // Check if the resolved skill path is inside this repo
-      const rel = relative(repoPath, result.path);
-      if (!rel.startsWith("..") && rel !== "") {
-        return true;
-      }
-      if (result.path === repoPath) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-async function confirm(message: string): Promise<boolean> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${message} (y/N) `, (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
-  });
-}
-
-export async function pruneDeck(cliDeckPath?: string, cliWorkdir?: string, yes?: boolean): Promise<void> {
-  const deckPath = cliDeckPath || process.argv.find((_, i, a) => a[i - 1] === "--deck");
-  const workdir = cliWorkdir
-
-  const DECK_PATH = deckPath ? resolve(deckPath) : 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 deckRaw = readFileSync(DECK_PATH, 'utf-8')
-
-  // ── Plan: pure unreferenced detection ──────────────────────────────
-  const plan = buildPrunePlan(deckRaw, {
-    deckPath: DECK_PATH,
-    workdir: workdir ? resolve(workdir) : undefined,
-  })
-
-  if (!existsSync(plan.coldPool)) {
-    console.log('📭 Cold pool does not exist. Nothing to prune.')
-    process.exit(0)
-  }
-
-  if (plan.candidates.length === 0 && plan.declared.length === 0) {
-    console.log('📭 Cold pool is empty. Nothing to prune.')
-    process.exit(0)
-  }
-
-  if (plan.candidates.length === 0) {
-    console.log('✅ All cold pool repositories are referenced. Nothing to prune.')
-    process.exit(0)
-  }
-
-  // ── Confirm ──────────────────────────────────────────────────────
-  let shouldDelete = false
-  if (yes) {
-    shouldDelete = true
-    console.log('\n⚠️  --yes flag set: deleting without confirmation.')
-  } else {
-    shouldDelete = await confirm(`\nDelete ${plan.candidates.length} unreferenced repo(s)?`)
-  }
-
-  if (!shouldDelete) {
-    console.log('❎ Prune cancelled.')
-    process.exit(0)
-  }
-
-  // ── Execute with real IO ──────────────────────────────────────────
-  const results = executePrunePlan(plan, {
-    delete: (path: string) => rmSync(path, { recursive: true, force: true }),
-    log: console.log,
-    formatSize,
-  })
-
-  if (results.some(r => !r.deleted)) process.exit(1)
-}

package/src/reconcile.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import { mkdtempSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { reconcileDeck } from './reconcile.js'
-
-describe('reconcileDeck', () => {
-  let projectDir: string
-  let coldPoolDir: string
-
-  beforeEach(() => {
-    projectDir = mkdtempSync(join(tmpdir(), 'deck-reconcile-'))
-    coldPoolDir = join(projectDir, 'cold-pool')
-    mkdirSync(coldPoolDir, { recursive: true })
-  })
-
-  afterEach(() => {
-    // Cleanup handled by OS temp dir lifecycle
-  })
-
-  function writeLock(skills: any[]) {
-    const lock = {
-      version: '1.0.0' as const,
-      generated_at: new Date().toISOString(),
-      deck_source: { path: join(projectDir, 'skill-deck.toml'), content_hash: 'abc' },
-      working_set: '.claude/skills',
-      cold_pool: coldPoolDir,
-      skills,
-      constraints: {
-        total_cards: skills.length,
-        max_cards: 10,
-        within_budget: skills.length <= 10,
-        transient_warnings: [],
-        dir_overlaps: [],
-      },
-    }
-    writeFileSync(join(projectDir, 'skill-deck.lock'), JSON.stringify(lock, null, 2))
-  }
-
-  function writeDeck() {
-    writeFileSync(
-      join(projectDir, 'skill-deck.toml'),
-      `[deck]\ncold_pool = "${coldPoolDir}"\nworking_set = ".claude/skills"\n\n[tool.skills.test]\npath = "github.com/owner/repo/test"\n`
-    )
-  }
-
-  it('reports no drift when lock matches cold pool', async () => {
-    writeDeck()
-    writeLock([
-      {
-        name: 'test',
-        alias: 'test',
-        deck_niche: 'test',
-        type: 'tool',
-        source: 'github.com/owner/repo/test',
-        dest: join(projectDir, '.claude/skills/test'),
-        mode: 'symlink',
-        linked_at: new Date().toISOString(),
-        deck_managed_dirs: [],
-      },
-    ])
-
-    // No cold pool repo = missing, but that's fine for this test
-    // We just verify it doesn't crash
-    await reconcileDeck(join(projectDir, 'skill-deck.toml'), projectDir, false)
-  })
-
-  it('shows plan-only mode by default', async () => {
-    writeDeck()
-    writeLock([])
-
-    await reconcileDeck(join(projectDir, 'skill-deck.toml'), projectDir, false)
-  })
-
-  it('--apply requires --yes or TTY confirmation', async () => {
-    writeDeck()
-    writeLock([])
-
-    // With --yes, apply proceeds even without TTY
-    await reconcileDeck(join(projectDir, 'skill-deck.toml'), projectDir, true, true)
-  })
-})

package/src/reconcile.ts

@@ -1,239 +0,0 @@
-#!/usr/bin/env bun
-/**
- * deck reconcile — k8s-style desired vs actual convergence.
- *
- * Per ADR-20260507021957847: reads skill-deck.lock (desired state),
- * compares against cold pool filesystem (actual state), reports diff.
- * By default plan-first (report only); --apply executes convergence.
- */
-
-import { existsSync, readFileSync } from 'node:fs'
-import { resolve, dirname, join } from 'node:path'
-import { findDeckToml, expandHome } from './link.js'
-import { parse as parseToml } from '@iarna/toml'
-import { ColdPool, buildReconcilePlan, type ReconcileDesiredState, getRepoHeadRef } from '@lythos/cold-pool'
-import { SkillDeckLockSchema } from './schema.js'
-import { addSkill } from './add.js'
-import { refreshDeck } from './refresh.js'
-import { pruneDeck } from './prune.js'
-
-function isTTY(): boolean {
-  return process.stdin.isTTY && process.stdout.isTTY
-}
-
-async function promptYesNo(question: string): Promise<boolean> {
-  if (!isTTY()) return false
-  const { createInterface } = await import('node:readline')
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
-    rl.question(`${question} [y/N] `, (answer) => {
-      rl.close()
-      resolve(answer.trim().toLowerCase() === 'y')
-    })
-  })
-}
-
-export async function reconcileDeck(
-  cliDeckPath?: string,
-  cliWorkdir?: string,
-  apply?: boolean,
-  yes?: boolean,
-): Promise<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`)
-    process.exit(1)
-  }
-
-  const PROJECT_DIR = cliWorkdir ? resolve(cliWorkdir) : process.cwd()
-  const LOCK_PATH = resolve(PROJECT_DIR, 'skill-deck.lock')
-
-  if (!existsSync(LOCK_PATH)) {
-    console.error(`❌ No lock file found. Run 'deck link' first.`)
-    process.exit(1)
-  }
-
-  // Read lock
-  let lock: any
-  try {
-    lock = JSON.parse(readFileSync(LOCK_PATH, 'utf-8'))
-  } catch {
-    console.error(`❌ Failed to parse lock file: ${LOCK_PATH}`)
-    process.exit(1)
-  }
-
-  const parsed = SkillDeckLockSchema.safeParse(lock)
-  if (!parsed.success) {
-    console.error(`❌ Lock file schema mismatch. Run 'deck link' to regenerate.`)
-    process.exit(1)
-  }
-
-  const lockData = parsed.data
-  const coldPoolRaw = lockData.cold_pool || '~/.agents/skill-repos'
-  const COLD_POOL = expandHome(coldPoolRaw, PROJECT_DIR)
-
-  // Build alias → skill info map for locating missing skills
-  const skillByAlias = new Map<string, { source: string; type: string; mode: string }>()
-  for (const s of lockData.skills) {
-    skillByAlias.set(s.alias, { source: s.source, type: s.type, mode: s.mode })
-  }
-
-  // Build desired state from lock
-  const desired: ReconcileDesiredState = {
-    deckPath: DECK_PATH,
-    skills: lockData.skills.map((s) => ({
-      locator: s.source,
-      alias: s.alias,
-    })),
-  }
-
-  // Run reconcile plan
-  const pool = new ColdPool(COLD_POOL)
-  const plan = buildReconcilePlan(pool, desired)
-
-  // Report
-  console.log(`\n📊 Reconcile Report`)
-  console.log(`   Deck: ${lockData.deck_source.path}`)
-  console.log(`   Skills declared: ${lockData.skills.length}`)
-  console.log(`   Cold pool: ${COLD_POOL}`)
-
-  if (plan.missing.length === 0 && plan.behind.length === 0 && plan.extra.length === 0) {
-    console.log(`\n✅ No drift detected — cold pool matches desired state.`)
-    pool.metadata.close()
-    return
-  }
-
-  console.log(`\n🔍 Drift detected:`)
-  console.log(`   ❌ Missing: ${plan.missing.length}`)
-  console.log(`   ⚠️  Behind:  ${plan.behind.length}`)
-  console.log(`   📦 Extra:   ${plan.extra.length}`)
-
-  for (const entry of plan.missing) {
-    console.log(`\n   ❌ Missing: ${entry.host}/${entry.owner}/${entry.repo}`)
-    console.log(`      Reason: ${entry.reason}`)
-    console.log(`      Skills: ${entry.aliases.join(', ')}`)
-  }
-
-  for (const entry of plan.behind) {
-    console.log(`\n   ⚠️  Behind: ${entry.host}/${entry.owner}/${entry.repo}`)
-    console.log(`      ${entry.reason}`)
-    console.log(`      Skills: ${entry.aliases.join(', ')}`)
-  }
-
-  for (const entry of plan.extra) {
-    console.log(`\n   📦 Extra: ${entry.host}/${entry.owner}/${entry.repo}`)
-    console.log(`      Reason: ${entry.reason}`)
-  }
-
-  if (!apply) {
-    console.log(`\n💡 Plan-first. Use --apply to converge, or handle individually:`)
-    console.log(`   deck add <locator>   → restore missing`)
-    console.log(`   deck refresh         → update behind`)
-    console.log(`   cold-pool prune      → GC extras`)
-    pool.metadata.close()
-    return
-  }
-
-  // ── Apply convergence ────────────────────────────────────────────────
-
-  // Confirmation
-  if (!yes) {
-    const confirmed = await promptYesNo('\nApply these changes?')
-    if (!confirmed) {
-      console.log('❌ Aborted. No changes made.')
-      pool.metadata.close()
-      return
-    }
-  }
-
-  console.log(`\n🏗️  Applying convergence...`)
-
-  const failures: string[] = []
-
-  // 1. Missing → deck add
-  for (const entry of plan.missing) {
-    for (const alias of entry.aliases) {
-      const info = skillByAlias.get(alias)
-      if (!info) {
-        failures.push(`Missing skill info for alias: ${alias}`)
-        continue
-      }
-      try {
-        console.log(`   ➕ Adding ${alias}...`)
-        await addSkill(info.source, {
-          deck: DECK_PATH,
-          workdir: PROJECT_DIR,
-          alias,
-          type: info.type,
-          mode: info.mode as 'symlink' | 'snapshot',
-        })
-        console.log(`   ✅ Added ${alias}`)
-      } catch (e: any) {
-        failures.push(`Add ${alias}: ${e.message}`)
-        console.error(`   ❌ Failed to add ${alias}: ${e.message}`)
-      }
-    }
-  }
-
-  // 2. Behind → check actual HEAD vs recorded, then refresh if different
-  for (const entry of plan.behind) {
-    try {
-      const recordedRef = pool.metadata.getRepoRef(entry.host, entry.owner, entry.repo)
-      if (!recordedRef) {
-        console.log(`   ⏭️  Skipping ${entry.host}/${entry.owner}/${entry.repo} — no recorded HEAD`)
-        continue
-      }
-      const currentRef = await getRepoHeadRef(entry.repoPath)
-      if (currentRef === recordedRef) {
-        console.log(`   ✅ ${entry.host}/${entry.owner}/${entry.repo} is up to date (${currentRef.slice(0, 8)})`)
-        continue
-      }
-      console.log(`   🔄 Refreshing ${entry.host}/${entry.owner}/${entry.repo} (${recordedRef.slice(0, 8)} → ${currentRef.slice(0, 8)})...`)
-      // Refresh all aliases for this repo
-      for (const alias of entry.aliases) {
-        try {
-          refreshDeck(DECK_PATH, PROJECT_DIR, alias)
-          console.log(`   ✅ Refreshed ${alias}`)
-        } catch (e: any) {
-          failures.push(`Refresh ${alias}: ${e.message}`)
-          console.error(`   ❌ Failed to refresh ${alias}: ${e.message}`)
-        }
-      }
-    } catch (e: any) {
-      failures.push(`Behind ${entry.host}/${entry.owner}/${entry.repo}: ${e.message}`)
-      console.error(`   ❌ Failed to check/refresh ${entry.host}/${entry.owner}/${entry.repo}: ${e.message}`)
-    }
-  }
-
-  // 3. Extra → prune (global, only once)
-  if (plan.extra.length > 0) {
-    try {
-      console.log(`   🗑️  Pruning extras...`)
-      await pruneDeck(DECK_PATH, PROJECT_DIR, true)
-      console.log(`   ✅ Prune complete`)
-    } catch (e: any) {
-      failures.push(`Prune: ${e.message}`)
-      console.error(`   ❌ Prune failed: ${e.message}`)
-    }
-  }
-
-  // Summary
-  console.log(`\n📋 Convergence summary:`)
-  console.log(`   Missing resolved: ${plan.missing.length}`)
-  console.log(`   Behind resolved:  ${plan.behind.length}`)
-  console.log(`   Extra resolved:   ${plan.extra.length}`)
-  if (failures.length > 0) {
-    console.log(`   ❌ Failures: ${failures.length}`)
-    for (const f of failures) {
-      console.log(`      - ${f}`)
-    }
-  } else {
-    console.log(`   ✅ All operations successful`)
-  }
-
-  pool.metadata.close()
-}