claude-slim 2.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iops-leo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,234 @@
+<div align="center">
+
+# claude-slim
+
+**You're burning thousands of tokens before you even say "hello."**
+
+Every session loads *every* skill, memory file, and plugin instruction into the system prompt — even the ones you never use. claude-slim finds and removes that waste.
+
+```
+/claude-slim
+```
+
+[한국어](./docs/README.ko.md) | [日本語](./docs/README.ja.md) | [中文](./docs/README.zh.md)
+
+</div>
+
+---
+
+### The problem, visualized
+
+```
+  Session start token budget
+  ┌──────────────────────────────────────────────────┐
+  │██████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░│ Before claude-slim
+  │ 12K tokens consumed ↑    your actual work ↑      │
+  ├──────────────────────────────────────────────────┤
+  │██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │ After claude-slim
+  │ 5K ↑            more room for your work ↑        │
+  └──────────────────────────────────────────────────┘
+```
+
+Where the bloat hides:
+
+| Source | Typical overhead |
+|--------|:---:|
+| 60+ registered skills | ~3,000 tokens |
+| CLAUDE.md (plugin instructions) | ~5,000 tokens |
+| Memory files | ~2,500 tokens |
+| Deferred tools list | ~1,500 tokens |
+| **Total** | **~12,000 tokens** |
+
+That's slower responses. Hitting your usage cap faster. Paying for context you're not using.
+
+---
+
+## One command. Five steps.
+
+```
+/claude-slim
+```
+
+```
+ ┌────────┐   ┌──────────┐   ┌─────────┐   ┌─────────┐   ┌────────┐
+ │  Scan  │ → │ Classify │ → │ Propose │ → │  Clean  │ → │ Report │
+ │        │   │          │   │         │   │         │   │        │
+ │measure │   │ broken   │   │  you    │   │ move to │   │before  │
+ │ every  │   │ dupes    │   │ choose  │   │.disabled│   │  vs    │
+ │source  │   │ bloat    │   │  what   │   │  dir    │   │ after  │
+ └────────┘   └──────────┘   └─────────┘   └─────────┘   └────────┘
+```
+
+**Scan** — Measures everything: local skills, plugin skills, CLAUDE.md, memory files, MCP servers. Token counts are measured with [js-tiktoken](https://github.com/nicolo-ribaudo/js-tiktoken), not guessed.
+
+**Classify** — Finds the waste automatically:
+
+| | What it catches |
+|---|---|
+| Broken symlinks | Dead links from uninstalled skill packs |
+| Duplicates | Same skill registered from multiple sources |
+| Empty templates | Placeholder skills with no content |
+| Oversized files | SKILL.md over 10KB |
+| Stale memory | Large memory files loaded every session |
+| Disabled plugins | Installed but disabled plugins still in cache |
+| Stale projects | Project memory untouched for 90+ days |
+| Temp caches | Failed plugin install remnants (`temp_local_*`) |
+
+**Propose** — Three tiers, you decide:
+
+| Tier | Action | Example |
+|------|--------|---------|
+| **Auto** | Pre-selected | Broken symlinks, empty templates, temp caches |
+| **Recommended** | Suggested | Duplicates, stale memory, disabled plugins, stale projects |
+| **Optional** | Your call | Oversized skills you might still use |
+
+**Clean** — Moves selected items to `~/.claude/skills.disabled/`. **Nothing is deleted. Ever.**
+
+**Report** — Shows exactly what changed:
+
+```
+╭──────────────────────────────────────────╮
+│  claude-slim report                      │
+│                                          │
+│  Before: 14,510 tokens at startup        │
+│  After:   5,181 tokens at startup        │
+│  Saved:   9,329 tokens (64.3%)           │
+│                                          │
+│  Top offenders removed:                  │
+│  • office-hours              23,008 tok  │
+│  • harness                    7,902 tok  │
+│  • manpower                   4,764 tok  │
+│                                          │
+│  Est. monthly savings: ~$1.68            │
+│  (2 sessions/day × $0.003/1K tok)        │
+╰──────────────────────────────────────────╯
+
+  ┌──────────────────┬──────────┬──────────┬────────────┐
+  │                  │  Before  │  After   │  Saved     │
+  ├──────────────────┼──────────┼──────────┼────────────┤
+  │ Local skills     │    14    │     4    │  -10       │
+  │ System prompt    │   ~124   │   ~114   │  -10       │
+  │ Memory files     │  19.5KB  │   5.7KB  │  -13.8KB   │
+  │ Est. tokens      │ ~14,510  │  ~5,181  │  ~9,329    │
+  └──────────────────┴──────────┴──────────┴────────────┘
+```
+
+---
+
+## Install (10 seconds)
+
+```bash
+claude plugin marketplace add iops-leo/claude-slim
+claude plugin install claude-slim
+```
+
+Then just type `/claude-slim` in any session.
+
+Or use the standalone CLI:
+
+```bash
+npx claude-slim scan
+```
+
+---
+
+## Usage
+
+```bash
+/claude-slim              # Full pipeline: scan → propose → clean → report
+/claude-slim scan         # Report only, no changes
+/claude-slim scan --json  # Machine-readable JSON output
+/claude-slim restore      # Bring back anything you disabled
+```
+
+CLI equivalents:
+
+```bash
+npx claude-slim clean             # Full pipeline
+npx claude-slim clean --dry-run   # See what would happen (no changes)
+npx claude-slim clean --auto      # Non-interactive, Tier 1 only (CI/scripts)
+npx claude-slim scan              # Report only
+npx claude-slim restore           # Undo
+npx claude-slim report            # Show savings from last clean
+```
+
+---
+
+## Safety first
+
+| | |
+|---|---|
+| **Non-destructive** | Nothing is ever deleted. Disabled items move to `~/.claude/skills.disabled/` |
+| **Reversible** | `/claude-slim restore` brings anything back, any time |
+| **User-controlled** | Always asks before making changes. `--dry-run` to preview. |
+| **Hands off** | Never touches CLAUDE.md, settings.json, or plugin configs |
+
+---
+
+## How it works
+
+claude-slim scans these locations. No plugin-specific logic — pure filesystem analysis.
+
+```
+~/.claude/
+├── skills/                  ← user-installed skills
+├── plugins/cache/           ← plugin skills
+├── CLAUDE.md                ← system instructions (read-only)
+├── projects/*/memory/       ← auto-memory files
+└── settings.json            ← MCP server count (read-only)
+```
+
+Works with any setup: OMC, gstack, marketplace plugins, custom skills, or vanilla Claude Code.
+
+---
+
+## Real-world results
+
+From a real cleanup session:
+
+| Metric | Before | After | |
+|--------|:------:|:-----:|---|
+| Local skills | 65 | 15 | **-77%** |
+| System prompt skills | ~80 | ~48 | **-40%** |
+| Memory files | 15KB | 2KB | **-87%** |
+| **Est. token savings** | | **~4,300/session** | |
+
+---
+
+## v2.2 — What's new
+
+- **Atomic `stale_project` clean/restore** — Single directory `rename()` instead of per-file loop. No more partial-failure state if the operation is interrupted.
+- **Clear collision errors** — Cleaning a project whose backup already exists (or restoring onto an existing directory) now fails with an actionable message instead of a cryptic OS error.
+- **Manifest schema v2** — Single JSON file (`manifest.json`) containing only currently-disabled entries. Restore removes the entry entirely, so the manifest stays bounded across many clean/restore cycles.
+- **Automatic migration from v1** — Existing legacy manifests (`.claude-slim-manifest.jsonl`) are auto-migrated on first read; the original is preserved as `.jsonl.bak` for safety.
+- **Crash-safe manifest writes** — Write-to-tmp-then-rename pattern prevents partial-write corruption on power loss or SIGKILL.
+- **Expanded test coverage** — 66 tests (was 35). New round-trip tests per issue type: `broken_symlink`, `template`, `duplicate`, `skill_dup`, `oversized_skill`, `temp_cache`, `stale_project`. Plus manifest migration + bounded-growth cycle tests.
+
+## v2.0 — What's new
+
+- **TypeScript CLI** — Rewritten from bash. Faster, more accurate, extensible.
+- **Accurate token counting** — [js-tiktoken](https://github.com/nicolo-ribaudo/js-tiktoken) with `cl100k_base` encoding.
+- **Savings report box** — Visual before/after with breakdown table and monthly savings estimate.
+- **`--dry-run`** — Preview changes without making them.
+- **`--json`** — Machine-readable output for automation.
+- **Token cache** — Instant repeat scans.
+- **Standalone CLI** — `npx claude-slim` works outside Claude Code.
+- **`--auto`** — Non-interactive cleanup for CI/scripts (Tier 1 only).
+- **Disabled plugin detection** — Finds plugins you disabled but didn't uninstall.
+- **Stale project detection** — Flags project memory untouched for 90+ days.
+- **CLAUDE.md section breakdown** — See which plugin instructions cost the most tokens.
+- **Plugin status** — Shows enabled/disabled status for each plugin.
+- **Non-TTY support** — Auto-selects Tier 1 when stdin is piped.
+- **Unit tests** — Vitest-based.
+
+---
+
+## Requirements
+
+- Node.js 18+
+- macOS or Linux
+- Claude Code CLI
+
+## License
+
+MIT

package/dist/cleaner.d.ts

@@ -0,0 +1,11 @@
+import type { Issue, ManifestEntry } from './types.js';
+export interface CleanResult {
+    moved: ManifestEntry[];
+    skipped: string[];
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+export declare function cleanIssues(issues: Issue[]): Promise<CleanResult>;
+export declare function restoreItem(entry: ManifestEntry): Promise<void>;

package/dist/cleaner.js

@@ -0,0 +1,154 @@
+import { rename, readdir, rmdir, rm, unlink, lstat, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { appendManifest, ensureDisabledDir, getDisabledDir, removeEntry } from './manifest.js';
+import { getSkillsDir } from './paths.js';
+async function pathExists(p) {
+    try {
+        await lstat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function cleanIssues(issues) {
+    await ensureDisabledDir();
+    const disabledDir = getDisabledDir();
+    const moved = [];
+    const skipped = [];
+    const errors = [];
+    for (const issue of issues) {
+        try {
+            if (issue.type === 'broken_symlink') {
+                await unlink(issue.path);
+                const entry = {
+                    date: new Date().toISOString(),
+                    name: issue.name,
+                    from: issue.path,
+                    type: issue.type,
+                    tokenCount: issue.tokens,
+                    tier: issue.tier,
+                };
+                await appendManifest(entry);
+                moved.push(entry);
+            }
+            else if (issue.type === 'template' ||
+                issue.type === 'duplicate' ||
+                issue.type === 'skill_dup' ||
+                issue.type === 'oversized_skill') {
+                // Move skill directory to disabled — use name (not basename) to avoid namespace collisions
+                const safeName = issue.name.replace(/\//g, '--');
+                const dest = join(disabledDir, safeName);
+                await rename(issue.path, dest);
+                const entry = {
+                    date: new Date().toISOString(),
+                    name: issue.name,
+                    from: issue.path,
+                    type: issue.type,
+                    tokenCount: issue.tokens,
+                    tier: issue.tier,
+                };
+                await appendManifest(entry);
+                moved.push(entry);
+            }
+            else if (issue.type === 'temp_cache') {
+                // Delete temp directories (failed plugin installs, not restorable)
+                await rm(issue.path, { recursive: true, force: true });
+                const entry = {
+                    date: new Date().toISOString(),
+                    name: issue.name,
+                    from: issue.path,
+                    type: issue.type,
+                    tokenCount: 0,
+                    tier: issue.tier,
+                };
+                await appendManifest(entry);
+                moved.push(entry);
+            }
+            else if (issue.type === 'stale_project') {
+                const backupParent = join(disabledDir, 'memory-backup');
+                await mkdir(backupParent, { recursive: true });
+                const backupDir = join(backupParent, issue.name);
+                // Refuse to overwrite an existing backup — protects prior clean state
+                if (await pathExists(backupDir)) {
+                    throw new Error(`Backup already exists for "${issue.name}" at ${backupDir}. ` +
+                        `Restore or remove it before cleaning again.`);
+                }
+                // Atomic directory rename — requires same FS (guaranteed since both paths are under ~/.claude/)
+                await rename(issue.path, backupDir);
+                const entry = {
+                    date: new Date().toISOString(),
+                    name: issue.name,
+                    from: issue.path,
+                    type: issue.type,
+                    tokenCount: issue.tokens,
+                    tier: issue.tier,
+                };
+                await appendManifest(entry);
+                moved.push(entry);
+            }
+            else if (issue.type === 'oversized_memory' || issue.type === 'disabled_plugin') {
+                // Report only — user manages these manually
+                skipped.push(issue.name);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            errors.push({ name: issue.name, error: message });
+        }
+    }
+    // Clean empty directories in skills/
+    await cleanEmptyDirs(getSkillsDir());
+    return { moved, skipped, errors };
+}
+async function cleanEmptyDirs(dir) {
+    try {
+        const entries = await readdir(dir);
+        for (const entry of entries) {
+            const entryPath = join(dir, entry);
+            try {
+                const stats = await lstat(entryPath);
+                if (stats.isDirectory()) {
+                    await cleanEmptyDirs(entryPath);
+                    const remaining = await readdir(entryPath);
+                    if (remaining.length === 0) {
+                        await rmdir(entryPath);
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* skip */ }
+}
+export async function restoreItem(entry) {
+    if (entry.type === 'broken_symlink') {
+        throw new Error(`Broken symlinks cannot be restored (${entry.name})`);
+    }
+    if (entry.type === 'disabled_plugin') {
+        throw new Error(`Plugins must be reinstalled: claude plugin install ${entry.name}`);
+    }
+    if (entry.type === 'temp_cache') {
+        throw new Error(`Temp caches were deleted and cannot be restored (${entry.name})`);
+    }
+    const disabledDir = getDisabledDir();
+    if (entry.type === 'stale_project') {
+        const backupDir = join(disabledDir, 'memory-backup', entry.name);
+        // Refuse to overwrite user's current state
+        if (await pathExists(entry.from)) {
+            throw new Error(`Cannot restore: ${entry.from} already exists. ` +
+                `Remove or rename it first.`);
+        }
+        await mkdir(dirname(entry.from), { recursive: true });
+        // Atomic directory rename — requires same FS (guaranteed since both paths are under ~/.claude/)
+        await rename(backupDir, entry.from);
+    }
+    else {
+        // Restore skill directory using the same naming as cleanIssues
+        const safeName = entry.name.replace(/\//g, '--');
+        const src = join(disabledDir, safeName);
+        await mkdir(dirname(entry.from), { recursive: true });
+        await rename(src, entry.from);
+    }
+    await removeEntry(entry.name);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+import { Command } from 'commander';
+import { initTokenizer, flushCache } from './tokenizer.js';
+import { scan } from './scanner.js';
+import { cleanIssues, restoreItem } from './cleaner.js';
+import { readManifest } from './manifest.js';
+import { formatScanSummary, formatReportBox, calculateReport, } from './report.js';
+import { resolveSelection, resolveRestoreSelection } from './selection.js';
+const program = new Command();
+program
+    .name('claude-slim')
+    .description('Analyze and reduce Claude Code token overhead')
+    .version('2.2.0');
+// --- scan ---
+program
+    .command('scan')
+    .description('Scan environment and report issues')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+    await initTokenizer();
+    const result = await scan();
+    await flushCache();
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(formatScanSummary(result));
+    }
+});
+// --- clean ---
+program
+    .command('clean')
+    .description('Interactive cleanup of detected issues')
+    .option('--dry-run', 'Show what would happen without making changes')
+    .option('--auto', 'Non-interactive: auto-select Tier 1 items only')
+    .option('--sessions-per-day <n>', 'Sessions per day for savings estimate', '2')
+    .action(async (opts) => {
+    await runCleanPipeline({
+        dryRun: !!opts.dryRun,
+        auto: !!opts.auto,
+        sessionsPerDay: parseInt(opts.sessionsPerDay, 10) || 2,
+    });
+});
+// --- restore ---
+program
+    .command('restore')
+    .description('Restore previously disabled items')
+    .action(async () => {
+    const entries = await readManifest();
+    // v2 manifest contains only currently-disabled entries (restored ones are removed)
+    const disabled = entries.filter((e) => e.type !== 'broken_symlink');
+    const NON_RESTORABLE = new Set(['temp_cache', 'disabled_plugin']);
+    const restorable = disabled.filter((e) => !NON_RESTORABLE.has(e.type));
+    const infoOnly = disabled.filter((e) => NON_RESTORABLE.has(e.type));
+    if (restorable.length === 0 && infoOnly.length === 0) {
+        console.log('\n  Nothing to restore.\n');
+        return;
+    }
+    if (restorable.length > 0) {
+        console.log('\n  Restorable items:\n');
+        for (let i = 0; i < restorable.length; i++) {
+            const e = restorable[i];
+            const date = new Date(e.date).toLocaleDateString();
+            console.log(`    ${i + 1}. ${e.name} (${e.type}, disabled ${date})`);
+        }
+    }
+    if (infoOnly.length > 0) {
+        console.log('\n  \x1b[90mNon-restorable (for reference):\x1b[0m');
+        for (const e of infoOnly) {
+            const date = new Date(e.date).toLocaleDateString();
+            const hint = e.type === 'disabled_plugin'
+                ? `reinstall: claude plugin install ${e.name}`
+                : 'deleted, cannot restore';
+            console.log(`    \x1b[90m\u2022 ${e.name} (${date}) — ${hint}\x1b[0m`);
+        }
+    }
+    if (restorable.length === 0) {
+        console.log('\n  No items can be restored.\n');
+        return;
+    }
+    console.log('');
+    const selection = await askUser('  Restore (all / numbers / none): ');
+    const indices = resolveRestoreSelection(selection, restorable.length);
+    if (indices.length === 0) {
+        console.log('\n  Cancelled.\n');
+        return;
+    }
+    let restored = 0;
+    for (const idx of indices) {
+        try {
+            await restoreItem(restorable[idx]);
+            console.log(`  \x1b[32m\u2713\x1b[0m Restored: ${restorable[idx].name}`);
+            restored++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  \x1b[31m\u2717\x1b[0m ${restorable[idx].name}: ${msg}`);
+        }
+    }
+    console.log(`\n  Restored ${restored} item(s).\n`);
+});
+// --- report ---
+program
+    .command('report')
+    .description('Show savings report from last clean')
+    .option('--sessions-per-day <n>', 'Sessions per day for savings estimate', '2')
+    .action(async (opts) => {
+    await initTokenizer();
+    const result = await scan();
+    const entries = await readManifest();
+    const movedEntries = entries.filter((e) => e.tokenCount && e.tokenCount > 0);
+    if (movedEntries.length === 0) {
+        console.log('\n  No previous cleanup found. Run `claude-slim clean` first.\n');
+        await flushCache();
+        return;
+    }
+    const sessionsPerDay = parseInt(opts.sessionsPerDay, 10) || 2;
+    // Reconstruct "before" state: current + what was removed
+    const removedSkillCount = movedEntries.filter((e) => e.type !== 'oversized_memory').length;
+    const totalBefore = result.totalTokensBefore + removedSkillCount * 30;
+    const pseudoBefore = {
+        ...result,
+        totalTokensBefore: totalBefore,
+        localSkills: [
+            ...result.localSkills,
+            ...movedEntries
+                .filter((e) => e.type !== 'oversized_memory')
+                .map((e) => ({ name: e.name, path: e.from, sizeBytes: 0, tokens: e.tokenCount || 0, source: 'local' })),
+        ],
+    };
+    const reportData = calculateReport(pseudoBefore, result, movedEntries, sessionsPerDay);
+    console.log('');
+    console.log(formatReportBox(reportData));
+    console.log('');
+    await flushCache();
+});
+// --- default (no subcommand) → run clean ---
+program.action(async () => {
+    await runCleanPipeline({ dryRun: false, auto: false, sessionsPerDay: 2 });
+});
+// --- shared clean pipeline ---
+async function runCleanPipeline(opts) {
+    await initTokenizer();
+    const result = await scan();
+    if (result.issues.length === 0) {
+        console.log('\n  \x1b[32mAlready slim!\x1b[0m No issues found.\n');
+        await flushCache();
+        return;
+    }
+    console.log(formatScanSummary(result));
+    const isInteractive = !opts.auto && process.stdin.isTTY;
+    let selectedIssues;
+    if (isInteractive) {
+        console.log('  Actions:');
+        console.log('    Enter    \u2192 accept pre-selected (Tier 1 only)');
+        console.log('    1,3,5    \u2192 select specific items');
+        console.log('    all      \u2192 select everything');
+        console.log('    none     \u2192 cancel');
+        console.log('');
+        const selection = await askUser('  Your choice: ');
+        selectedIssues = resolveSelection(selection, result.issues);
+    }
+    else {
+        // Auto mode or non-TTY: select Tier 1 only
+        selectedIssues = result.issues.filter((i) => i.tier === 1);
+        if (!opts.auto) {
+            console.log('  \x1b[33m\u26a0 Non-interactive mode detected, auto-selecting Tier 1\x1b[0m\n');
+        }
+        else {
+            console.log(`  \x1b[36m\u2192 Auto mode: selecting ${selectedIssues.length} Tier 1 item(s)\x1b[0m\n`);
+        }
+    }
+    if (selectedIssues.length === 0) {
+        console.log('\n  Cancelled. No changes made.\n');
+        await flushCache();
+        return;
+    }
+    if (opts.dryRun) {
+        console.log('\n  \x1b[33m[DRY RUN]\x1b[0m Would disable:');
+        for (const issue of selectedIssues) {
+            console.log(`    \u2022 ${issue.name} (${issue.type})`);
+        }
+        console.log(`\n  Estimated token savings: ~${selectedIssues.reduce((s, i) => s + i.tokens, 0).toLocaleString()}`);
+        console.log('');
+        await flushCache();
+        return;
+    }
+    console.log('');
+    const cleanResult = await cleanIssues(selectedIssues);
+    // Re-scan after cleanup for accurate breakdown
+    const afterResult = await scan();
+    const reportData = calculateReport(result, afterResult, cleanResult.moved, opts.sessionsPerDay);
+    console.log('');
+    console.log(formatReportBox(reportData));
+    console.log('');
+    if (cleanResult.errors.length > 0) {
+        console.log('  \x1b[31mErrors:\x1b[0m');
+        for (const err of cleanResult.errors) {
+            console.log(`    \u2022 ${err.name}: ${err.error}`);
+        }
+        console.log('');
+    }
+    console.log(`  Recovery: ~/.claude/skills.disabled/`);
+    console.log(`  Restore:  npx claude-slim restore\n`);
+    await flushCache();
+}
+// --- helpers ---
+function askUser(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+program.parse();

package/dist/manifest.d.ts

@@ -0,0 +1,10 @@
+import type { Manifest, ManifestEntry } from './types.js';
+export declare function getDisabledDir(): string;
+export declare function ensureDisabledDir(): Promise<void>;
+export declare function migrateLegacyIfNeeded(): Promise<void>;
+export declare function readManifestV2(): Promise<Manifest>;
+export declare function writeManifestV2(manifest: Manifest): Promise<void>;
+export declare function addEntry(entry: ManifestEntry): Promise<void>;
+export declare function removeEntry(name: string): Promise<ManifestEntry | null>;
+export declare function readManifest(): Promise<ManifestEntry[]>;
+export declare function appendManifest(entry: ManifestEntry): Promise<void>;